API tools faq
paste
Advertisement
Guest User

Now with flashing!

a guest
Jul 20th, 2018
143
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 16.81 KB | None | 0 0
raw download clone embed print report
  1. #define FONT_WIDTH 8
  2. #define INTERCHAR_SPACE 1
  3. #define ASCII_OFFSET 0x20 // ASSCI code of 1st char in font array
  4.  
  5. String myMessage = " /c#CC00CCWelcome to /c#00CC00/bZillow/c#CC00CC!/b";
  6.  
  7. const uint8_t Font5x7[] PROGMEM = {
  8. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  9. 0x00,0x00,0x60,0xfa,0xfa,0x60,0x00,0x00,
  10. 0x00,0xc0,0xc0,0x00,0xc0,0xc0,0x00,0x00,
  11. 0x28,0xfe,0xfe,0x28,0xfe,0xfe,0x28,0x00,
  12. 0x24,0x74,0xd6,0xd6,0x5c,0x48,0x00,0x00,
  13. 0x62,0x66,0x0c,0x18,0x30,0x66,0x46,0x00,
  14. 0x0c,0x5e,0xf2,0xba,0xec,0x5e,0x12,0x00,
  15. 0x20,0xe0,0xc0,0x00,0x00,0x00,0x00,0x00,
  16. 0x00,0x38,0x7c,0xc6,0x82,0x00,0x00,0x00,
  17. 0x00,0x82,0xc6,0x7c,0x38,0x00,0x00,0x00,
  18. 0x10,0x54,0x7c,0x38,0x38,0x7c,0x54,0x10,
  19. 0x10,0x10,0x7c,0x7c,0x10,0x10,0x00,0x00,
  20. 0x00,0x01,0x07,0x06,0x00,0x00,0x00,0x00,
  21. 0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
  22. 0x00,0x00,0x06,0x06,0x00,0x00,0x00,0x00,
  23. 0x06,0x0c,0x18,0x30,0x60,0xc0,0x80,0x00,
  24. 0x7c,0xfe,0x8e,0x9a,0xb2,0xfe,0x7c,0x00,
  25. 0x02,0x42,0xfe,0xfe,0x02,0x02,0x00,0x00,
  26. 0x46,0xce,0x9a,0x92,0xf6,0x66,0x00,0x00,
  27. 0x44,0xc6,0x92,0x92,0xfe,0x6c,0x00,0x00,
  28. 0x18,0x38,0x68,0xca,0xfe,0xfe,0x0a,0x00,
  29. 0xe4,0xe6,0xa2,0xa2,0xbe,0x9c,0x00,0x00,
  30. 0x3c,0x7e,0xd2,0x92,0x9e,0x0c,0x00,0x00,
  31. 0xc0,0xc0,0x8e,0x9e,0xf0,0xe0,0x00,0x00,
  32. 0x6c,0xfe,0x92,0x92,0xfe,0x6c,0x00,0x00,
  33. 0x60,0xf2,0x92,0x96,0xfc,0x78,0x00,0x00,
  34. 0x00,0x00,0x66,0x66,0x00,0x00,0x00,0x00,
  35. 0x00,0x01,0x67,0x66,0x00,0x00,0x00,0x00,
  36. 0x10,0x38,0x6c,0xc6,0x82,0x00,0x00,0x00,
  37. 0x24,0x24,0x24,0x24,0x24,0x24,0x00,0x00,
  38. 0x00,0x82,0xc6,0x6c,0x38,0x10,0x00,0x00,
  39. 0x40,0xc0,0x8a,0x9a,0xf0,0x60,0x00,0x00,
  40. 0x7c,0xfe,0x82,0xba,0xba,0xf8,0x78,0x00,
  41. 0x3e,0x7e,0xc8,0xc8,0x7e,0x3e,0x00,0x00,
  42. 0x82,0xfe,0xfe,0x92,0x92,0xfe,0x6c,0x00,
  43. 0x38,0x7c,0xc6,0x82,0x82,0xc6,0x44,0x00,
  44. 0x82,0xfe,0xfe,0x82,0xc6,0x7c,0x38,0x00,
  45. 0x82,0xfe,0xfe,0x92,0xba,0x82,0xc6,0x00,
  46. 0x82,0xfe,0xfe,0x92,0xb8,0x80,0xc0,0x00,
  47. 0x38,0x7c,0xc6,0x82,0x8a,0xce,0x4e,0x00,
  48. 0xfe,0xfe,0x10,0x10,0xfe,0xfe,0x00,0x00,
  49. 0x00,0x82,0xfe,0xfe,0x82,0x00,0x00,0x00,
  50. 0x0c,0x0e,0x02,0x82,0xfe,0xfc,0x80,0x00,
  51. 0x82,0xfe,0xfe,0x10,0x38,0xee,0xc6,0x00,
  52. 0x82,0xfe,0xfe,0x82,0x02,0x06,0x0e,0x00,
  53. 0xfe,0xfe,0x70,0x38,0x70,0xfe,0xfe,0x00,
  54. 0xfe,0xfe,0x60,0x30,0x18,0xfe,0xfe,0x00,
  55. 0x38,0x7c,0xc6,0x82,0xc6,0x7c,0x38,0x00,
  56. 0x82,0xfe,0xfe,0x92,0x90,0xf0,0x60,0x00,
  57. 0x78,0xfc,0x84,0x8e,0xfe,0x7a,0x00,0x00,
  58. 0x82,0xfe,0xfe,0x90,0x98,0xfe,0x66,0x00,
  59. 0x64,0xf6,0xb2,0x9a,0xce,0x4c,0x00,0x00,
  60. 0xc0,0x82,0xfe,0xfe,0x82,0xc0,0x00,0x00,
  61. 0xfe,0xfe,0x02,0x02,0xfe,0xfe,0x00,0x00,
  62. 0xf8,0xfc,0x06,0x06,0xfc,0xf8,0x00,0x00,
  63. 0xfe,0xfe,0x0c,0x18,0x0c,0xfe,0xfe,0x00,
  64. 0xc2,0xe6,0x3c,0x18,0x3c,0xe6,0xc2,0x00,
  65. 0xe0,0xf2,0x1e,0x1e,0xf2,0xe0,0x00,0x00,
  66. 0xe2,0xc6,0x8e,0x9a,0xb2,0xe6,0xce,0x00,
  67. 0x00,0xfe,0xfe,0x82,0x82,0x00,0x00,0x00,
  68. 0x80,0xc0,0x60,0x30,0x18,0x0c,0x06,0x00,
  69. 0x00,0x82,0x82,0xfe,0xfe,0x00,0x00,0x00,
  70. 0x10,0x30,0x60,0xc0,0x60,0x30,0x10,0x00,
  71. 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
  72. 0x00,0x00,0xc0,0xe0,0x20,0x00,0x00,0x00,
  73. 0x04,0x2e,0x2a,0x2a,0x3c,0x1e,0x02,0x00,
  74. 0x82,0xfe,0xfc,0x12,0x12,0x1e,0x0c,0x00,
  75. 0x1c,0x3e,0x22,0x22,0x36,0x14,0x00,0x00,
  76. 0x0c,0x1e,0x12,0x92,0xfc,0xfe,0x02,0x00,
  77. 0x1c,0x3e,0x2a,0x2a,0x3a,0x18,0x00,0x00,
  78. 0x12,0x7e,0xfe,0x92,0xc0,0x40,0x00,0x00,
  79. 0x19,0x3d,0x25,0x25,0x1f,0x3e,0x20,0x00,
  80. 0x82,0xfe,0xfe,0x10,0x20,0x3e,0x1e,0x00,
  81. 0x00,0x22,0xbe,0xbe,0x02,0x00,0x00,0x00,
  82. 0x06,0x07,0x01,0x01,0xbf,0xbe,0x00,0x00,
  83. 0x82,0xfe,0xfe,0x08,0x1c,0x36,0x22,0x00,
  84. 0x00,0x82,0xfe,0xfe,0x02,0x00,0x00,0x00,
  85. 0x3e,0x3e,0x18,0x1c,0x38,0x3e,0x1e,0x00,
  86. 0x3e,0x3e,0x20,0x20,0x3e,0x1e,0x00,0x00,
  87. 0x1c,0x3e,0x22,0x22,0x3e,0x1c,0x00,0x00,
  88. 0x21,0x3f,0x1f,0x25,0x24,0x3c,0x18,0x00,
  89. 0x18,0x3c,0x24,0x25,0x1f,0x3f,0x21,0x00,
  90. 0x22,0x3e,0x1e,0x32,0x20,0x38,0x18,0x00,
  91. 0x12,0x3a,0x2a,0x2a,0x2e,0x24,0x00,0x00,
  92. 0x00,0x20,0x7c,0xfe,0x22,0x24,0x00,0x00,
  93. 0x3c,0x3e,0x02,0x02,0x3c,0x3e,0x02,0x00,
  94. 0x38,0x3c,0x06,0x06,0x3c,0x38,0x00,0x00,
  95. 0x3c,0x3e,0x0e,0x1c,0x0e,0x3e,0x3c,0x00,
  96. 0x22,0x36,0x1c,0x08,0x1c,0x36,0x22,0x00,
  97. 0x39,0x3d,0x05,0x05,0x3f,0x3e,0x00,0x00,
  98. 0x32,0x26,0x2e,0x3a,0x32,0x26,0x00,0x00,
  99. 0x10,0x10,0x7c,0xee,0x82,0x82,0x00,0x00,
  100. 0x00,0x00,0x00,0xee,0xee,0x00,0x00,0x00,
  101. 0x82,0x82,0xee,0x7c,0x10,0x10,0x00,0x00,
  102. 0x40,0xc0,0x80,0xc0,0x40,0xc0,0x80,0x00,
  103. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
  104. };
  105.  
  106. #define PIXELS 60*4 // Number of pixels in the string. I am using 4 meters of 96LED/M
  107.  
  108. #define PIXEL_PORT PORTD // Port of the pin the pixels are connected to
  109. #define PIXEL_DDR DDRD // Port of the pin the pixels are connected to
  110.  
  111. #define READY_FOR_MESSAGE_SIGNAL "READYMESSAGE#_-#CANARY#_-#READYMESSAGE"
  112.  
  113. #define BAUD_RATE 9600
  114.  
  115. #define WAIT_FOR_INPUT_DURATION 100
  116.  
  117. #define DEBUG false
  118.  
  119. static const uint8_t onBits = 0b11111111; // Bit pattern to write to port to turn on all pins connected to LED strips.
  120.  
  121. // Phase #1 - Always 1 - 5 cycles, Phase #2 - Data part - 8 cycles, Phase #3 - Always 0 - 7 cycles
  122. #define T1H 814 // Width of a 1 bit in ns - 13 cycles
  123. #define T1L 438 // Width of a 1 bit in ns - 7 cycles
  124.  
  125. #define T0H 312 // Width of a 0 bit in ns - 5 cycles
  126. #define T0L 936 // Width of a 0 bit in ns - 15 cycles
  127.  
  128. #define RES 500000 // Width of the low gap between bits to cause a frame to latch
  129. #define NS_PER_SEC (1000000000L) // Note that this has to be SIGNED since we want to be able to check for negative values of derivatives
  130. #define CYCLES_PER_SEC (F_CPU)
  131. #define NS_PER_CYCLE ( NS_PER_SEC / CYCLES_PER_SEC )
  132. #define NS_TO_CYCLES(n) ( (n) / NS_PER_CYCLE )
  133.  
  134. struct FormattingState {
  135. uint8_t red;
  136. uint8_t green;
  137. uint8_t blue;
  138. bool isBlinkEnabled;
  139. bool isEscapedSlash;
  140. };
  141.  
  142. struct FormattingState currentFormattingState;
  143. struct FormattingState startOfOutputFormattingState;
  144.  
  145. bool isBlinkFrame;
  146.  
  147. void setup() {
  148. PIXEL_DDR |= onBits; // Set used pins to output mode
  149.  
  150. // initialize formatting state
  151. currentFormattingState.red = 0x00;
  152. currentFormattingState.green = 0x00;
  153. currentFormattingState.blue = 0x40;
  154. currentFormattingState.isBlinkEnabled = false;
  155. currentFormattingState.isEscapedSlash = false;
  156. startOfOutputFormattingState = currentFormattingState;
  157. }
  158.  
  159. void loop() {
  160. const char* pMessage = myMessage.c_str();
  161.  
  162. while (*pMessage) {
  163.  
  164. // restore the startOfOutputFormattingState (since we're starting to output the message again)
  165. currentFormattingState = startOfOutputFormattingState;
  166.  
  167. // process the escape characters at the current position of the message
  168. pMessage = processEscapeCharacters(pMessage);
  169.  
  170. // after processing escape characters, it's possible that we are now at the end of our string, in which case stop
  171. if (!*pMessage) {
  172. break;
  173. }
  174.  
  175. // update the startOfOutputFormatting state in case it has now changed
  176. startOfOutputFormattingState = currentFormattingState;
  177.  
  178. // step though each column of the 1st char for smooth scrolling
  179. for (uint8_t step = 0; step < FONT_WIDTH + INTERCHAR_SPACE ; step++) {
  180.  
  181. // toggle the isBlinkFrame (for any blinking text)
  182. isBlinkFrame = !isBlinkFrame;
  183.  
  184. noInterrupts();
  185.  
  186. sendString(pMessage, step);
  187.  
  188. interrupts();
  189.  
  190. delay(10);
  191. }
  192.  
  193. pMessage++;
  194. }
  195.  
  196. requestNewMessage();
  197. }
  198.  
  199. // Show the passed string. The last letter of the string will be in the rightmost pixels of the display.
  200. // Skip is how many cols of the 1st char to skip for smooth scrolling
  201. static inline void sendString(const char *str , uint8_t skip) {
  202.  
  203. unsigned int maximumNumberOfVisibleCharacters = PIXELS / (FONT_WIDTH + INTERCHAR_SPACE);
  204.  
  205. // First char is special case because it can be stepped for smooth scrolling
  206. sendChar(*str, skip, currentFormattingState.red, currentFormattingState.green, currentFormattingState.blue);
  207.  
  208. while (++str && maximumNumberOfVisibleCharacters-- > 0) {
  209. str = processEscapeCharacters(str);
  210.  
  211. // after processing escape characters, it's possible that we are now at the end of our string, in which case stop
  212. if(!*str) {
  213. break;
  214. }
  215.  
  216. sendChar(*str, 0, currentFormattingState.red, currentFormattingState.green, currentFormattingState.blue);
  217. }
  218.  
  219. show();
  220. }
  221.  
  222. // Send the pixels to form the specified char, not including interchar space
  223. // skip is the number of pixels to skip at the begining to enable sub-char smooth scrolling
  224. // TODO: Subtract the offset from the char before starting the send sequence to save time if nessisary
  225. // TODO: Also could pad the begining of the font table to aovid the offset subtraction at the cost of 20*8 bytes of progmem
  226. // TODO: Could pad all chars out to 8 bytes wide to turn the the multiply by FONT_WIDTH into a shift
  227. static inline void sendChar(uint8_t character, uint8_t skip, uint8_t r, uint8_t g, uint8_t b) {
  228.  
  229. const uint8_t *charbase = Font5x7 + (( character - ' ') * FONT_WIDTH ) ;
  230.  
  231. uint8_t col = FONT_WIDTH;
  232.  
  233. while (skip--) {
  234. charbase++;
  235. col--;
  236. }
  237.  
  238. while (col--) {
  239. sendRowRGB(pgm_read_byte_near(charbase++), r, g, b);
  240. }
  241.  
  242. col = INTERCHAR_SPACE;
  243.  
  244. while (col--) {
  245. sendRowRGB(0, r, g, b); // Interchar space
  246. }
  247. }
  248.  
  249. // Send 3 bytes of color data (R,G,B) for a signle pixel down all the connected stringsat the same time
  250. // A 1 bit in "row" means send the color, a 0 bit means send black.
  251. static inline void sendRowRGB( uint8_t row, uint8_t r, uint8_t g, uint8_t b ) {
  252. // on a blink frame when blink is enabled, don't draw anything for this row
  253. if (currentFormattingState.isBlinkEnabled && isBlinkFrame) {
  254. row = 0;
  255. }
  256.  
  257. if (DEBUG) {
  258. // output to serial for testing
  259. printRowToSerial(row);
  260. }
  261.  
  262. sendBitx8(row, g , onBits); // WS2812 takes colors in GRB order
  263. sendBitx8(row, r , onBits); // WS2812 takes colors in GRB order
  264. sendBitx8(row, b , onBits); // WS2812 takes colors in GRB order
  265. }
  266.  
  267. // Sends a full 8 bits down all the pins, represening a single color of 1 pixel
  268. // We walk though the 8 bits in colorbyte one at a time. If the bit is 1 then we send the 8 bits of row out. Otherwise we send 0.
  269. // We send onBits at the first phase of the signal generation. We could just send 0xff, but that mught enable pull-ups on pins that we are not using.
  270.  
  271.  
  272. // OnBits is the mask of which bits are connected to strips. We pass it on so that we
  273. // do not turn on unused pins becuase this would enable the pullup. Also, hopefully passing this
  274. // will cause the compiler to allocate a Register for it and avoid a reload every pass.
  275. static inline void sendBitx8(const uint8_t row, const uint8_t colorbyte, const uint8_t onBits) {
  276.  
  277. asm volatile (
  278.  
  279. "L_%=: \n\r"
  280.  
  281. "out %[port], %[onBits] \n\t" // (1 cycles) - send either T0H or the first part of T1H. Onbits is a mask of which bits have strings attached.
  282.  
  283. // Next determine if we are going to be sending 1s or 0s based on the current bit in the color....
  284.  
  285. "mov r0, %[bitwalker] \n\t" // (1 cycles)
  286. "and r0, %[colorbyte] \n\t" // (1 cycles) - is the current bit in the color byte set?
  287. "breq OFF_%= \n\t" // (1 cycles) - bit in color is 0, then send full zero row (takes 2 cycles if branch taken, count the extra 1 on the target line)
  288.  
  289. // If we get here, then we want to send a 1 for every row that has an ON dot...
  290. "nop \n\t " // (1 cycles)
  291. "out %[port], %[row] \n\t" // (1 cycles) - set the output bits to [row] This is phase for T0H-T1H.
  292. // ==========
  293. // (5 cycles) - T0H (Phase #1)
  294.  
  295.  
  296. "nop \n\t nop \n\t " // (2 cycles)
  297. "nop \n\t nop \n\t " // (2 cycles)
  298. "nop \n\t nop \n\t " // (2 cycles)
  299. "nop \n\t " // (1 cycles)
  300.  
  301. "out %[port], __zero_reg__ \n\t" // (1 cycles) - set the output bits to 0x00 based on the bit in colorbyte. This is phase for T0H-T1H
  302. // ==========
  303. // (8 cycles) - Phase #2
  304.  
  305. "ror %[bitwalker] \n\t" // (1 cycles) - get ready for next pass. On last pass, the bit will end up in C flag
  306.  
  307. "brcs DONE_%= \n\t" // (1 cycles) Exit if carry bit is set as a result of us walking all 8 bits. We assume that the process around us will tak long enough to cover the phase 3 delay
  308.  
  309. "nop \n\t \n\t " // (1 cycles) - When added to the 5 cycles in S:, we gte the 7 cycles of T1L
  310.  
  311. "jmp L_%= \n\t" // (3 cycles)
  312. // (1 cycles) - The OUT on the next pass of the loop
  313. // ==========
  314. // (7 cycles) - T1L
  315.  
  316.  
  317. "OFF_%=: \n\r" // (1 cycles) Note that we land here becuase of breq, which takes takes 2 cycles
  318.  
  319. "out %[port], __zero_reg__ \n\t" // (1 cycles) - set the output bits to 0x00 based on the bit in colorbyte. This is phase for T0H-T1H
  320. // ==========
  321. // (5 cycles) - T0H
  322.  
  323. "ror %[bitwalker] \n\t" // (1 cycles) - get ready for next pass. On last pass, the bit will end up in C flag
  324.  
  325. "brcs DONE_%= \n\t" // (1 cycles) Exit if carry bit is set as a result of us walking all 8 bits. We assume that the process around us will tak long enough to cover the phase 3 delay
  326.  
  327. "nop \n\t nop \n\t " // (2 cycles)
  328. "nop \n\t nop \n\t " // (2 cycles)
  329. "nop \n\t nop \n\t " // (2 cycles)
  330. "nop \n\t nop \n\t " // (2 cycles)
  331. "nop \n\t " // (1 cycles)
  332.  
  333. "jmp L_%= \n\t" // (3 cycles)
  334. // (1 cycles) - The OUT on the next pass of the loop
  335. // ==========
  336. //(15 cycles) - T0L
  337.  
  338.  
  339. "DONE_%=: \n\t"
  340.  
  341. // Don't need an explicit delay here since the overhead that follows will always be long enough
  342.  
  343. ::
  344. [port] "I" (_SFR_IO_ADDR(PIXEL_PORT)),
  345. [row] "d" (row),
  346. [onBits] "d" (onBits),
  347. [colorbyte] "d" (colorbyte ), // Phase 2 of the signal where the actual data bits show up.
  348. [bitwalker] "r" (0x80) // Alocate a register to hold a bit that we will walk down though the color byte
  349.  
  350. );
  351. }
  352.  
  353.  
  354. // Just wait long enough without sending any bots to cause the pixels to latch and display the last sent frame
  355. void show() {
  356. delayMicroseconds( (RES / 1000UL) + 1); // Round up since the delay must be _at_least_ this long (too short might not work, too long not a problem)
  357. }
  358.  
  359.  
  360. ////////////////////////////////
  361. // Escape characters helpers
  362. ////////////////////////////////
  363.  
  364. static inline int hexCharToInt(const char* c) {
  365. return (c > '9') ? c - 'A' + 10 : c - '0';
  366. }
  367.  
  368. static inline char* processColor(const char* str) {
  369. if (*str == '#') {
  370. *str++;
  371. currentFormattingState.red = (hexCharToInt(*str++) << 4) + hexCharToInt(*str++);
  372. currentFormattingState.green = (hexCharToInt(*str++) << 4) + hexCharToInt(*str++);
  373. currentFormattingState.blue = (hexCharToInt(*str++) << 4) + hexCharToInt(*str++);
  374. }
  375. return str;
  376. }
  377.  
  378. static inline char* processEscapeCharacter(const char* str) {
  379. switch (*++str) {
  380. case 'c':
  381. // process color
  382. str = processColor(++str);
  383. break;
  384.  
  385. case 'b':
  386. // toggle blinkEnabled
  387. currentFormattingState.isBlinkEnabled = !currentFormattingState.isBlinkEnabled;
  388. str++;
  389. break;
  390.  
  391. case '/':
  392. currentFormattingState.isEscapedSlash = true;
  393. break;
  394. }
  395.  
  396. return str;
  397. }
  398.  
  399. static inline char* processEscapeCharacters(const char* str) {
  400. currentFormattingState.isEscapedSlash = false;
  401.  
  402. while (*str == '/' && *(str + 1)) {
  403. // if this slash is for an escaped slash, then skip the character
  404. if (currentFormattingState.isEscapedSlash) {
  405. str++;
  406. } else {
  407. str = processEscapeCharacter(str);
  408. }
  409. }
  410.  
  411. // if we encountered an escapedSlash, then return to it so it can be printed
  412. // NOTE: this code will not work if there is an escaped slash followed immediately by another slash :(
  413. if (currentFormattingState.isEscapedSlash) {
  414. str--;
  415. }
  416.  
  417. return str;
  418. }
  419.  
  420. ////////////////////////////////
  421. // Communication
  422. ////////////////////////////////
  423. // Requests a new message via serial
  424. static inline void requestNewMessage() {
  425. Serial.begin(BAUD_RATE);
  426.  
  427. // inform connection that we're ready
  428. Serial.println(READY_FOR_MESSAGE_SIGNAL);
  429.  
  430. // wait for input to arrive
  431. delay(WAIT_FOR_INPUT_DURATION);
  432.  
  433. // see if we got anything
  434. if (Serial.available()) {
  435. myMessage = Serial.readString();
  436. }
  437.  
  438. Serial.end();
  439. }
  440.  
  441. ////////////////////////////////
  442. // Debug
  443. ////////////////////////////////
  444. // Debug method to print a row to serial
  445. static inline void printRowToSerial(uint8_t row) {
  446. Serial.begin(BAUD_RATE);
  447. for (int i = 0; i < 7; i++ ) {
  448. Serial.print( ((row >> i) & 0x01) ? " " : "##");
  449. }
  450. Serial.println( ((row >> 7) & 0x01) ? " " : "##");
  451. Serial.end();
  452. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!