├── fontgen
    ├── readme.ME
    ├── cpp
    │   ├── fontconvert.cpp
    │   └── fontconvert2.cpp
    └── java
    │   └── com
    │       └── josh
    │           └── ConvertFontH.java
├── README.md
└── Arduino
    ├── arcade font.txt
    ├── tiny 5x5 font.txt
    ├── Homespun font.txt
    ├── Como too tall font.txt
    ├── Hunter thick and rich font.txt
    ├── bmspa font.txt
    ├── MacroMarquee
        └── MacroMarquee.ino
    └── SimpleScroll
        └── SimpleScroll.ino


/fontgen/readme.ME:
--------------------------------------------------------------------------------
1 | This is  some brutal hacked up Java code to convert fonts into the format and order used by the main progrom. 
2 | 
3 | You should not need this if you are happy with the fonts already provided. 
4 | 
5 | It is only included for those who want to play with fonts from other sources. 
6 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # MacroMarquee
2 | Efficient text scrolling across 8 NeoPixel strings from an Aurdunio Uno using multi-bit-bang
3 | 
4 | More info here...
5 | https://wp.josh.com/2016/05/04/parallel-processing-arduino-style-make-massive-neopixel-displays-with-nanoscale-concurrent-computing/
6 | 
7 | Example project (big scrolling sign) here...
8 | https://wp.josh.com/2016/05/04/parallel-processing-arduino-style-make-massive-neopixel-displays-with-nanoscale-concurrent-computing/
9 | 


--------------------------------------------------------------------------------
/fontgen/cpp/fontconvert.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <iomanip>
  3 | #include <bitset>
  4 | 
  5 | using namespace std;
  6 | 
  7 | // This program takes some font data and generates C code that you can paste into 
  8 | // the programs here...
  9 | // https://github.com/bigjosh/MacroMarquee/tree/master/Arduino
 10 | 
 11 | // A nice arcade font from...
 12 | // http://jared.geek.nz/2014/jan/custom-fonts-for-microcontrollers
 13 | 
 14 | // defines ascii characters 0x20-0x7F (32-127)
 15 | // PROGMEM after variable name as per https://www.arduino.cc/en/Reference/PROGMEM
 16 | 
 17 | #define FONT_WIDTH 8      
 18 | #define INTERCHAR_SPACE 1
 19 | #define ASCII_OFFSET 0x20    // ASSCI code of 1st char in font array
 20 | 
 21 | const uint8_t Font[]  = {
 22 | 
 23 |   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//  
 24 |   0x06,0x06,0x30,0x30,0x60,0xc0,0xc0,0x00,// !
 25 |   0xe0,0xe0,0x00,0xe0,0xe0,0x00,0x00,0x00,// "
 26 |   0x28,0xfe,0xfe,0x28,0xfe,0xfe,0x28,0x00,// #
 27 |   0xf6,0xf6,0xd6,0xd6,0xd6,0xde,0xde,0x00,// $
 28 |   0xc6,0xce,0x1c,0x38,0x70,0xe6,0xc6,0x00,// %
 29 |   0xfe,0xfe,0xd6,0xc6,0x16,0x1e,0x1e,0x00,// &
 30 |   0xe0,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,// '
 31 |   0xfe,0xfe,0x00,0x00,0x00,0x00,0x00,0x00,// (
 32 |   0x00,0xfe,0xfe,0x00,0x00,0x00,0x00,0x00,// )
 33 |   0x6c,0x10,0xfe,0xfe,0xfe,0x10,0x6c,0x00,// *
 34 |   0x10,0x10,0x7c,0x10,0x10,0x00,0x00,0x00,// +
 35 |   0x06,0x06,0x00,0x00,0x00,0x00,0x00,0x00,// ,
 36 |   0x10,0x10,0x10,0x10,0x10,0x00,0x00,0x00,// -
 37 |   0x06,0x06,0x00,0x00,0x00,0x00,0x00,0x00,// .
 38 |   0x0e,0x38,0xe0,0x00,0x00,0x00,0x00,0x00,// /
 39 |   0xfe,0xfe,0xc6,0xc6,0xc6,0xfe,0xfe,0x00,// 0
 40 |   0x06,0x66,0x66,0xfe,0xfe,0x06,0x06,0x00,// 1
 41 |   0xde,0xde,0xd6,0xd6,0xd6,0xf6,0xf6,0x00,// 2
 42 |   0xc6,0xc6,0xd6,0xd6,0xd6,0xfe,0xfe,0x00,// 3
 43 |   0xf8,0xf8,0x18,0x18,0x18,0x7e,0x7e,0x00,// 4
 44 |   0xf6,0xf6,0xd6,0xd6,0xd6,0xde,0xde,0x00,// 5
 45 |   0xfe,0xfe,0x36,0x36,0x36,0x3e,0x3e,0x00,// 6
 46 |   0xc2,0xc6,0xce,0xdc,0xf8,0xf0,0xe0,0x00,// 7
 47 |   0xfe,0xfe,0xd6,0xd6,0xd6,0xfe,0xfe,0x00,// 8
 48 |   0xf8,0xf8,0xd8,0xd8,0xd8,0xfe,0xfe,0x00,// 9
 49 |   0x36,0x36,0x00,0x00,0x00,0x00,0x00,0x00,// :
 50 |   0x36,0x36,0x00,0x00,0x00,0x00,0x00,0x00,// ;
 51 |   0x10,0x28,0x44,0x44,0x00,0x00,0x00,0x00,// <
 52 |   0x28,0x28,0x28,0x28,0x28,0x00,0x00,0x00,// =
 53 |   0x44,0x44,0x28,0x10,0x00,0x00,0x00,0x00,// >
 54 |   0xc0,0xc0,0xda,0xda,0xd0,0xf0,0xf0,0x00,// ?
 55 |   0xfe,0xfe,0xc6,0xf6,0xd6,0xf6,0xf6,0x00,// @
 56 |   0xfe,0xfe,0xd8,0xd8,0xd8,0xfe,0xfe,0x00,// A
 57 |   0xfe,0xfe,0xd6,0xd6,0xf6,0x7e,0x3e,0x00,// B
 58 |   0xfe,0xfe,0xc6,0xc6,0xc6,0xc6,0xc6,0x00,// C
 59 |   0xfe,0xfe,0xc6,0xc6,0xe6,0x7e,0x3e,0x00,// D
 60 |   0xfe,0xfe,0xd6,0xd6,0xd6,0xd6,0xd6,0x00,// E
 61 |   0xfe,0xfe,0xd0,0xd0,0xd0,0xc0,0xc0,0x00,// F
 62 |   0xfe,0xfe,0xc6,0xc6,0xd6,0xde,0xde,0x00,// G
 63 |   0xfe,0xfe,0x18,0x18,0x18,0xfe,0xfe,0x00,// H
 64 |   0xc6,0xc6,0xfe,0xfe,0xc6,0xc6,0xc6,0x00,// I
 65 |   0x06,0x06,0x06,0x06,0x06,0xfe,0xfc,0x00,// J
 66 |   0xfe,0xfe,0x18,0x18,0x78,0xfe,0x9e,0x00,// K
 67 |   0xfe,0xfe,0x06,0x06,0x06,0x06,0x06,0x00,// L
 68 |   0xfe,0xfe,0xc0,0x60,0xc0,0xfe,0xfe,0x00,// M
 69 |   0xfe,0xfe,0x70,0x38,0x1c,0xfe,0xfe,0x00,// N
 70 |   0xfe,0xfe,0xc6,0xc6,0xc6,0xfe,0xfe,0x00,// O
 71 |   0xfe,0xfe,0xd8,0xd8,0xd8,0xf8,0xf8,0x00,// P
 72 |   0xfe,0xfe,0xc6,0xce,0xce,0xfe,0xfe,0x00,// Q
 73 |   0xfe,0xfe,0xd8,0xdc,0xde,0xfe,0xfa,0x00,// R
 74 |   0xf6,0xf6,0xd6,0xd6,0xd6,0xde,0xde,0x00,// S
 75 |   0xc0,0xc0,0xfe,0xfe,0xc0,0xc0,0xc0,0x00,// T
 76 |   0xfe,0xfe,0x06,0x06,0x06,0xfe,0xfe,0x00,// U
 77 |   0xf8,0xfc,0x0e,0x06,0x0e,0xfc,0xf8,0x00,// V
 78 |   0xfc,0xfe,0x06,0x0c,0x06,0xfe,0xfc,0x00,// W
 79 |   0xee,0xfe,0x38,0x10,0x38,0xfe,0xee,0x00,// X
 80 |   0xe0,0xf0,0x3e,0x1e,0x3e,0xf0,0xe0,0x00,// Y
 81 |   0xce,0xde,0xd6,0xd6,0xd6,0xf6,0xe6,0x00,// Z
 82 |   0xfe,0xfe,0x00,0x00,0x00,0x00,0x00,0x00,// [
 83 |   0xe0,0x38,0x0e,0x00,0x00,0x00,0x00,0x00,// \
 84 |   0x00,0xfe,0xfe,0x00,0x00,0x00,0x00,0x00,// ]
 85 |   0x00,0xfe,0x02,0xfe,0x00,0x00,0x00,0x00,// ^
 86 |   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,// _
 87 |   0x00,0xfe,0x02,0xfe,0x00,0x00,0x00,0x00,// `
 88 |   0xfe,0xfe,0xd8,0xd8,0xd8,0xfe,0xfe,0x00,// a
 89 |   0xfe,0xfe,0xd6,0xd6,0xf6,0x7e,0x3e,0x00,// b
 90 |   0xfe,0xfe,0xc6,0xc6,0xc6,0xc6,0xc6,0x00,// c
 91 |   0xfe,0xfe,0xc6,0xc6,0xe6,0x7e,0x3e,0x00,// d
 92 |   0xfe,0xfe,0xd6,0xd6,0xd6,0xd6,0xd6,0x00,// e
 93 |   0xfe,0xfe,0xd0,0xd0,0xd0,0xc0,0xc0,0x00,// f
 94 |   0xfe,0xfe,0xc6,0xc6,0xd6,0xde,0xde,0x00,// g
 95 |   0xfe,0xfe,0x18,0x18,0x18,0xfe,0xfe,0x00,// h
 96 |   0xc6,0xc6,0xfe,0xfe,0xc6,0xc6,0xc6,0x00,// i
 97 |   0x06,0x06,0x06,0x06,0x06,0xfe,0xfc,0x00,// j
 98 |   0xfe,0xfe,0x18,0x18,0x78,0xfe,0x9e,0x00,// k
 99 |   0xfe,0xfe,0x06,0x06,0x06,0x06,0x06,0x00,// l
100 |   0xfe,0xfe,0xc0,0x60,0xc0,0xfe,0xfe,0x00,// m
101 |   0xfe,0xfe,0x70,0x38,0x1c,0xfe,0xfe,0x00,// n
102 |   0xfe,0xfe,0xc6,0xc6,0xc6,0xfe,0xfe,0x00,// o
103 |   0xfe,0xfe,0xd8,0xd8,0xd8,0xf8,0xf8,0x00,// p
104 |   0xfe,0xfe,0xc6,0xce,0xce,0xfe,0xfe,0x00,// q
105 |   0xfe,0xfe,0xd8,0xdc,0xde,0xfe,0xfa,0x00,// r
106 |   0xf6,0xf6,0xd6,0xd6,0xd6,0xde,0xde,0x00,// s
107 |   0xc0,0xc0,0xfe,0xfe,0xc0,0xc0,0xc0,0x00,// t
108 |   0xfe,0xfe,0x06,0x06,0x06,0xfe,0xfe,0x00,// u
109 |   0xf8,0xfc,0x0e,0x06,0x0e,0xfc,0xf8,0x00,// v
110 |   0xfc,0xfe,0x06,0x0c,0x06,0xfe,0xfc,0x00,// w
111 |   0xee,0xfe,0x38,0x10,0x38,0xfe,0xee,0x00,// x
112 |   0xe0,0xf0,0x3e,0x1e,0x3e,0xf0,0xe0,0x00,// y
113 |   0xce,0xde,0xd6,0xd6,0xd6,0xf6,0xe6,0x00,// z
114 |   0x38,0xfe,0xfe,0x00,0x00,0x00,0x00,0x00,// {
115 |   0xfe,0x00,0x00,0x00,0x00,0x00,0x00,0x00,// |
116 |   0x00,0xfe,0xfe,0x38,0x00,0x00,0x00,0x00,// }
117 |   0x00,0xfe,0x02,0xfe,0x00,0x00,0x00,0x00,// ~
118 |   };
119 | 
120 | 
121 | // Size of array from https://stackoverflow.com/a/18078435/3152071
122 | template<class T, size_t N>
123 | constexpr size_t size(T (&)[N]) { return N; }
124 | 
125 | int main()
126 | {
127 | 
128 |     cout << "/*------------------- FONT CUT TOP HERE -------------------------------*/" << std::endl;
129 | 
130 | 
131 |     cout << std::hex;
132 | 
133 |     cout << "#define ASCII_OFFSET (0x20)     // ASCII code of 1st char in font array" << std::endl;
134 |     
135 |     cout << "#define ASCII_NONPRINT (0x80)   // ASCII code of char to show for chars not included in the font (could also be a space)" << std::endl;
136 |     
137 |     cout << "#define FONT_WIDTH " << FONT_WIDTH+INTERCHAR_SPACE << std::endl;      
138 |     
139 |     cout << "const byte fontdata[][FONT_WIDTH] PROGMEM = {" << std::endl; 
140 | 
141 | 
142 |     char c = ASCII_OFFSET;
143 |     
144 |     auto i=0;
145 |     
146 |     while ( i < size( Font ) ) {
147 |         
148 |   
149 |         if (isprint( c )) {
150 |              printf("    { // ASCII 0x%02.2X ('%c')\n" , (unsigned) c , c );
151 |         }  else {
152 |              printf("    { // ASCII 0x%02.2X" ,  (unsigned) c );
153 |         }
154 |         
155 | 
156 |         c++;
157 |         
158 |         
159 |         for( auto j =0; j < FONT_WIDTH; j++ ) {
160 |             
161 |             cout << "       0b" << std::bitset<8>( Font[ i ] ) << ","  <<  std::endl ;
162 |             
163 |             i++;
164 |                 
165 |         }
166 |         
167 |         cout << "       0b00000000,  // Interchar space" <<  std::endl ;        // Interchar space
168 |         cout << "    },\r\n";
169 |         
170 |     }
171 | 
172 |   cout << "};" << std::endl;
173 | 
174 |     cout << "/*------------------- FONT CUT BOTTOM HERE -------------------------------*/" << std::endl;
175 | 
176 |     return 0;
177 | }
178 | 


--------------------------------------------------------------------------------
/fontgen/cpp/fontconvert2.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <iomanip>
  3 | #include <bitset>
  4 | 
  5 | using namespace std;
  6 | 
  7 | // This program takes some font data and generates C code that you can paste into 
  8 | // the programs here...
  9 | // https://github.com/bigjosh/MacroMarquee/tree/master/Arduino
 10 | 
 11 | // A tiny 5x5 font from 
 12 | // https://jared.geek.nz/2014/jan/custom-fonts-for-microcontrollers
 13 | 
 14 | // defines ascii characters 0x20-0x7F (32-127)
 15 | // PROGMEM after variable name as per https://www.arduino.cc/en/Reference/PROGMEM
 16 | 
 17 | #define FONT_WIDTH 8      
 18 | #define INTERCHAR_SPACE 1
 19 | #define ASCII_OFFSET 0x20    // ASSCI code of 1st char in font array
 20 | 
 21 | const unsigned char font[96][8] = {
 22 | 	{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, //  
 23 | 	{0x00,0x5f,0x00,0x00,0x00,0x00,0x00,0x00}, // !
 24 | 	{0x00,0x03,0x00,0x03,0x00,0x00,0x00,0x00}, // "
 25 | 	{0x0a,0x1f,0x0a,0x1f,0x0a,0x00,0x00,0x00}, // #
 26 | 	{0x24,0x2a,0x2a,0x7f,0x2a,0x2a,0x12,0x00}, // $
 27 | 	{0x00,0x47,0x25,0x17,0x08,0x74,0x52,0x71}, // %
 28 | 	{0x00,0x36,0x49,0x49,0x49,0x41,0x41,0x38}, // &
 29 | 	{0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00}, // '
 30 | 	{0x00,0x3e,0x41,0x00,0x00,0x00,0x00,0x00}, // (
 31 | 	{0x41,0x3e,0x00,0x00,0x00,0x00,0x00,0x00}, // )
 32 | 	{0x04,0x15,0x0e,0x15,0x04,0x00,0x00,0x00}, // *
 33 | 	{0x08,0x08,0x3e,0x08,0x08,0x00,0x00,0x00}, // +
 34 | 	{0x00,0xc0,0x00,0x00,0x00,0x00,0x00,0x00}, // ,
 35 | 	{0x08,0x08,0x08,0x08,0x08,0x00,0x00,0x00}, // -
 36 | 	{0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // .
 37 | 	{0x40,0x20,0x10,0x08,0x04,0x02,0x01,0x00}, // /
 38 | 	{0x00,0x3e,0x61,0x51,0x49,0x45,0x43,0x3e}, // 0
 39 | 	{0x01,0x01,0x7e,0x00,0x00,0x00,0x00,0x00}, // 1
 40 | 	{0x00,0x71,0x49,0x49,0x49,0x49,0x49,0x46}, // 2
 41 | 	{0x41,0x49,0x49,0x49,0x49,0x49,0x36,0x00}, // 3
 42 | 	{0x00,0x0f,0x10,0x10,0x10,0x10,0x10,0x7f}, // 4
 43 | 	{0x00,0x4f,0x49,0x49,0x49,0x49,0x49,0x31}, // 5
 44 | 	{0x00,0x3e,0x49,0x49,0x49,0x49,0x49,0x30}, // 6
 45 | 	{0x01,0x01,0x01,0x01,0x01,0x01,0x7e,0x00}, // 7
 46 | 	{0x00,0x36,0x49,0x49,0x49,0x49,0x49,0x36}, // 8
 47 | 	{0x00,0x06,0x49,0x49,0x49,0x49,0x49,0x3e}, // 9
 48 | 	{0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // :
 49 | 	{0x40,0x34,0x00,0x00,0x00,0x00,0x00,0x00}, // ;
 50 | 	{0x08,0x14,0x22,0x00,0x00,0x00,0x00,0x00}, // <
 51 | 	{0x14,0x14,0x14,0x14,0x14,0x00,0x00,0x00}, // =
 52 | 	{0x22,0x14,0x08,0x00,0x00,0x00,0x00,0x00}, // >
 53 | 	{0x00,0x06,0x01,0x01,0x59,0x09,0x09,0x06}, // ?
 54 | 	{0x00,0x3e,0x41,0x5d,0x55,0x5d,0x51,0x5e}, // @
 55 | 	{0x00,0x7e,0x01,0x09,0x09,0x09,0x09,0x7e}, // A
 56 | 	{0x00,0x7f,0x41,0x49,0x49,0x49,0x49,0x36}, // B
 57 | 	{0x00,0x3e,0x41,0x41,0x41,0x41,0x41,0x22}, // C
 58 | 	{0x00,0x7f,0x41,0x41,0x41,0x41,0x41,0x3e}, // D
 59 | 	{0x00,0x3e,0x49,0x49,0x49,0x49,0x49,0x41}, // E
 60 | 	{0x00,0x7e,0x09,0x09,0x09,0x09,0x09,0x01}, // F
 61 | 	{0x00,0x3e,0x41,0x49,0x49,0x49,0x49,0x79}, // G
 62 | 	{0x00,0x7f,0x08,0x08,0x08,0x08,0x08,0x7f}, // H
 63 | 	{0x00,0x7f,0x00,0x00,0x00,0x00,0x00,0x00}, // I
 64 | 	{0x00,0x38,0x40,0x40,0x41,0x41,0x41,0x3f}, // J
 65 | 	{0x00,0x7f,0x08,0x08,0x08,0x0c,0x0a,0x71}, // K
 66 | 	{0x00,0x3f,0x40,0x40,0x40,0x40,0x40,0x40}, // L
 67 | 	{0x00,0x7e,0x01,0x01,0x7e,0x01,0x01,0x7e}, // M
 68 | 	{0x00,0x7e,0x01,0x01,0x3e,0x40,0x40,0x3f}, // N
 69 | 	{0x00,0x3e,0x41,0x41,0x41,0x41,0x41,0x3e}, // O
 70 | 	{0x00,0x7e,0x09,0x09,0x09,0x09,0x09,0x06}, // P
 71 | 	{0x00,0x3e,0x41,0x41,0x71,0x51,0x51,0x7e}, // Q
 72 | 	{0x00,0x7e,0x01,0x31,0x49,0x49,0x49,0x46}, // R
 73 | 	{0x00,0x46,0x49,0x49,0x49,0x49,0x49,0x31}, // S
 74 | 	{0x01,0x01,0x01,0x7f,0x01,0x01,0x01,0x00}, // T
 75 | 	{0x00,0x3f,0x40,0x40,0x40,0x40,0x40,0x3f}, // U
 76 | 	{0x00,0x0f,0x10,0x20,0x40,0x20,0x10,0x0f}, // V
 77 | 	{0x00,0x3f,0x40,0x40,0x3f,0x40,0x40,0x3f}, // W
 78 | 	{0x00,0x63,0x14,0x08,0x08,0x08,0x14,0x63}, // X
 79 | 	{0x00,0x07,0x08,0x08,0x78,0x08,0x08,0x07}, // Y
 80 | 	{0x00,0x71,0x49,0x49,0x49,0x49,0x49,0x47}, // Z
 81 | 	{0x00,0x7f,0x41,0x00,0x00,0x00,0x00,0x00}, // [
 82 | 	{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // "\"
 83 | 	{0x41,0x7f,0x00,0x00,0x00,0x00,0x00,0x00}, // ]
 84 | 	{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // ^
 85 | 	{0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00}, // _
 86 | 	{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // `
 87 | 	{0x00,0x7e,0x01,0x09,0x09,0x09,0x09,0x7e}, // A
 88 | 	{0x00,0x7f,0x41,0x49,0x49,0x49,0x49,0x36}, // B
 89 | 	{0x00,0x3e,0x41,0x41,0x41,0x41,0x41,0x22}, // C
 90 | 	{0x00,0x7f,0x41,0x41,0x41,0x41,0x41,0x3e}, // D
 91 | 	{0x00,0x3e,0x49,0x49,0x49,0x49,0x49,0x41}, // E
 92 | 	{0x00,0x7e,0x09,0x09,0x09,0x09,0x09,0x01}, // F
 93 | 	{0x00,0x3e,0x41,0x49,0x49,0x49,0x49,0x79}, // G
 94 | 	{0x00,0x7f,0x08,0x08,0x08,0x08,0x08,0x7f}, // H
 95 | 	{0x00,0x7f,0x00,0x00,0x00,0x00,0x00,0x00}, // I
 96 | 	{0x00,0x38,0x40,0x40,0x41,0x41,0x41,0x3f}, // J
 97 | 	{0x00,0x7f,0x08,0x08,0x08,0x0c,0x0a,0x71}, // K
 98 | 	{0x00,0x3f,0x40,0x40,0x40,0x40,0x40,0x40}, // L
 99 | 	{0x00,0x7e,0x01,0x01,0x7e,0x01,0x01,0x7e}, // M
100 | 	{0x00,0x7e,0x01,0x01,0x3e,0x40,0x40,0x3f}, // N
101 | 	{0x00,0x3e,0x41,0x41,0x41,0x41,0x41,0x3e}, // O
102 | 	{0x00,0x7e,0x09,0x09,0x09,0x09,0x09,0x06}, // P
103 | 	{0x00,0x3e,0x41,0x41,0x71,0x51,0x51,0x7e}, // Q
104 | 	{0x00,0x7e,0x01,0x31,0x49,0x49,0x49,0x46}, // R
105 | 	{0x00,0x46,0x49,0x49,0x49,0x49,0x49,0x31}, // S
106 | 	{0x01,0x01,0x01,0x7f,0x01,0x01,0x01,0x00}, // T
107 | 	{0x00,0x3f,0x40,0x40,0x40,0x40,0x40,0x3f}, // U
108 | 	{0x00,0x0f,0x10,0x20,0x40,0x20,0x10,0x0f}, // V
109 | 	{0x00,0x3f,0x40,0x40,0x3f,0x40,0x40,0x3f}, // W
110 | 	{0x00,0x63,0x14,0x08,0x08,0x08,0x14,0x63}, // X
111 | 	{0x00,0x07,0x08,0x08,0x78,0x08,0x08,0x07}, // Y
112 | 	{0x00,0x71,0x49,0x49,0x49,0x49,0x49,0x47}, // Z
113 | 	{0x08,0x36,0x41,0x00,0x00,0x00,0x00,0x00}, // {
114 | 	{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // |
115 | 	{0x41,0x36,0x08,0x00,0x00,0x00,0x00,0x00}, // }
116 | 	{0x02,0x01,0x01,0x02,0x02,0x01,0x00,0x00}, // ~
117 | 	{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}
118 | };
119 | 
120 | // Size of array from https://stackoverflow.com/a/18078435/3152071
121 | template<class T, size_t N>
122 | constexpr size_t size(T (&)[N]) { return N; }
123 | 
124 | unsigned char reverse(unsigned char b) {
125 |    b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
126 |    b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
127 |    b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
128 |    return b;
129 | }
130 | 
131 | int main()
132 | {
133 | 
134 |     cout << "/*------------------- FONT CUT TOP HERE -------------------------------*/" << std::endl;
135 | 
136 | 
137 |     cout << std::hex;
138 | 
139 |     cout << "#define ASCII_OFFSET (0x20)     // ASCII code of 1st char in font array" << std::endl;
140 |     
141 |     cout << "#define ASCII_NONPRINT (0x80)   // ASCII code of char to show for chars not included in the font (could also be a space)" << std::endl;
142 |     
143 |     cout << "#define FONT_WIDTH " << FONT_WIDTH+INTERCHAR_SPACE << std::endl;      
144 |     
145 |     cout << "const byte fontdata[][FONT_WIDTH] PROGMEM = {" << std::endl; 
146 | 
147 | 
148 |     char c = ASCII_OFFSET;
149 |     
150 |     auto i=0;
151 |     
152 |     while ( i < size( font ) ) {
153 |         
154 |   
155 |         if (isprint( c )) {
156 |              printf("    { // ASCII 0x%02.2X ('%c')\n" , (unsigned) c , c );
157 |         }  else {
158 |              printf("    { // ASCII 0x%02.2X" ,  (unsigned) c );
159 |         }
160 |         
161 | 
162 |         c++;
163 |         
164 |         
165 |         for( auto j = 0; j < FONT_WIDTH; j++ ) {
166 |             
167 |             cout << "       0b" << std::bitset<8>( reverse(font[ i ][j] )) << ","  << std::endl ;
168 |             
169 |         }
170 |         
171 |        // cout << "       0b00000000,  // Interchar space" <<  std::endl ;        // Interchar space
172 |         cout << "    },\r\n";
173 |         
174 |         i++;
175 |         
176 |     }
177 | 
178 |   cout << "};" << std::endl;
179 | 
180 |     cout << "/*------------------- FONT CUT BOTTOM HERE -------------------------------*/" << std::endl;
181 | 
182 |     return 0;
183 | }
184 | 


--------------------------------------------------------------------------------
/fontgen/java/com/josh/ConvertFontH.java:
--------------------------------------------------------------------------------
  1 | package com.josh;
  2 | 
  3 | // Reverse vertical bit order in font, keep LSB always 0.
  4 | // Works with 7 pixel high Fonts from this great collection...
  5 | // http://jared.geek.nz/2014/jan/custom-fonts-for-microcontrollers
  6 | 
  7 | 
  8 | public class ConvertFontH {
  9 | 
 10 |     public static void main(String[] args) {
 11 | 
 12 |         int fontzxpix[][] = {
 13 | 
 14 |                 // Cut and paste a font data you want to encode here and run the program.
 15 |                 // Then copy and paste the output code into your program
 16 | 
 17 |                 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //
 18 |                 {0x5f, 0x5f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // !
 19 |                 {0x07, 0x07, 0x00, 0x07, 0x07, 0x00, 0x00, 0x00}, // "
 20 |                 {0x14, 0x7f, 0x7f, 0x14, 0x7f, 0x7f, 0x14, 0x00}, // #
 21 |                 {0x6f, 0x6f, 0x6b, 0xeb, 0x6b, 0x7b, 0x7b, 0x00}, // $
 22 |                 {0x63, 0x73, 0x38, 0x1c, 0x0e, 0x67, 0x63, 0x00}, // %
 23 |                 {0x7f, 0x7f, 0x6b, 0x63, 0x68, 0x78, 0x78, 0x00}, // &
 24 |                 {0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // '
 25 |                 {0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00}, // (
 26 |                 {0x80, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00}, // )
 27 |                 {0x36, 0x08, 0x7f, 0x7f, 0x7f, 0x08, 0x36, 0x00}, // *
 28 |                 {0x08, 0x08, 0x3e, 0x08, 0x08, 0x00, 0x00, 0x00}, // +
 29 |                 {0xe0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ,
 30 |                 {0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00}, // -
 31 |                 {0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // .
 32 |                 {0x70, 0x1c, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00}, // /
 33 |                 {0x7f, 0x7f, 0x63, 0x63, 0x63, 0x7f, 0x7f, 0x00}, // 0
 34 |                 {0x60, 0x66, 0x66, 0x7f, 0x7f, 0x60, 0x60, 0x00}, // 1
 35 |                 {0x7b, 0x7b, 0x6b, 0x6b, 0x6b, 0x6f, 0x6f, 0x00}, // 2
 36 |                 {0x63, 0x63, 0x6b, 0x6b, 0x6b, 0x7f, 0x7f, 0x00}, // 3
 37 |                 {0x1f, 0x1f, 0x18, 0x18, 0x18, 0x7e, 0x7e, 0x00}, // 4
 38 |                 {0x6f, 0x6f, 0x6b, 0x6b, 0x6b, 0x7b, 0x7b, 0x00}, // 5
 39 |                 {0x7f, 0x7f, 0x6c, 0x6c, 0x6c, 0x7c, 0x7c, 0x00}, // 6
 40 |                 {0x43, 0x63, 0x73, 0x3b, 0x1f, 0x0f, 0x07, 0x00}, // 7
 41 |                 {0x7f, 0x7f, 0x6b, 0x6b, 0x6b, 0x7f, 0x7f, 0x00}, // 8
 42 |                 {0x1f, 0x1f, 0x1b, 0x1b, 0x1b, 0x7f, 0x7f, 0x00}, // 9
 43 |                 {0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // :
 44 |                 {0xec, 0xec, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ;
 45 |                 {0x08, 0x14, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00}, // <
 46 |                 {0x14, 0x14, 0x14, 0x14, 0x14, 0x00, 0x00, 0x00}, // =
 47 |                 {0x22, 0x22, 0x14, 0x08, 0x00, 0x00, 0x00, 0x00}, // >
 48 |                 {0x03, 0x03, 0x5b, 0x5b, 0x0b, 0x0f, 0x0f, 0x00}, // ?
 49 |                 {0x7f, 0x7f, 0x63, 0x6f, 0x6b, 0x6f, 0x6f, 0x00}, // @
 50 |                 {0x7f, 0x7f, 0x1b, 0x1b, 0x1b, 0x7f, 0x7f, 0x00}, // A
 51 |                 {0x7f, 0x7f, 0x6b, 0x6b, 0x6f, 0x7e, 0x7c, 0x00}, // B
 52 |                 {0x7f, 0x7f, 0x63, 0x63, 0x63, 0x63, 0x63, 0x00}, // C
 53 |                 {0x7f, 0x7f, 0x63, 0x63, 0x67, 0x7e, 0x7c, 0x00}, // D
 54 |                 {0x7f, 0x7f, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x00}, // E
 55 |                 {0x7f, 0x7f, 0x0b, 0x0b, 0x0b, 0x03, 0x03, 0x00}, // F
 56 |                 {0x7f, 0x7f, 0x63, 0x63, 0x6b, 0x7b, 0x7b, 0x00}, // G
 57 |                 {0x7f, 0x7f, 0x18, 0x18, 0x18, 0x7f, 0x7f, 0x00}, // H
 58 |                 {0x63, 0x63, 0x7f, 0x7f, 0x63, 0x63, 0x63, 0x00}, // I
 59 |                 {0x60, 0x60, 0x60, 0x60, 0x60, 0x7f, 0x3f, 0x00}, // J
 60 |                 {0x7f, 0x7f, 0x18, 0x18, 0x1e, 0x7f, 0x79, 0x00}, // K
 61 |                 {0x7f, 0x7f, 0x60, 0x60, 0x60, 0x60, 0x60, 0x00}, // L
 62 |                 {0x7f, 0x7f, 0x03, 0x06, 0x03, 0x7f, 0x7f, 0x00}, // M
 63 |                 {0x7f, 0x7f, 0x0e, 0x1c, 0x38, 0x7f, 0x7f, 0x00}, // N
 64 |                 {0x7f, 0x7f, 0x63, 0x63, 0x63, 0x7f, 0x7f, 0x00}, // O
 65 |                 {0x7f, 0x7f, 0x1b, 0x1b, 0x1b, 0x1f, 0x1f, 0x00}, // P
 66 |                 {0x7f, 0x7f, 0x63, 0xf3, 0xf3, 0x7f, 0x7f, 0x00}, // Q
 67 |                 {0x7f, 0x7f, 0x1b, 0x3b, 0x7b, 0x7f, 0x5f, 0x00}, // R
 68 |                 {0x6f, 0x6f, 0x6b, 0x6b, 0x6b, 0x7b, 0x7b, 0x00}, // S
 69 |                 {0x03, 0x03, 0x7f, 0x7f, 0x03, 0x03, 0x03, 0x00}, // T
 70 |                 {0x7f, 0x7f, 0x60, 0x60, 0x60, 0x7f, 0x7f, 0x00}, // U
 71 |                 {0x1f, 0x3f, 0x70, 0x60, 0x70, 0x3f, 0x1f, 0x00}, // V
 72 |                 {0x3f, 0x7f, 0x60, 0x30, 0x60, 0x7f, 0x3f, 0x00}, // W
 73 |                 {0x77, 0x7f, 0x1c, 0x08, 0x1c, 0x7f, 0x77, 0x00}, // X
 74 |                 {0x07, 0x0f, 0x7c, 0x78, 0x7c, 0x0f, 0x07, 0x00}, // Y
 75 |                 {0x73, 0x7b, 0x6b, 0x6b, 0x6b, 0x6f, 0x67, 0x00}, // Z
 76 |                 {0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00}, // [
 77 |                 {0x07, 0x1c, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00}, // "\"
 78 |                 {0x80, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00}, // ]
 79 |                 {0x00, 0x7f, 0x40, 0x7f, 0x00, 0x00, 0x00, 0x00}, // ^
 80 |                 {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00}, // _
 81 |                 {0x00, 0x7f, 0x40, 0x7f, 0x00, 0x00, 0x00, 0x00}, // `
 82 |                 {0x7f, 0x7f, 0x1b, 0x1b, 0x1b, 0x7f, 0x7f, 0x00}, // a
 83 |                 {0x7f, 0x7f, 0x6b, 0x6b, 0x6f, 0x7e, 0x7c, 0x00}, // b
 84 |                 {0x7f, 0x7f, 0x63, 0x63, 0x63, 0x63, 0x63, 0x00}, // c
 85 |                 {0x7f, 0x7f, 0x63, 0x63, 0x67, 0x7e, 0x7c, 0x00}, // d
 86 |                 {0x7f, 0x7f, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x00}, // e
 87 |                 {0x7f, 0x7f, 0x0b, 0x0b, 0x0b, 0x03, 0x03, 0x00}, // f
 88 |                 {0x7f, 0x7f, 0x63, 0x63, 0x6b, 0x7b, 0x7b, 0x00}, // g
 89 |                 {0x7f, 0x7f, 0x18, 0x18, 0x18, 0x7f, 0x7f, 0x00}, // h
 90 |                 {0x63, 0x63, 0x7f, 0x7f, 0x63, 0x63, 0x63, 0x00}, // i
 91 |                 {0x60, 0x60, 0x60, 0x60, 0x60, 0x7f, 0x3f, 0x00}, // j
 92 |                 {0x7f, 0x7f, 0x18, 0x18, 0x1e, 0x7f, 0x79, 0x00}, // k
 93 |                 {0x7f, 0x7f, 0x60, 0x60, 0x60, 0x60, 0x60, 0x00}, // l
 94 |                 {0x7f, 0x7f, 0x03, 0x06, 0x03, 0x7f, 0x7f, 0x00}, // m
 95 |                 {0x7f, 0x7f, 0x0e, 0x1c, 0x38, 0x7f, 0x7f, 0x00}, // n
 96 |                 {0x7f, 0x7f, 0x63, 0x63, 0x63, 0x7f, 0x7f, 0x00}, // o
 97 |                 {0x7f, 0x7f, 0x1b, 0x1b, 0x1b, 0x1f, 0x1f, 0x00}, // p
 98 |                 {0x7f, 0x7f, 0x63, 0xf3, 0xf3, 0x7f, 0x7f, 0x00}, // q
 99 |                 {0x7f, 0x7f, 0x1b, 0x3b, 0x7b, 0x7f, 0x5f, 0x00}, // r
100 |                 {0x6f, 0x6f, 0x6b, 0x6b, 0x6b, 0x7b, 0x7b, 0x00}, // s
101 |                 {0x03, 0x03, 0x7f, 0x7f, 0x03, 0x03, 0x03, 0x00}, // t
102 |                 {0x7f, 0x7f, 0x60, 0x60, 0x60, 0x7f, 0x7f, 0x00}, // u
103 |                 {0x1f, 0x3f, 0x70, 0x60, 0x70, 0x3f, 0x1f, 0x00}, // v
104 |                 {0x3f, 0x7f, 0x60, 0x30, 0x60, 0x7f, 0x3f, 0x00}, // w
105 |                 {0x77, 0x7f, 0x1c, 0x08, 0x1c, 0x7f, 0x77, 0x00}, // x
106 |                 {0x07, 0x0f, 0x7c, 0x78, 0x7c, 0x0f, 0x07, 0x00}, // y
107 |                 {0x73, 0x7b, 0x6b, 0x6b, 0x6b, 0x6f, 0x67, 0x00}, // z
108 |                 {0x1c, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00}, // {
109 |                 {0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // |
110 |                 {0x80, 0xff, 0xff, 0x1c, 0x00, 0x00, 0x00, 0x00}, // }
111 |                 {0x00, 0x7f, 0x40, 0x7f, 0x00, 0x00, 0x00, 0x00}, // ~
112 |         };
113 | 
114 | 
115 |         int enemies[][] = {
116 | 
117 |                 {
118 |                     0b00001110,
119 |                     0b00101111,
120 |                     0b01111111,
121 |                     0b01011011,
122 |                     0b00011011,
123 |                     0b00101111,
124 |                     0b00101111,
125 |                     0b00011011,
126 |                     0b01011011,
127 |                     0b01111111,
128 |                     0b00101111,
129 |                     0b00001110,
130 |                 },
131 | 
132 |                 {
133 |                     0b01001110,
134 |                     0b01001111,
135 |                     0b00101111,
136 |                     0b00111011,
137 |                     0b00011011,
138 |                     0b00101111,
139 |                     0b00101111,
140 |                     0b00011011,
141 |                     0b00111011,
142 |                     0b00101111,
143 |                     0b01001111,
144 |                     0b01001110,
145 |                 },
146 |                 {
147 |                         0b00111000,
148 |                         0b00001100,
149 |                         0b00111110,
150 |                         0b01011011,
151 |                         0b01011110,
152 |                         0b00011110,
153 |                         0b01011110,
154 |                         0b01011011,
155 |                         0b00111110,
156 |                         0b00001100,
157 |                         0b00111000,
158 |                 },
159 | 
160 |                 {
161 |                         0b00001111,
162 |                         0b01011100,
163 |                         0b00111110,
164 |                         0b00011011,
165 |                         0b00011110,
166 |                         0b00011110,
167 |                         0b00011110,
168 |                         0b00011011,
169 |                         0b00111110,
170 |                         0b01011100,
171 |                         0b00001111,
172 |                 },
173 | 
174 |                 {
175 |                         0b01001001,
176 |                         0b00101010,
177 |                         0b00001000,
178 |                         0b01000001,
179 |                         0b00100010,
180 |                         0b00000000,
181 |                         0b00000000,
182 |                         0b00100010,
183 |                         0b01000001,
184 |                         0b00001000,
185 |                         0b00101010,
186 |                         0b01001001,
187 |                 },
188 | 
189 |             };
190 | 
191 |         //int[][] font = fontzxpix;
192 | 
193 |         int[][] font = enemies;
194 | 
195 |         for (int i = 0; i < font.length ; i++) {
196 | 
197 |             for (int s : font[i] ) {
198 | 
199 |                 int d = 0;
200 | 
201 |                 for (int b = 0; b < 8; b++) {
202 | 
203 |                     d <<=1;
204 | 
205 | 
206 |                     if ( (s & 0x01 ) !=0 ) {
207 |                         d |= 1;
208 |                     }
209 | 
210 |                     s >>=1;
211 | 
212 | 
213 |                     //    System.out.format( "b=%d e=%d a=%02x c=%b d=%02x%n" , b , (2^b) , (s & (2^b) ) , ((s & (2 ^ b))) !=0   ,d );
214 | 
215 |                 }
216 | 
217 |                 // System.out.format( "S=%02x d=%02x%n",s ,d );
218 | 
219 |                 d &= 0xfe;          // Clear bottom bit just in case
220 | 
221 |                 System.out.format("%#04x,", d);
222 | 
223 |             }
224 | 
225 |             System.out.format("// %c%n", i + 0x20);
226 |         }
227 | 
228 |     }
229 | 
230 | }
231 | 


--------------------------------------------------------------------------------
/Arduino/arcade font.txt:
--------------------------------------------------------------------------------
  1 | /*------------------- FONT CUT TOP HERE -------------------------------*/
  2 | 
  3 | // A nice arcade font from...
  4 | // http://jared.geek.nz/2014/jan/custom-fonts-for-microcontrollers
  5 | 
  6 | // Only defines upper case letters. 
  7 | 
  8 | #define ASCII_OFFSET (0x20)     // ASCII code of 1st char in font array
  9 | #define ASCII_NONPRINT (0x80)   // ASCII code of char to show for chars not included in the font (could also be a space)
 10 | #define FONT_WIDTH 9
 11 | const byte fontdata[][FONT_WIDTH] PROGMEM = {
 12 |     { // ASCII 0x20 (' ')
 13 |        0b00000000,
 14 |        0b00000000,
 15 |        0b00000000,
 16 |        0b00000000,
 17 |        0b00000000,
 18 |        0b00000000,
 19 |        0b00000000,
 20 |        0b00000000,
 21 |        0b00000000,  // Interchar space
 22 |     },
 23 |     { // ASCII 0x21 ('!')
 24 |        0b00000110,
 25 |        0b00000110,
 26 |        0b00110000,
 27 |        0b00110000,
 28 |        0b01100000,
 29 |        0b11000000,
 30 |        0b11000000,
 31 |        0b00000000,
 32 |        0b00000000,  // Interchar space
 33 |     },
 34 |     { // ASCII 0x22 ('"')
 35 |        0b11100000,
 36 |        0b11100000,
 37 |        0b00000000,
 38 |        0b11100000,
 39 |        0b11100000,
 40 |        0b00000000,
 41 |        0b00000000,
 42 |        0b00000000,
 43 |        0b00000000,  // Interchar space
 44 |     },
 45 |     { // ASCII 0x23 ('#')
 46 |        0b00101000,
 47 |        0b11111110,
 48 |        0b11111110,
 49 |        0b00101000,
 50 |        0b11111110,
 51 |        0b11111110,
 52 |        0b00101000,
 53 |        0b00000000,
 54 |        0b00000000,  // Interchar space
 55 |     },
 56 |     { // ASCII 0x24 ('$')
 57 |        0b11110110,
 58 |        0b11110110,
 59 |        0b11010110,
 60 |        0b11010110,
 61 |        0b11010110,
 62 |        0b11011110,
 63 |        0b11011110,
 64 |        0b00000000,
 65 |        0b00000000,  // Interchar space
 66 |     },
 67 |     { // ASCII 0x25 ('%')
 68 |        0b11000110,
 69 |        0b11001110,
 70 |        0b00011100,
 71 |        0b00111000,
 72 |        0b01110000,
 73 |        0b11100110,
 74 |        0b11000110,
 75 |        0b00000000,
 76 |        0b00000000,  // Interchar space
 77 |     },
 78 |     { // ASCII 0x26 ('&')
 79 |        0b11111110,
 80 |        0b11111110,
 81 |        0b11010110,
 82 |        0b11000110,
 83 |        0b00010110,
 84 |        0b00011110,
 85 |        0b00011110,
 86 |        0b00000000,
 87 |        0b00000000,  // Interchar space
 88 |     },
 89 |     { // ASCII 0x27 (''')
 90 |        0b11100000,
 91 |        0b11100000,
 92 |        0b00000000,
 93 |        0b00000000,
 94 |        0b00000000,
 95 |        0b00000000,
 96 |        0b00000000,
 97 |        0b00000000,
 98 |        0b00000000,  // Interchar space
 99 |     },
100 |     { // ASCII 0x28 ('(')
101 |        0b11111110,
102 |        0b11111110,
103 |        0b00000000,
104 |        0b00000000,
105 |        0b00000000,
106 |        0b00000000,
107 |        0b00000000,
108 |        0b00000000,
109 |        0b00000000,  // Interchar space
110 |     },
111 |     { // ASCII 0x29 (')')
112 |        0b00000000,
113 |        0b11111110,
114 |        0b11111110,
115 |        0b00000000,
116 |        0b00000000,
117 |        0b00000000,
118 |        0b00000000,
119 |        0b00000000,
120 |        0b00000000,  // Interchar space
121 |     },
122 |     { // ASCII 0x2A ('*')
123 |        0b01101100,
124 |        0b00010000,
125 |        0b11111110,
126 |        0b11111110,
127 |        0b11111110,
128 |        0b00010000,
129 |        0b01101100,
130 |        0b00000000,
131 |        0b00000000,  // Interchar space
132 |     },
133 |     { // ASCII 0x2B ('+')
134 |        0b00010000,
135 |        0b00010000,
136 |        0b01111100,
137 |        0b00010000,
138 |        0b00010000,
139 |        0b00000000,
140 |        0b00000000,
141 |        0b00000000,
142 |        0b00000000,  // Interchar space
143 |     },
144 |     { // ASCII 0x2C (',')
145 |        0b00000110,
146 |        0b00000110,
147 |        0b00000000,
148 |        0b00000000,
149 |        0b00000000,
150 |        0b00000000,
151 |        0b00000000,
152 |        0b00000000,
153 |        0b00000000,  // Interchar space
154 |     },
155 |     { // ASCII 0x2D ('-')
156 |        0b00010000,
157 |        0b00010000,
158 |        0b00010000,
159 |        0b00010000,
160 |        0b00010000,
161 |        0b00000000,
162 |        0b00000000,
163 |        0b00000000,
164 |        0b00000000,  // Interchar space
165 |     },
166 |     { // ASCII 0x2E ('.')
167 |        0b00000110,
168 |        0b00000110,
169 |        0b00000000,
170 |        0b00000000,
171 |        0b00000000,
172 |        0b00000000,
173 |        0b00000000,
174 |        0b00000000,
175 |        0b00000000,  // Interchar space
176 |     },
177 |     { // ASCII 0x2F ('/')
178 |        0b00001110,
179 |        0b00111000,
180 |        0b11100000,
181 |        0b00000000,
182 |        0b00000000,
183 |        0b00000000,
184 |        0b00000000,
185 |        0b00000000,
186 |        0b00000000,  // Interchar space
187 |     },
188 |     { // ASCII 0x30 ('0')
189 |        0b11111110,
190 |        0b11111110,
191 |        0b11000110,
192 |        0b11000110,
193 |        0b11000110,
194 |        0b11111110,
195 |        0b11111110,
196 |        0b00000000,
197 |        0b00000000,  // Interchar space
198 |     },
199 |     { // ASCII 0x31 ('1')
200 |        0b00000110,
201 |        0b01100110,
202 |        0b01100110,
203 |        0b11111110,
204 |        0b11111110,
205 |        0b00000110,
206 |        0b00000110,
207 |        0b00000000,
208 |        0b00000000,  // Interchar space
209 |     },
210 |     { // ASCII 0x32 ('2')
211 |        0b11011110,
212 |        0b11011110,
213 |        0b11010110,
214 |        0b11010110,
215 |        0b11010110,
216 |        0b11110110,
217 |        0b11110110,
218 |        0b00000000,
219 |        0b00000000,  // Interchar space
220 |     },
221 |     { // ASCII 0x33 ('3')
222 |        0b11000110,
223 |        0b11000110,
224 |        0b11010110,
225 |        0b11010110,
226 |        0b11010110,
227 |        0b11111110,
228 |        0b11111110,
229 |        0b00000000,
230 |        0b00000000,  // Interchar space
231 |     },
232 |     { // ASCII 0x34 ('4')
233 |        0b11111000,
234 |        0b11111000,
235 |        0b00011000,
236 |        0b00011000,
237 |        0b00011000,
238 |        0b01111110,
239 |        0b01111110,
240 |        0b00000000,
241 |        0b00000000,  // Interchar space
242 |     },
243 |     { // ASCII 0x35 ('5')
244 |        0b11110110,
245 |        0b11110110,
246 |        0b11010110,
247 |        0b11010110,
248 |        0b11010110,
249 |        0b11011110,
250 |        0b11011110,
251 |        0b00000000,
252 |        0b00000000,  // Interchar space
253 |     },
254 |     { // ASCII 0x36 ('6')
255 |        0b11111110,
256 |        0b11111110,
257 |        0b00110110,
258 |        0b00110110,
259 |        0b00110110,
260 |        0b00111110,
261 |        0b00111110,
262 |        0b00000000,
263 |        0b00000000,  // Interchar space
264 |     },
265 |     { // ASCII 0x37 ('7')
266 |        0b11000010,
267 |        0b11000110,
268 |        0b11001110,
269 |        0b11011100,
270 |        0b11111000,
271 |        0b11110000,
272 |        0b11100000,
273 |        0b00000000,
274 |        0b00000000,  // Interchar space
275 |     },
276 |     { // ASCII 0x38 ('8')
277 |        0b11111110,
278 |        0b11111110,
279 |        0b11010110,
280 |        0b11010110,
281 |        0b11010110,
282 |        0b11111110,
283 |        0b11111110,
284 |        0b00000000,
285 |        0b00000000,  // Interchar space
286 |     },
287 |     { // ASCII 0x39 ('9')
288 |        0b11111000,
289 |        0b11111000,
290 |        0b11011000,
291 |        0b11011000,
292 |        0b11011000,
293 |        0b11111110,
294 |        0b11111110,
295 |        0b00000000,
296 |        0b00000000,  // Interchar space
297 |     },
298 |     { // ASCII 0x3A (':')
299 |        0b00110110,
300 |        0b00110110,
301 |        0b00000000,
302 |        0b00000000,
303 |        0b00000000,
304 |        0b00000000,
305 |        0b00000000,
306 |        0b00000000,
307 |        0b00000000,  // Interchar space
308 |     },
309 |     { // ASCII 0x3B (';')
310 |        0b00110110,
311 |        0b00110110,
312 |        0b00000000,
313 |        0b00000000,
314 |        0b00000000,
315 |        0b00000000,
316 |        0b00000000,
317 |        0b00000000,
318 |        0b00000000,  // Interchar space
319 |     },
320 |     { // ASCII 0x3C ('<')
321 |        0b00010000,
322 |        0b00101000,
323 |        0b01000100,
324 |        0b01000100,
325 |        0b00000000,
326 |        0b00000000,
327 |        0b00000000,
328 |        0b00000000,
329 |        0b00000000,  // Interchar space
330 |     },
331 |     { // ASCII 0x3D ('=')
332 |        0b00101000,
333 |        0b00101000,
334 |        0b00101000,
335 |        0b00101000,
336 |        0b00101000,
337 |        0b00000000,
338 |        0b00000000,
339 |        0b00000000,
340 |        0b00000000,  // Interchar space
341 |     },
342 |     { // ASCII 0x3E ('>')
343 |        0b01000100,
344 |        0b01000100,
345 |        0b00101000,
346 |        0b00010000,
347 |        0b00000000,
348 |        0b00000000,
349 |        0b00000000,
350 |        0b00000000,
351 |        0b00000000,  // Interchar space
352 |     },
353 |     { // ASCII 0x3F ('?')
354 |        0b11000000,
355 |        0b11000000,
356 |        0b11011010,
357 |        0b11011010,
358 |        0b11010000,
359 |        0b11110000,
360 |        0b11110000,
361 |        0b00000000,
362 |        0b00000000,  // Interchar space
363 |     },
364 |     { // ASCII 0x40 ('@')
365 |        0b11111110,
366 |        0b11111110,
367 |        0b11000110,
368 |        0b11110110,
369 |        0b11010110,
370 |        0b11110110,
371 |        0b11110110,
372 |        0b00000000,
373 |        0b00000000,  // Interchar space
374 |     },
375 |     { // ASCII 0x41 ('A')
376 |        0b11111110,
377 |        0b11111110,
378 |        0b11011000,
379 |        0b11011000,
380 |        0b11011000,
381 |        0b11111110,
382 |        0b11111110,
383 |        0b00000000,
384 |        0b00000000,  // Interchar space
385 |     },
386 |     { // ASCII 0x42 ('B')
387 |        0b11111110,
388 |        0b11111110,
389 |        0b11010110,
390 |        0b11010110,
391 |        0b11110110,
392 |        0b01111110,
393 |        0b00111110,
394 |        0b00000000,
395 |        0b00000000,  // Interchar space
396 |     },
397 |     { // ASCII 0x43 ('C')
398 |        0b11111110,
399 |        0b11111110,
400 |        0b11000110,
401 |        0b11000110,
402 |        0b11000110,
403 |        0b11000110,
404 |        0b11000110,
405 |        0b00000000,
406 |        0b00000000,  // Interchar space
407 |     },
408 |     { // ASCII 0x44 ('D')
409 |        0b11111110,
410 |        0b11111110,
411 |        0b11000110,
412 |        0b11000110,
413 |        0b11100110,
414 |        0b01111110,
415 |        0b00111110,
416 |        0b00000000,
417 |        0b00000000,  // Interchar space
418 |     },
419 |     { // ASCII 0x45 ('E')
420 |        0b11111110,
421 |        0b11111110,
422 |        0b11010110,
423 |        0b11010110,
424 |        0b11010110,
425 |        0b11010110,
426 |        0b11010110,
427 |        0b00000000,
428 |        0b00000000,  // Interchar space
429 |     },
430 |     { // ASCII 0x46 ('F')
431 |        0b11111110,
432 |        0b11111110,
433 |        0b11010000,
434 |        0b11010000,
435 |        0b11010000,
436 |        0b11000000,
437 |        0b11000000,
438 |        0b00000000,
439 |        0b00000000,  // Interchar space
440 |     },
441 |     { // ASCII 0x47 ('G')
442 |        0b11111110,
443 |        0b11111110,
444 |        0b11000110,
445 |        0b11000110,
446 |        0b11010110,
447 |        0b11011110,
448 |        0b11011110,
449 |        0b00000000,
450 |        0b00000000,  // Interchar space
451 |     },
452 |     { // ASCII 0x48 ('H')
453 |        0b11111110,
454 |        0b11111110,
455 |        0b00011000,
456 |        0b00011000,
457 |        0b00011000,
458 |        0b11111110,
459 |        0b11111110,
460 |        0b00000000,
461 |        0b00000000,  // Interchar space
462 |     },
463 |     { // ASCII 0x49 ('I')
464 |        0b11000110,
465 |        0b11000110,
466 |        0b11111110,
467 |        0b11111110,
468 |        0b11000110,
469 |        0b11000110,
470 |        0b11000110,
471 |        0b00000000,
472 |        0b00000000,  // Interchar space
473 |     },
474 |     { // ASCII 0x4A ('J')
475 |        0b00000110,
476 |        0b00000110,
477 |        0b00000110,
478 |        0b00000110,
479 |        0b00000110,
480 |        0b11111110,
481 |        0b11111100,
482 |        0b00000000,
483 |        0b00000000,  // Interchar space
484 |     },
485 |     { // ASCII 0x4B ('K')
486 |        0b11111110,
487 |        0b11111110,
488 |        0b00011000,
489 |        0b00011000,
490 |        0b01111000,
491 |        0b11111110,
492 |        0b10011110,
493 |        0b00000000,
494 |        0b00000000,  // Interchar space
495 |     },
496 |     { // ASCII 0x4C ('L')
497 |        0b11111110,
498 |        0b11111110,
499 |        0b00000110,
500 |        0b00000110,
501 |        0b00000110,
502 |        0b00000110,
503 |        0b00000110,
504 |        0b00000000,
505 |        0b00000000,  // Interchar space
506 |     },
507 |     { // ASCII 0x4D ('M')
508 |        0b11111110,
509 |        0b11111110,
510 |        0b11000000,
511 |        0b01100000,
512 |        0b11000000,
513 |        0b11111110,
514 |        0b11111110,
515 |        0b00000000,
516 |        0b00000000,  // Interchar space
517 |     },
518 |     { // ASCII 0x4E ('N')
519 |        0b11111110,
520 |        0b11111110,
521 |        0b01110000,
522 |        0b00111000,
523 |        0b00011100,
524 |        0b11111110,
525 |        0b11111110,
526 |        0b00000000,
527 |        0b00000000,  // Interchar space
528 |     },
529 |     { // ASCII 0x4F ('O')
530 |        0b11111110,
531 |        0b11111110,
532 |        0b11000110,
533 |        0b11000110,
534 |        0b11000110,
535 |        0b11111110,
536 |        0b11111110,
537 |        0b00000000,
538 |        0b00000000,  // Interchar space
539 |     },
540 |     { // ASCII 0x50 ('P')
541 |        0b11111110,
542 |        0b11111110,
543 |        0b11011000,
544 |        0b11011000,
545 |        0b11011000,
546 |        0b11111000,
547 |        0b11111000,
548 |        0b00000000,
549 |        0b00000000,  // Interchar space
550 |     },
551 |     { // ASCII 0x51 ('Q')
552 |        0b11111110,
553 |        0b11111110,
554 |        0b11000110,
555 |        0b11001110,
556 |        0b11001110,
557 |        0b11111110,
558 |        0b11111110,
559 |        0b00000000,
560 |        0b00000000,  // Interchar space
561 |     },
562 |     { // ASCII 0x52 ('R')
563 |        0b11111110,
564 |        0b11111110,
565 |        0b11011000,
566 |        0b11011100,
567 |        0b11011110,
568 |        0b11111110,
569 |        0b11111010,
570 |        0b00000000,
571 |        0b00000000,  // Interchar space
572 |     },
573 |     { // ASCII 0x53 ('S')
574 |        0b11110110,
575 |        0b11110110,
576 |        0b11010110,
577 |        0b11010110,
578 |        0b11010110,
579 |        0b11011110,
580 |        0b11011110,
581 |        0b00000000,
582 |        0b00000000,  // Interchar space
583 |     },
584 |     { // ASCII 0x54 ('T')
585 |        0b11000000,
586 |        0b11000000,
587 |        0b11111110,
588 |        0b11111110,
589 |        0b11000000,
590 |        0b11000000,
591 |        0b11000000,
592 |        0b00000000,
593 |        0b00000000,  // Interchar space
594 |     },
595 |     { // ASCII 0x55 ('U')
596 |        0b11111110,
597 |        0b11111110,
598 |        0b00000110,
599 |        0b00000110,
600 |        0b00000110,
601 |        0b11111110,
602 |        0b11111110,
603 |        0b00000000,
604 |        0b00000000,  // Interchar space
605 |     },
606 |     { // ASCII 0x56 ('V')
607 |        0b11111000,
608 |        0b11111100,
609 |        0b00001110,
610 |        0b00000110,
611 |        0b00001110,
612 |        0b11111100,
613 |        0b11111000,
614 |        0b00000000,
615 |        0b00000000,  // Interchar space
616 |     },
617 |     { // ASCII 0x57 ('W')
618 |        0b11111100,
619 |        0b11111110,
620 |        0b00000110,
621 |        0b00001100,
622 |        0b00000110,
623 |        0b11111110,
624 |        0b11111100,
625 |        0b00000000,
626 |        0b00000000,  // Interchar space
627 |     },
628 |     { // ASCII 0x58 ('X')
629 |        0b11101110,
630 |        0b11111110,
631 |        0b00111000,
632 |        0b00010000,
633 |        0b00111000,
634 |        0b11111110,
635 |        0b11101110,
636 |        0b00000000,
637 |        0b00000000,  // Interchar space
638 |     },
639 |     { // ASCII 0x59 ('Y')
640 |        0b11100000,
641 |        0b11110000,
642 |        0b00111110,
643 |        0b00011110,
644 |        0b00111110,
645 |        0b11110000,
646 |        0b11100000,
647 |        0b00000000,
648 |        0b00000000,  // Interchar space
649 |     },
650 |     { // ASCII 0x5A ('Z')
651 |        0b11001110,
652 |        0b11011110,
653 |        0b11010110,
654 |        0b11010110,
655 |        0b11010110,
656 |        0b11110110,
657 |        0b11100110,
658 |        0b00000000,
659 |        0b00000000,  // Interchar space
660 |     },
661 |     { // ASCII 0x5B ('[')
662 |        0b11111110,
663 |        0b11111110,
664 |        0b00000000,
665 |        0b00000000,
666 |        0b00000000,
667 |        0b00000000,
668 |        0b00000000,
669 |        0b00000000,
670 |        0b00000000,  // Interchar space
671 |     },
672 |     { // ASCII 0x5C ('\')
673 |        0b11100000,
674 |        0b00111000,
675 |        0b00001110,
676 |        0b00000000,
677 |        0b00000000,
678 |        0b00000000,
679 |        0b00000000,
680 |        0b00000000,
681 |        0b00000000,  // Interchar space
682 |     },
683 |     { // ASCII 0x5D (']')
684 |        0b00000000,
685 |        0b11111110,
686 |        0b00000010,
687 |        0b11111110,
688 |        0b00000000,
689 |        0b00000000,
690 |        0b00000000,
691 |        0b00000000,
692 |        0b00000000,  // Interchar space
693 |     },
694 |     { // ASCII 0x5E ('^')
695 |        0b00000000,
696 |        0b00000000,
697 |        0b00000000,
698 |        0b00000000,
699 |        0b00000000,
700 |        0b00000000,
701 |        0b00000000,
702 |        0b00000000,
703 |        0b00000000,  // Interchar space
704 |     },
705 |     { // ASCII 0x5F ('_')
706 |        0b00000000,
707 |        0b11111110,
708 |        0b00000010,
709 |        0b11111110,
710 |        0b00000000,
711 |        0b00000000,
712 |        0b00000000,
713 |        0b00000000,
714 |        0b00000000,  // Interchar space
715 |     },
716 | };
717 | /*------------------- FONT CUT BOTTOM HERE -------------------------------*/
718 | 


--------------------------------------------------------------------------------
/Arduino/tiny 5x5 font.txt:
--------------------------------------------------------------------------------
  1 | /*------------------- FONT CUT TOP HERE -------------------------------*/
  2 | 
  3 | // A tiny 5x5 font from 
  4 | // https://jared.geek.nz/2014/jan/custom-fonts-for-microcontrollers
  5 | // Nice if you only have 5 strings, or if you want to connect something to the TX pin. 
  6 | // Connect LEDs to pins 2-6
  7 | 
  8 | #define ASCII_OFFSET (0x20)     // ASCII code of 1st char in font array
  9 | #define ASCII_NONPRINT (0x80)   // ASCII code of char to show for chars not included in the font (could also be a space)
 10 | #define FONT_WIDTH 6
 11 | const byte fontdata[][FONT_WIDTH] PROGMEM = {
 12 |     { // ASCII 0x20 (' ')
 13 |        0b00000000,
 14 |        0b00000000,
 15 |        0b00000000,
 16 |        0b00000000,
 17 |        0b00000000,
 18 |        0b00000000,
 19 |     },
 20 |     { // ASCII 0x21 ('!')
 21 |        0b01110100,
 22 |        0b00000000,
 23 |        0b00000000,
 24 |        0b00000000,
 25 |        0b00000000,
 26 |        0b00000000,
 27 |     },
 28 |     { // ASCII 0x22 ('"')
 29 |        0b11000000,
 30 |        0b00000000,
 31 |        0b11000000,
 32 |        0b00000000,
 33 |        0b00000000,
 34 |        0b00000000,
 35 |     },
 36 |     { // ASCII 0x23 ('#')
 37 |        0b00101000,
 38 |        0b01111100,
 39 |        0b00101000,
 40 |        0b01111100,
 41 |        0b00101000,
 42 |        0b00000000,
 43 |     },
 44 |     { // ASCII 0x24 ('$')
 45 |        0b01110100,
 46 |        0b01010100,
 47 |        0b11111110,
 48 |        0b01010100,
 49 |        0b01011100,
 50 |        0b00000000,
 51 |     },
 52 |     { // ASCII 0x25 ('%')
 53 |        0b01000100,
 54 |        0b00001000,
 55 |        0b00010000,
 56 |        0b00100000,
 57 |        0b01000100,
 58 |        0b00000000,
 59 |     },
 60 |     { // ASCII 0x26 ('&')
 61 |        0b00101000,
 62 |        0b01010100,
 63 |        0b01010100,
 64 |        0b00001000,
 65 |        0b00010100,
 66 |        0b00000000,
 67 |     },
 68 |     { // ASCII 0x27 (''')
 69 |        0b11000000,
 70 |        0b00000000,
 71 |        0b00000000,
 72 |        0b00000000,
 73 |        0b00000000,
 74 |        0b00000000,
 75 |     },
 76 |     { // ASCII 0x28 ('(')
 77 |        0b00111000,
 78 |        0b01000100,
 79 |        0b00000000,
 80 |        0b00000000,
 81 |        0b00000000,
 82 |        0b00000000,
 83 |     },
 84 |     { // ASCII 0x29 (')')
 85 |        0b01000100,
 86 |        0b00111000,
 87 |        0b00000000,
 88 |        0b00000000,
 89 |        0b00000000,
 90 |        0b00000000,
 91 |     },
 92 |     { // ASCII 0x2A ('*')
 93 |        0b10000000,
 94 |        0b11000000,
 95 |        0b10000000,
 96 |        0b00000000,
 97 |        0b00000000,
 98 |        0b00000000,
 99 |     },
100 |     { // ASCII 0x2B ('+')
101 |        0b00010000,
102 |        0b00010000,
103 |        0b01111100,
104 |        0b00010000,
105 |        0b00010000,
106 |        0b00000000,
107 |     },
108 |     { // ASCII 0x2C (',')
109 |        0b00000110,
110 |        0b00000000,
111 |        0b00000000,
112 |        0b00000000,
113 |        0b00000000,
114 |        0b00000000,
115 |     },
116 |     { // ASCII 0x2D ('-')
117 |        0b00010000,
118 |        0b00010000,
119 |        0b00010000,
120 |        0b00010000,
121 |        0b00010000,
122 |        0b00000000,
123 |     },
124 |     { // ASCII 0x2E ('.')
125 |        0b00000100,
126 |        0b00000000,
127 |        0b00000000,
128 |        0b00000000,
129 |        0b00000000,
130 |        0b00000000,
131 |     },
132 |     { // ASCII 0x2F ('/')
133 |        0b00001100,
134 |        0b00010000,
135 |        0b01100000,
136 |        0b00000000,
137 |        0b00000000,
138 |        0b00000000,
139 |     },
140 |     { // ASCII 0x30 ('0')
141 |        0b01111100,
142 |        0b01001100,
143 |        0b01010100,
144 |        0b01100100,
145 |        0b01111100,
146 |        0b00000000,
147 |     },
148 |     { // ASCII 0x31 ('1')
149 |        0b00100100,
150 |        0b01111100,
151 |        0b00000100,
152 |        0b00000000,
153 |        0b00000000,
154 |        0b00000000,
155 |     },
156 |     { // ASCII 0x32 ('2')
157 |        0b01001100,
158 |        0b01010100,
159 |        0b01010100,
160 |        0b01010100,
161 |        0b00100100,
162 |        0b00000000,
163 |     },
164 |     { // ASCII 0x33 ('3')
165 |        0b01000100,
166 |        0b01010100,
167 |        0b01010100,
168 |        0b01010100,
169 |        0b01101100,
170 |        0b00000000,
171 |     },
172 |     { // ASCII 0x34 ('4')
173 |        0b01111000,
174 |        0b00001000,
175 |        0b00011100,
176 |        0b00001000,
177 |        0b00001000,
178 |        0b00000000,
179 |     },
180 |     { // ASCII 0x35 ('5')
181 |        0b01110100,
182 |        0b01010100,
183 |        0b01010100,
184 |        0b01010100,
185 |        0b01001000,
186 |        0b00000000,
187 |     },
188 |     { // ASCII 0x36 ('6')
189 |        0b01111100,
190 |        0b01010100,
191 |        0b01010100,
192 |        0b01010100,
193 |        0b01011100,
194 |        0b00000000,
195 |     },
196 |     { // ASCII 0x37 ('7')
197 |        0b01000000,
198 |        0b01000000,
199 |        0b01001100,
200 |        0b01010000,
201 |        0b01100000,
202 |        0b00000000,
203 |     },
204 |     { // ASCII 0x38 ('8')
205 |        0b01111100,
206 |        0b01010100,
207 |        0b01010100,
208 |        0b01010100,
209 |        0b01111100,
210 |        0b00000000,
211 |     },
212 |     { // ASCII 0x39 ('9')
213 |        0b01110100,
214 |        0b01010100,
215 |        0b01010100,
216 |        0b01010100,
217 |        0b01111100,
218 |        0b00000000,
219 |     },
220 |     { // ASCII 0x3A (':')
221 |        0b01000100,
222 |        0b00000000,
223 |        0b00000000,
224 |        0b00000000,
225 |        0b00000000,
226 |        0b00000000,
227 |     },
228 |     { // ASCII 0x3B (';')
229 |        0b01000110,
230 |        0b00000000,
231 |        0b00000000,
232 |        0b00000000,
233 |        0b00000000,
234 |        0b00000000,
235 |     },
236 |     { // ASCII 0x3C ('<')
237 |        0b00010000,
238 |        0b00101000,
239 |        0b01000100,
240 |        0b00000000,
241 |        0b00000000,
242 |        0b00000000,
243 |     },
244 |     { // ASCII 0x3D ('=')
245 |        0b00101000,
246 |        0b00101000,
247 |        0b00101000,
248 |        0b00101000,
249 |        0b00101000,
250 |        0b00000000,
251 |     },
252 |     { // ASCII 0x3E ('>')
253 |        0b01000100,
254 |        0b00101000,
255 |        0b00010000,
256 |        0b00000000,
257 |        0b00000000,
258 |        0b00000000,
259 |     },
260 |     { // ASCII 0x3F ('?')
261 |        0b00100000,
262 |        0b01000000,
263 |        0b01010100,
264 |        0b00100000,
265 |        0b00000000,
266 |        0b00000000,
267 |     },
268 |     { // ASCII 0x40 ('@')
269 |        0b01111100,
270 |        0b01000100,
271 |        0b01010100,
272 |        0b01010100,
273 |        0b01110100,
274 |        0b00000000,
275 |     },
276 |     { // ASCII 0x41 ('A')
277 |        0b01111100,
278 |        0b01001000,
279 |        0b01001000,
280 |        0b01001000,
281 |        0b01111100,
282 |        0b00000000,
283 |     },
284 |     { // ASCII 0x42 ('B')
285 |        0b01111100,
286 |        0b01010100,
287 |        0b01010100,
288 |        0b01010100,
289 |        0b01101100,
290 |        0b00000000,
291 |     },
292 |     { // ASCII 0x43 ('C')
293 |        0b01111100,
294 |        0b01000100,
295 |        0b01000100,
296 |        0b01000100,
297 |        0b01000100,
298 |        0b00000000,
299 |     },
300 |     { // ASCII 0x44 ('D')
301 |        0b01111100,
302 |        0b01000100,
303 |        0b01000100,
304 |        0b01000100,
305 |        0b00111000,
306 |        0b00000000,
307 |     },
308 |     { // ASCII 0x45 ('E')
309 |        0b01111100,
310 |        0b01010100,
311 |        0b01010100,
312 |        0b01010100,
313 |        0b01000100,
314 |        0b00000000,
315 |     },
316 |     { // ASCII 0x46 ('F')
317 |        0b01111100,
318 |        0b01010000,
319 |        0b01010000,
320 |        0b01010000,
321 |        0b01000000,
322 |        0b00000000,
323 |     },
324 |     { // ASCII 0x47 ('G')
325 |        0b01111100,
326 |        0b01000100,
327 |        0b01000100,
328 |        0b01010100,
329 |        0b01011100,
330 |        0b00000000,
331 |     },
332 |     { // ASCII 0x48 ('H')
333 |        0b01111100,
334 |        0b00010000,
335 |        0b00010000,
336 |        0b00010000,
337 |        0b01111100,
338 |        0b00000000,
339 |     },
340 |     { // ASCII 0x49 ('I')
341 |        0b01000100,
342 |        0b01000100,
343 |        0b01111100,
344 |        0b01000100,
345 |        0b01000100,
346 |        0b00000000,
347 |     },
348 |     { // ASCII 0x4A ('J')
349 |        0b00001100,
350 |        0b00000100,
351 |        0b00000100,
352 |        0b01000100,
353 |        0b01111100,
354 |        0b00000000,
355 |     },
356 |     { // ASCII 0x4B ('K')
357 |        0b01111100,
358 |        0b00010000,
359 |        0b00010000,
360 |        0b00101000,
361 |        0b01000100,
362 |        0b00000000,
363 |     },
364 |     { // ASCII 0x4C ('L')
365 |        0b01111100,
366 |        0b00000100,
367 |        0b00000100,
368 |        0b00000100,
369 |        0b00000100,
370 |        0b00000000,
371 |     },
372 |     { // ASCII 0x4D ('M')
373 |        0b01111100,
374 |        0b00100000,
375 |        0b00010000,
376 |        0b00100000,
377 |        0b01111100,
378 |        0b00000000,
379 |     },
380 |     { // ASCII 0x4E ('N')
381 |        0b01111100,
382 |        0b00100000,
383 |        0b00010000,
384 |        0b00001000,
385 |        0b01111100,
386 |        0b00000000,
387 |     },
388 |     { // ASCII 0x4F ('O')
389 |        0b00111000,
390 |        0b01000100,
391 |        0b01000100,
392 |        0b01000100,
393 |        0b00111000,
394 |        0b00000000,
395 |     },
396 |     { // ASCII 0x50 ('P')
397 |        0b01111100,
398 |        0b01010000,
399 |        0b01010000,
400 |        0b01010000,
401 |        0b00100000,
402 |        0b00000000,
403 |     },
404 |     { // ASCII 0x51 ('Q')
405 |        0b01111000,
406 |        0b01001000,
407 |        0b01001100,
408 |        0b01001000,
409 |        0b01111000,
410 |        0b00000000,
411 |     },
412 |     { // ASCII 0x52 ('R')
413 |        0b01111100,
414 |        0b01010000,
415 |        0b01010000,
416 |        0b01010000,
417 |        0b00101100,
418 |        0b00000000,
419 |     },
420 |     { // ASCII 0x53 ('S')
421 |        0b01110100,
422 |        0b01010100,
423 |        0b01010100,
424 |        0b01010100,
425 |        0b01011100,
426 |        0b00000000,
427 |     },
428 |     { // ASCII 0x54 ('T')
429 |        0b01000000,
430 |        0b01000000,
431 |        0b01111100,
432 |        0b01000000,
433 |        0b01000000,
434 |        0b00000000,
435 |     },
436 |     { // ASCII 0x55 ('U')
437 |        0b01111100,
438 |        0b00000100,
439 |        0b00000100,
440 |        0b00000100,
441 |        0b01111100,
442 |        0b00000000,
443 |     },
444 |     { // ASCII 0x56 ('V')
445 |        0b01100000,
446 |        0b00011000,
447 |        0b00000100,
448 |        0b00011000,
449 |        0b01100000,
450 |        0b00000000,
451 |     },
452 |     { // ASCII 0x57 ('W')
453 |        0b01111000,
454 |        0b00000100,
455 |        0b00011000,
456 |        0b00000100,
457 |        0b01111000,
458 |        0b00000000,
459 |     },
460 |     { // ASCII 0x58 ('X')
461 |        0b01000100,
462 |        0b00101000,
463 |        0b00010000,
464 |        0b00101000,
465 |        0b01000100,
466 |        0b00000000,
467 |     },
468 |     { // ASCII 0x59 ('Y')
469 |        0b01100000,
470 |        0b00010000,
471 |        0b00001100,
472 |        0b00010000,
473 |        0b01100000,
474 |        0b00000000,
475 |     },
476 |     { // ASCII 0x5A ('Z')
477 |        0b01000100,
478 |        0b01001100,
479 |        0b01010100,
480 |        0b01100100,
481 |        0b01000100,
482 |        0b00000000,
483 |     },
484 |     { // ASCII 0x5B ('[')
485 |        0b01111100,
486 |        0b01000100,
487 |        0b00000000,
488 |        0b00000000,
489 |        0b00000000,
490 |        0b00000000,
491 |     },
492 |     { // ASCII 0x5C ('\')
493 |        0b01100000,
494 |        0b00010000,
495 |        0b00001100,
496 |        0b00000000,
497 |        0b00000000,
498 |        0b00000000,
499 |     },
500 |     { // ASCII 0x5D (']')
501 |        0b01000100,
502 |        0b01111100,
503 |        0b00000000,
504 |        0b00000000,
505 |        0b00000000,
506 |        0b00000000,
507 |     },
508 |     { // ASCII 0x5E ('^')
509 |        0b00000000,
510 |        0b00000000,
511 |        0b00000000,
512 |        0b00000000,
513 |        0b00000000,
514 |        0b00000000,
515 |     },
516 |     { // ASCII 0x5F ('_')
517 |        0b00000100,
518 |        0b00000100,
519 |        0b00000100,
520 |        0b00000100,
521 |        0b00000100,
522 |        0b00000100,
523 |     },
524 |     { // ASCII 0x60 ('`')
525 |        0b00000000,
526 |        0b00000000,
527 |        0b00000000,
528 |        0b00000000,
529 |        0b00000000,
530 |        0b00000000,
531 |     },
532 |     { // ASCII 0x61 ('a')
533 |        0b01111100,
534 |        0b01001000,
535 |        0b01001000,
536 |        0b01001000,
537 |        0b01111100,
538 |        0b00000000,
539 |     },
540 |     { // ASCII 0x62 ('b')
541 |        0b01111100,
542 |        0b01010100,
543 |        0b01010100,
544 |        0b01010100,
545 |        0b01101100,
546 |        0b00000000,
547 |     },
548 |     { // ASCII 0x63 ('c')
549 |        0b01111100,
550 |        0b01000100,
551 |        0b01000100,
552 |        0b01000100,
553 |        0b01000100,
554 |        0b00000000,
555 |     },
556 |     { // ASCII 0x64 ('d')
557 |        0b01111100,
558 |        0b01000100,
559 |        0b01000100,
560 |        0b01000100,
561 |        0b00111000,
562 |        0b00000000,
563 |     },
564 |     { // ASCII 0x65 ('e')
565 |        0b01111100,
566 |        0b01010100,
567 |        0b01010100,
568 |        0b01010100,
569 |        0b01000100,
570 |        0b00000000,
571 |     },
572 |     { // ASCII 0x66 ('f')
573 |        0b01111100,
574 |        0b01010000,
575 |        0b01010000,
576 |        0b01010000,
577 |        0b01000000,
578 |        0b00000000,
579 |     },
580 |     { // ASCII 0x67 ('g')
581 |        0b01111100,
582 |        0b01000100,
583 |        0b01000100,
584 |        0b01010100,
585 |        0b01011100,
586 |        0b00000000,
587 |     },
588 |     { // ASCII 0x68 ('h')
589 |        0b01111100,
590 |        0b00010000,
591 |        0b00010000,
592 |        0b00010000,
593 |        0b01111100,
594 |        0b00000000,
595 |     },
596 |     { // ASCII 0x69 ('i')
597 |        0b01000100,
598 |        0b01000100,
599 |        0b01111100,
600 |        0b01000100,
601 |        0b01000100,
602 |        0b00000000,
603 |     },
604 |     { // ASCII 0x6A ('j')
605 |        0b00001100,
606 |        0b00000100,
607 |        0b00000100,
608 |        0b01000100,
609 |        0b01111100,
610 |        0b00000000,
611 |     },
612 |     { // ASCII 0x6B ('k')
613 |        0b01111100,
614 |        0b00010000,
615 |        0b00010000,
616 |        0b00101000,
617 |        0b01000100,
618 |        0b00000000,
619 |     },
620 |     { // ASCII 0x6C ('l')
621 |        0b01111100,
622 |        0b00000100,
623 |        0b00000100,
624 |        0b00000100,
625 |        0b00000100,
626 |        0b00000000,
627 |     },
628 |     { // ASCII 0x6D ('m')
629 |        0b01111100,
630 |        0b00100000,
631 |        0b00010000,
632 |        0b00100000,
633 |        0b01111100,
634 |        0b00000000,
635 |     },
636 |     { // ASCII 0x6E ('n')
637 |        0b01111100,
638 |        0b00100000,
639 |        0b00010000,
640 |        0b00001000,
641 |        0b01111100,
642 |        0b00000000,
643 |     },
644 |     { // ASCII 0x6F ('o')
645 |        0b00111000,
646 |        0b01000100,
647 |        0b01000100,
648 |        0b01000100,
649 |        0b00111000,
650 |        0b00000000,
651 |     },
652 |     { // ASCII 0x70 ('p')
653 |        0b01111100,
654 |        0b01010000,
655 |        0b01010000,
656 |        0b01010000,
657 |        0b00100000,
658 |        0b00000000,
659 |     },
660 |     { // ASCII 0x71 ('q')
661 |        0b01111000,
662 |        0b01001000,
663 |        0b01001100,
664 |        0b01001000,
665 |        0b01111000,
666 |        0b00000000,
667 |     },
668 |     { // ASCII 0x72 ('r')
669 |        0b01111100,
670 |        0b01010000,
671 |        0b01010000,
672 |        0b01010000,
673 |        0b00101100,
674 |        0b00000000,
675 |     },
676 |     { // ASCII 0x73 ('s')
677 |        0b01110100,
678 |        0b01010100,
679 |        0b01010100,
680 |        0b01010100,
681 |        0b01011100,
682 |        0b00000000,
683 |     },
684 |     { // ASCII 0x74 ('t')
685 |        0b01000000,
686 |        0b01000000,
687 |        0b01111100,
688 |        0b01000000,
689 |        0b01000000,
690 |        0b00000000,
691 |     },
692 |     { // ASCII 0x75 ('u')
693 |        0b01111100,
694 |        0b00000100,
695 |        0b00000100,
696 |        0b00000100,
697 |        0b01111100,
698 |        0b00000000,
699 |     },
700 |     { // ASCII 0x76 ('v')
701 |        0b01100000,
702 |        0b00011000,
703 |        0b00000100,
704 |        0b00011000,
705 |        0b01100000,
706 |        0b00000000,
707 |     },
708 |     { // ASCII 0x77 ('w')
709 |        0b01111000,
710 |        0b00000100,
711 |        0b00011000,
712 |        0b00000100,
713 |        0b01111000,
714 |        0b00000000,
715 |     },
716 |     { // ASCII 0x78 ('x')
717 |        0b01000100,
718 |        0b00101000,
719 |        0b00010000,
720 |        0b00101000,
721 |        0b01000100,
722 |        0b00000000,
723 |     },
724 |     { // ASCII 0x79 ('y')
725 |        0b01100000,
726 |        0b00010000,
727 |        0b00001100,
728 |        0b00010000,
729 |        0b01100000,
730 |        0b00000000,
731 |     },
732 |     { // ASCII 0x7A ('z')
733 |        0b01000100,
734 |        0b01001100,
735 |        0b01010100,
736 |        0b01100100,
737 |        0b01000100,
738 |        0b00000000,
739 |     },
740 |     { // ASCII 0x7B ('{')
741 |        0b00010000,
742 |        0b01111100,
743 |        0b01000100,
744 |        0b00000000,
745 |        0b00000000,
746 |        0b00000000,
747 |     },
748 |     { // ASCII 0x7C ('|')
749 |        0b01101100,
750 |        0b00000000,
751 |        0b00000000,
752 |        0b00000000,
753 |        0b00000000,
754 |        0b00000000,
755 |     },
756 |     { // ASCII 0x7D ('}')
757 |        0b01000100,
758 |        0b01111100,
759 |        0b00010000,
760 |        0b00000000,
761 |        0b00000000,
762 |        0b00000000,
763 |     },
764 |     { // ASCII 0x7E ('~')
765 |        0b10000000,
766 |        0b00000000,
767 |        0b10000000,
768 |        0b00000000,
769 |        0b00000000,
770 |        0b00000000,
771 |     },
772 | };
773 | /*------------------- FONT CUT BOTTOM HERE -------------------------------*/


--------------------------------------------------------------------------------
/Arduino/Homespun font.txt:
--------------------------------------------------------------------------------
  1 | /*------------------- FONT CUT TOP HERE -------------------------------*/
  2 | // Simple and classy
  3 | // From:
  4 | // https://jared.geek.nz/2014/jan/custom-fonts-for-microcontrollers
  5 | 
  6 | #define ASCII_OFFSET (0x20)     // ASCII code of 1st char in font array
  7 | #define ASCII_NONPRINT (0x80)   // ASCII code of char to show for chars not included in the font (could also be a space)
  8 | #define FONT_WIDTH 8
  9 | const byte fontdata[][FONT_WIDTH] PROGMEM = {
 10 |     { // ASCII 0x20 (' ')
 11 |        0b00000000,
 12 |        0b00000000,
 13 |        0b00000000,
 14 |        0b00000000,
 15 |        0b00000000,
 16 |        0b00000000,
 17 |        0b00000000,
 18 |     },
 19 |     { // ASCII 0x21 ('!')
 20 |        0b11111010,
 21 |        0b00000000,
 22 |        0b00000000,
 23 |        0b00000000,
 24 |        0b00000000,
 25 |        0b00000000,
 26 |        0b00000000,
 27 |     },
 28 |     { // ASCII 0x22 ('"')
 29 |        0b11000000,
 30 |        0b00000000,
 31 |        0b11000000,
 32 |        0b00000000,
 33 |        0b00000000,
 34 |        0b00000000,
 35 |        0b00000000,
 36 |     },
 37 |     { // ASCII 0x23 ('#')
 38 |        0b00101000,
 39 |        0b11111110,
 40 |        0b00101000,
 41 |        0b11111110,
 42 |        0b00101000,
 43 |        0b00000000,
 44 |        0b00000000,
 45 |     },
 46 |     { // ASCII 0x24 ('$')
 47 |        0b11110110,
 48 |        0b10010010,
 49 |        0b10010011,
 50 |        0b11011110,
 51 |        0b00000000,
 52 |        0b00000000,
 53 |        0b00000000,
 54 |     },
 55 |     { // ASCII 0x25 ('%')
 56 |        0b11000110,
 57 |        0b11001000,
 58 |        0b00010000,
 59 |        0b00100110,
 60 |        0b11000110,
 61 |        0b00000000,
 62 |        0b00000000,
 63 |     },
 64 |     { // ASCII 0x26 ('&')
 65 |        0b11111110,
 66 |        0b10010011,
 67 |        0b10010010,
 68 |        0b11000110,
 69 |        0b00000000,
 70 |        0b00000000,
 71 |        0b00000000,
 72 |     },
 73 |     { // ASCII 0x27 (''')
 74 |        0b11000000,
 75 |        0b00000000,
 76 |        0b00000000,
 77 |        0b00000000,
 78 |        0b00000000,
 79 |        0b00000000,
 80 |        0b00000000,
 81 |     },
 82 |     { // ASCII 0x28 ('(')
 83 |        0b01111100,
 84 |        0b10000010,
 85 |        0b00000000,
 86 |        0b00000000,
 87 |        0b00000000,
 88 |        0b00000000,
 89 |        0b00000000,
 90 |     },
 91 |     { // ASCII 0x29 (')')
 92 |        0b10000010,
 93 |        0b01111100,
 94 |        0b00000000,
 95 |        0b00000000,
 96 |        0b00000000,
 97 |        0b00000000,
 98 |        0b00000000,
 99 |     },
100 |     { // ASCII 0x2A ('*')
101 |        0b01010000,
102 |        0b00100000,
103 |        0b11111000,
104 |        0b00100000,
105 |        0b01010000,
106 |        0b00000000,
107 |        0b00000000,
108 |     },
109 |     { // ASCII 0x2B ('+')
110 |        0b00010000,
111 |        0b00010000,
112 |        0b01111100,
113 |        0b00010000,
114 |        0b00010000,
115 |        0b00000000,
116 |        0b00000000,
117 |     },
118 |     { // ASCII 0x2C (',')
119 |        0b00000011,
120 |        0b00000000,
121 |        0b00000000,
122 |        0b00000000,
123 |        0b00000000,
124 |        0b00000000,
125 |        0b00000000,
126 |     },
127 |     { // ASCII 0x2D ('-')
128 |        0b00010000,
129 |        0b00010000,
130 |        0b00010000,
131 |        0b00010000,
132 |        0b00000000,
133 |        0b00000000,
134 |        0b00000000,
135 |     },
136 |     { // ASCII 0x2E ('.')
137 |        0b00000010,
138 |        0b00000000,
139 |        0b00000000,
140 |        0b00000000,
141 |        0b00000000,
142 |        0b00000000,
143 |        0b00000000,
144 |     },
145 |     { // ASCII 0x2F ('/')
146 |        0b00000110,
147 |        0b00001000,
148 |        0b00010000,
149 |        0b00100000,
150 |        0b11000000,
151 |        0b00000000,
152 |        0b00000000,
153 |     },
154 |     { // ASCII 0x30 ('0')
155 |        0b11111110,
156 |        0b10000010,
157 |        0b10000010,
158 |        0b11111110,
159 |        0b00000000,
160 |        0b00000000,
161 |        0b00000000,
162 |     },
163 |     { // ASCII 0x31 ('1')
164 |        0b10000000,
165 |        0b11111110,
166 |        0b00000000,
167 |        0b00000000,
168 |        0b00000000,
169 |        0b00000000,
170 |        0b00000000,
171 |     },
172 |     { // ASCII 0x32 ('2')
173 |        0b11011110,
174 |        0b10010010,
175 |        0b10010010,
176 |        0b11110110,
177 |        0b00000000,
178 |        0b00000000,
179 |        0b00000000,
180 |     },
181 |     { // ASCII 0x33 ('3')
182 |        0b11000110,
183 |        0b10010010,
184 |        0b10010010,
185 |        0b11111110,
186 |        0b00000000,
187 |        0b00000000,
188 |        0b00000000,
189 |     },
190 |     { // ASCII 0x34 ('4')
191 |        0b11110000,
192 |        0b00010000,
193 |        0b00010000,
194 |        0b11111110,
195 |        0b00000000,
196 |        0b00000000,
197 |        0b00000000,
198 |     },
199 |     { // ASCII 0x35 ('5')
200 |        0b11110110,
201 |        0b10010010,
202 |        0b10010010,
203 |        0b11011110,
204 |        0b00000000,
205 |        0b00000000,
206 |        0b00000000,
207 |     },
208 |     { // ASCII 0x36 ('6')
209 |        0b11111110,
210 |        0b10010010,
211 |        0b10010010,
212 |        0b11011110,
213 |        0b00000000,
214 |        0b00000000,
215 |        0b00000000,
216 |     },
217 |     { // ASCII 0x37 ('7')
218 |        0b11000000,
219 |        0b10000000,
220 |        0b10000000,
221 |        0b11111110,
222 |        0b00000000,
223 |        0b00000000,
224 |        0b00000000,
225 |     },
226 |     { // ASCII 0x38 ('8')
227 |        0b11111110,
228 |        0b10010010,
229 |        0b10010010,
230 |        0b11111110,
231 |        0b00000000,
232 |        0b00000000,
233 |        0b00000000,
234 |     },
235 |     { // ASCII 0x39 ('9')
236 |        0b11110000,
237 |        0b10010000,
238 |        0b10010000,
239 |        0b11111110,
240 |        0b00000000,
241 |        0b00000000,
242 |        0b00000000,
243 |     },
244 |     { // ASCII 0x3A (':')
245 |        0b10000010,
246 |        0b00000000,
247 |        0b00000000,
248 |        0b00000000,
249 |        0b00000000,
250 |        0b00000000,
251 |        0b00000000,
252 |     },
253 |     { // ASCII 0x3B (';')
254 |        0b10000011,
255 |        0b00000000,
256 |        0b00000000,
257 |        0b00000000,
258 |        0b00000000,
259 |        0b00000000,
260 |        0b00000000,
261 |     },
262 |     { // ASCII 0x3C ('<')
263 |        0b00010000,
264 |        0b00101000,
265 |        0b01000100,
266 |        0b00000000,
267 |        0b00000000,
268 |        0b00000000,
269 |        0b00000000,
270 |     },
271 |     { // ASCII 0x3D ('=')
272 |        0b00101000,
273 |        0b00101000,
274 |        0b00101000,
275 |        0b00101000,
276 |        0b00000000,
277 |        0b00000000,
278 |        0b00000000,
279 |     },
280 |     { // ASCII 0x3E ('>')
281 |        0b01000100,
282 |        0b00101000,
283 |        0b00010000,
284 |        0b00000000,
285 |        0b00000000,
286 |        0b00000000,
287 |        0b00000000,
288 |     },
289 |     { // ASCII 0x3F ('?')
290 |        0b11000000,
291 |        0b10011010,
292 |        0b10010000,
293 |        0b11110000,
294 |        0b00000000,
295 |        0b00000000,
296 |        0b00000000,
297 |     },
298 |     { // ASCII 0x40 ('@')
299 |        0b11111110,
300 |        0b10000010,
301 |        0b10111010,
302 |        0b10101010,
303 |        0b11111010,
304 |        0b00000000,
305 |        0b00000000,
306 |     },
307 |     { // ASCII 0x41 ('A')
308 |        0b11111110,
309 |        0b10010000,
310 |        0b10010000,
311 |        0b11111110,
312 |        0b00000000,
313 |        0b00000000,
314 |        0b00000000,
315 |     },
316 |     { // ASCII 0x42 ('B')
317 |        0b11111110,
318 |        0b10010010,
319 |        0b10010010,
320 |        0b11101110,
321 |        0b00000000,
322 |        0b00000000,
323 |        0b00000000,
324 |     },
325 |     { // ASCII 0x43 ('C')
326 |        0b11111110,
327 |        0b10000010,
328 |        0b10000010,
329 |        0b11000110,
330 |        0b00000000,
331 |        0b00000000,
332 |        0b00000000,
333 |     },
334 |     { // ASCII 0x44 ('D')
335 |        0b11111110,
336 |        0b10000010,
337 |        0b10000010,
338 |        0b01111100,
339 |        0b00000000,
340 |        0b00000000,
341 |        0b00000000,
342 |     },
343 |     { // ASCII 0x45 ('E')
344 |        0b11111110,
345 |        0b10010010,
346 |        0b10010010,
347 |        0b11000110,
348 |        0b00000000,
349 |        0b00000000,
350 |        0b00000000,
351 |     },
352 |     { // ASCII 0x46 ('F')
353 |        0b11111110,
354 |        0b10010000,
355 |        0b10010000,
356 |        0b11000000,
357 |        0b00000000,
358 |        0b00000000,
359 |        0b00000000,
360 |     },
361 |     { // ASCII 0x47 ('G')
362 |        0b11111110,
363 |        0b10000010,
364 |        0b10010010,
365 |        0b11011110,
366 |        0b00000000,
367 |        0b00000000,
368 |        0b00000000,
369 |     },
370 |     { // ASCII 0x48 ('H')
371 |        0b11111110,
372 |        0b00010000,
373 |        0b00010000,
374 |        0b11111110,
375 |        0b00000000,
376 |        0b00000000,
377 |        0b00000000,
378 |     },
379 |     { // ASCII 0x49 ('I')
380 |        0b10000010,
381 |        0b11111110,
382 |        0b10000010,
383 |        0b00000000,
384 |        0b00000000,
385 |        0b00000000,
386 |        0b00000000,
387 |     },
388 |     { // ASCII 0x4A ('J')
389 |        0b00000110,
390 |        0b00000010,
391 |        0b00000010,
392 |        0b11111110,
393 |        0b00000000,
394 |        0b00000000,
395 |        0b00000000,
396 |     },
397 |     { // ASCII 0x4B ('K')
398 |        0b11111110,
399 |        0b00010000,
400 |        0b00010000,
401 |        0b11101110,
402 |        0b00000000,
403 |        0b00000000,
404 |        0b00000000,
405 |     },
406 |     { // ASCII 0x4C ('L')
407 |        0b11111110,
408 |        0b00000010,
409 |        0b00000010,
410 |        0b00000110,
411 |        0b00000000,
412 |        0b00000000,
413 |        0b00000000,
414 |     },
415 |     { // ASCII 0x4D ('M')
416 |        0b11111110,
417 |        0b10000000,
418 |        0b10000000,
419 |        0b11111110,
420 |        0b10000000,
421 |        0b10000000,
422 |        0b11111110,
423 |     },
424 |     { // ASCII 0x4E ('N')
425 |        0b11111110,
426 |        0b10000000,
427 |        0b10000000,
428 |        0b11111110,
429 |        0b00000000,
430 |        0b00000000,
431 |        0b00000000,
432 |     },
433 |     { // ASCII 0x4F ('O')
434 |        0b11111110,
435 |        0b10000010,
436 |        0b10000010,
437 |        0b11111110,
438 |        0b00000000,
439 |        0b00000000,
440 |        0b00000000,
441 |     },
442 |     { // ASCII 0x50 ('P')
443 |        0b11111110,
444 |        0b10010000,
445 |        0b10010000,
446 |        0b11110000,
447 |        0b00000000,
448 |        0b00000000,
449 |        0b00000000,
450 |     },
451 |     { // ASCII 0x51 ('Q')
452 |        0b11111110,
453 |        0b10000010,
454 |        0b10000011,
455 |        0b11111110,
456 |        0b00000000,
457 |        0b00000000,
458 |        0b00000000,
459 |     },
460 |     { // ASCII 0x52 ('R')
461 |        0b11111110,
462 |        0b10010000,
463 |        0b10010000,
464 |        0b11101110,
465 |        0b00000000,
466 |        0b00000000,
467 |        0b00000000,
468 |     },
469 |     { // ASCII 0x53 ('S')
470 |        0b11110110,
471 |        0b10010010,
472 |        0b10010010,
473 |        0b11011110,
474 |        0b00000000,
475 |        0b00000000,
476 |        0b00000000,
477 |     },
478 |     { // ASCII 0x54 ('T')
479 |        0b10000000,
480 |        0b10000000,
481 |        0b11111110,
482 |        0b10000000,
483 |        0b10000000,
484 |        0b00000000,
485 |        0b00000000,
486 |     },
487 |     { // ASCII 0x55 ('U')
488 |        0b11111110,
489 |        0b00000010,
490 |        0b00000010,
491 |        0b11111110,
492 |        0b00000000,
493 |        0b00000000,
494 |        0b00000000,
495 |     },
496 |     { // ASCII 0x56 ('V')
497 |        0b11111110,
498 |        0b00000100,
499 |        0b00001000,
500 |        0b11110000,
501 |        0b00000000,
502 |        0b00000000,
503 |        0b00000000,
504 |     },
505 |     { // ASCII 0x57 ('W')
506 |        0b11111110,
507 |        0b00000010,
508 |        0b00000010,
509 |        0b11111110,
510 |        0b00000010,
511 |        0b00000010,
512 |        0b11111110,
513 |     },
514 |     { // ASCII 0x58 ('X')
515 |        0b11101110,
516 |        0b00010000,
517 |        0b00010000,
518 |        0b11101110,
519 |        0b00000000,
520 |        0b00000000,
521 |        0b00000000,
522 |     },
523 |     { // ASCII 0x59 ('Y')
524 |        0b11110110,
525 |        0b00010010,
526 |        0b00010010,
527 |        0b11111110,
528 |        0b00000000,
529 |        0b00000000,
530 |        0b00000000,
531 |     },
532 |     { // ASCII 0x5A ('Z')
533 |        0b10001110,
534 |        0b10010010,
535 |        0b10010010,
536 |        0b11100010,
537 |        0b00000000,
538 |        0b00000000,
539 |        0b00000000,
540 |     },
541 |     { // ASCII 0x5B ('[')
542 |        0b11111110,
543 |        0b10000010,
544 |        0b00000000,
545 |        0b00000000,
546 |        0b00000000,
547 |        0b00000000,
548 |        0b00000000,
549 |     },
550 |     { // ASCII 0x5C ('\')
551 |        0b11000000,
552 |        0b00100000,
553 |        0b00010000,
554 |        0b00001000,
555 |        0b00000110,
556 |        0b00000000,
557 |        0b00000000,
558 |     },
559 |     { // ASCII 0x5D (']')
560 |        0b10000010,
561 |        0b11111110,
562 |        0b00000000,
563 |        0b00000000,
564 |        0b00000000,
565 |        0b00000000,
566 |        0b00000000,
567 |     },
568 |     { // ASCII 0x5E ('^')
569 |        0b00100000,
570 |        0b01000000,
571 |        0b10000000,
572 |        0b01000000,
573 |        0b00100000,
574 |        0b00000000,
575 |        0b00000000,
576 |     },
577 |     { // ASCII 0x5F ('_')
578 |        0b00000001,
579 |        0b00000001,
580 |        0b00000001,
581 |        0b00000001,
582 |        0b00000000,
583 |        0b00000000,
584 |        0b00000000,
585 |     },
586 |     { // ASCII 0x60 ('`')
587 |        0b11000000,
588 |        0b00000000,
589 |        0b00000000,
590 |        0b00000000,
591 |        0b00000000,
592 |        0b00000000,
593 |        0b00000000,
594 |     },
595 |     { // ASCII 0x61 ('a')
596 |        0b00101110,
597 |        0b00101010,
598 |        0b00101010,
599 |        0b00111110,
600 |        0b00000000,
601 |        0b00000000,
602 |        0b00000000,
603 |     },
604 |     { // ASCII 0x62 ('b')
605 |        0b11111110,
606 |        0b00100010,
607 |        0b00100010,
608 |        0b00111110,
609 |        0b00000000,
610 |        0b00000000,
611 |        0b00000000,
612 |     },
613 |     { // ASCII 0x63 ('c')
614 |        0b00111110,
615 |        0b00100010,
616 |        0b00100010,
617 |        0b00110110,
618 |        0b00000000,
619 |        0b00000000,
620 |        0b00000000,
621 |     },
622 |     { // ASCII 0x64 ('d')
623 |        0b00111110,
624 |        0b00100010,
625 |        0b00100010,
626 |        0b11111110,
627 |        0b00000000,
628 |        0b00000000,
629 |        0b00000000,
630 |     },
631 |     { // ASCII 0x65 ('e')
632 |        0b00111110,
633 |        0b00101010,
634 |        0b00101010,
635 |        0b00111010,
636 |        0b00000000,
637 |        0b00000000,
638 |        0b00000000,
639 |     },
640 |     { // ASCII 0x66 ('f')
641 |        0b11111110,
642 |        0b10100000,
643 |        0b10100000,
644 |        0b10000000,
645 |        0b00000000,
646 |        0b00000000,
647 |        0b00000000,
648 |     },
649 |     { // ASCII 0x67 ('g')
650 |        0b00111101,
651 |        0b00100101,
652 |        0b00100101,
653 |        0b00111111,
654 |        0b00000000,
655 |        0b00000000,
656 |        0b00000000,
657 |     },
658 |     { // ASCII 0x68 ('h')
659 |        0b11111110,
660 |        0b00100000,
661 |        0b00100000,
662 |        0b00111110,
663 |        0b00000000,
664 |        0b00000000,
665 |        0b00000000,
666 |     },
667 |     { // ASCII 0x69 ('i')
668 |        0b10111110,
669 |        0b00000000,
670 |        0b00000000,
671 |        0b00000000,
672 |        0b00000000,
673 |        0b00000000,
674 |        0b00000000,
675 |     },
676 |     { // ASCII 0x6A ('j')
677 |        0b00000001,
678 |        0b10111111,
679 |        0b00000000,
680 |        0b00000000,
681 |        0b00000000,
682 |        0b00000000,
683 |        0b00000000,
684 |     },
685 |     { // ASCII 0x6B ('k')
686 |        0b11111110,
687 |        0b00100000,
688 |        0b00100000,
689 |        0b01011110,
690 |        0b00000000,
691 |        0b00000000,
692 |        0b00000000,
693 |     },
694 |     { // ASCII 0x6C ('l')
695 |        0b11111110,
696 |        0b00000000,
697 |        0b00000000,
698 |        0b00000000,
699 |        0b00000000,
700 |        0b00000000,
701 |        0b00000000,
702 |     },
703 |     { // ASCII 0x6D ('m')
704 |        0b00111110,
705 |        0b00100000,
706 |        0b00100000,
707 |        0b00111110,
708 |        0b00100000,
709 |        0b00100000,
710 |        0b00111110,
711 |     },
712 |     { // ASCII 0x6E ('n')
713 |        0b00111110,
714 |        0b00100000,
715 |        0b00100000,
716 |        0b00111110,
717 |        0b00000000,
718 |        0b00000000,
719 |        0b00000000,
720 |     },
721 |     { // ASCII 0x6F ('o')
722 |        0b00111110,
723 |        0b00100010,
724 |        0b00100010,
725 |        0b00111110,
726 |        0b00000000,
727 |        0b00000000,
728 |        0b00000000,
729 |     },
730 |     { // ASCII 0x70 ('p')
731 |        0b00111111,
732 |        0b00100010,
733 |        0b00100010,
734 |        0b00111110,
735 |        0b00000000,
736 |        0b00000000,
737 |        0b00000000,
738 |     },
739 |     { // ASCII 0x71 ('q')
740 |        0b00111110,
741 |        0b00100010,
742 |        0b00100010,
743 |        0b00111111,
744 |        0b00000000,
745 |        0b00000000,
746 |        0b00000000,
747 |     },
748 |     { // ASCII 0x72 ('r')
749 |        0b00111110,
750 |        0b00100000,
751 |        0b00100000,
752 |        0b00110000,
753 |        0b00000000,
754 |        0b00000000,
755 |        0b00000000,
756 |     },
757 |     { // ASCII 0x73 ('s')
758 |        0b00111010,
759 |        0b00101010,
760 |        0b00101010,
761 |        0b00101110,
762 |        0b00000000,
763 |        0b00000000,
764 |        0b00000000,
765 |     },
766 |     { // ASCII 0x74 ('t')
767 |        0b11111110,
768 |        0b00100010,
769 |        0b00100010,
770 |        0b00000110,
771 |        0b00000000,
772 |        0b00000000,
773 |        0b00000000,
774 |     },
775 |     { // ASCII 0x75 ('u')
776 |        0b00111110,
777 |        0b00000010,
778 |        0b00000010,
779 |        0b00111110,
780 |        0b00000000,
781 |        0b00000000,
782 |        0b00000000,
783 |     },
784 |     { // ASCII 0x76 ('v')
785 |        0b00111110,
786 |        0b00000100,
787 |        0b00001000,
788 |        0b00110000,
789 |        0b00000000,
790 |        0b00000000,
791 |        0b00000000,
792 |     },
793 |     { // ASCII 0x77 ('w')
794 |        0b00111110,
795 |        0b00000010,
796 |        0b00000010,
797 |        0b00111110,
798 |        0b00000010,
799 |        0b00000010,
800 |        0b00111110,
801 |     },
802 |     { // ASCII 0x78 ('x')
803 |        0b00110110,
804 |        0b00001000,
805 |        0b00001000,
806 |        0b00110110,
807 |        0b00000000,
808 |        0b00000000,
809 |        0b00000000,
810 |     },
811 |     { // ASCII 0x79 ('y')
812 |        0b00111101,
813 |        0b00000101,
814 |        0b00000101,
815 |        0b00111111,
816 |        0b00000000,
817 |        0b00000000,
818 |        0b00000000,
819 |     },
820 |     { // ASCII 0x7A ('z')
821 |        0b00100110,
822 |        0b00101010,
823 |        0b00101010,
824 |        0b00110010,
825 |        0b00000000,
826 |        0b00000000,
827 |        0b00000000,
828 |     },
829 |     { // ASCII 0x7B ('{')
830 |        0b00010000,
831 |        0b01111100,
832 |        0b10000010,
833 |        0b00000000,
834 |        0b00000000,
835 |        0b00000000,
836 |        0b00000000,
837 |     },
838 |     { // ASCII 0x7C ('|')
839 |        0b11111111,
840 |        0b00000000,
841 |        0b00000000,
842 |        0b00000000,
843 |        0b00000000,
844 |        0b00000000,
845 |        0b00000000,
846 |     },
847 |     { // ASCII 0x7D ('}')
848 |        0b10000010,
849 |        0b01111100,
850 |        0b00010000,
851 |        0b00000000,
852 |        0b00000000,
853 |        0b00000000,
854 |        0b00000000,
855 |     },
856 |     { // ASCII 0x7E ('~')
857 |        0b00111000,
858 |        0b00100000,
859 |        0b00111000,
860 |        0b00001000,
861 |        0b00111000,
862 |        0b00000000,
863 |        0b00000000,
864 |     },
865 |     { // ASCII 0x7F       0b00000000,
866 |        0b00000000,
867 |        0b00000000,
868 |        0b00000000,
869 |        0b00000000,
870 |        0b00000000,
871 |        0b00000000,
872 |     },
873 | };
874 | /*------------------- FONT CUT BOTTOM HERE -------------------------------*/


--------------------------------------------------------------------------------
/Arduino/Como too tall font.txt:
--------------------------------------------------------------------------------
  1 | /*------------------- FONT CUT TOP HERE -------------------------------*/
  2 | 
  3 | // This font is 8 bits high, so only useful if you do not need serial communication. 
  4 | 
  5 | #define ASCII_OFFSET (0x20)     // ASCII code of 1st char in font array
  6 | #define ASCII_NONPRINT (0x80)   // ASCII code of char to show for chars not included in the font (could also be a space)
  7 | #define FONT_WIDTH 9
  8 | const byte fontdata[][FONT_WIDTH] PROGMEM = {
  9 |     { // ASCII 0x20 (' ')
 10 |        0b00000000,
 11 |        0b00000000,
 12 |        0b00000000,
 13 |        0b00000000,
 14 |        0b00000000,
 15 |        0b00000000,
 16 |        0b00000000,
 17 |        0b00000000,
 18 |     },
 19 |     { // ASCII 0x21 ('!')
 20 |        0b11111010,
 21 |        0b00111010,
 22 |        0b00000000,
 23 |        0b00000000,
 24 |        0b00000000,
 25 |        0b00000000,
 26 |        0b00000000,
 27 |        0b00000000,
 28 |     },
 29 |     { // ASCII 0x22 ('"')
 30 |        0b11000000,
 31 |        0b11100000,
 32 |        0b00000000,
 33 |        0b11000000,
 34 |        0b11100000,
 35 |        0b00000000,
 36 |        0b00000000,
 37 |        0b00000000,
 38 |     },
 39 |     { // ASCII 0x23 ('#')
 40 |        0b00101000,
 41 |        0b01111100,
 42 |        0b00111100,
 43 |        0b00101000,
 44 |        0b01111100,
 45 |        0b00111100,
 46 |        0b00101000,
 47 |        0b00000000,
 48 |     },
 49 |     { // ASCII 0x24 ('$')
 50 |        0b11110110,
 51 |        0b10110110,
 52 |        0b10010010,
 53 |        0b11111111,
 54 |        0b10111110,
 55 |        0b10010010,
 56 |        0b11011110,
 57 |        0b00000000,
 58 |     },
 59 |     { // ASCII 0x25 ('%')
 60 |        0b10000000,
 61 |        0b11000000,
 62 |        0b11001110,
 63 |        0b11111110,
 64 |        0b11111100,
 65 |        0b11111110,
 66 |        0b10011110,
 67 |        0b00011110,
 68 |     },
 69 |     { // ASCII 0x26 ('&')
 70 |        0b11111100,
 71 |        0b11111100,
 72 |        0b10111110,
 73 |        0b10010010,
 74 |        0b11111110,
 75 |        0b11111100,
 76 |        0b00111110,
 77 |        0b00010010,
 78 |     },
 79 |     { // ASCII 0x27 (''')
 80 |        0b11000000,
 81 |        0b11100000,
 82 |        0b00000000,
 83 |        0b00000000,
 84 |        0b00000000,
 85 |        0b00000000,
 86 |        0b00000000,
 87 |        0b00000000,
 88 |     },
 89 |     { // ASCII 0x28 ('(')
 90 |        0b11111111,
 91 |        0b11111111,
 92 |        0b00000000,
 93 |        0b00000000,
 94 |        0b00000000,
 95 |        0b00000000,
 96 |        0b00000000,
 97 |        0b00000000,
 98 |     },
 99 |     { // ASCII 0x29 (')')
100 |        0b00000000,
101 |        0b00111111,
102 |        0b11111111,
103 |        0b11111111,
104 |        0b00000000,
105 |        0b00000000,
106 |        0b00000000,
107 |        0b00000000,
108 |     },
109 |     { // ASCII 0x2A ('*')
110 |        0b01111000,
111 |        0b01111000,
112 |        0b01111000,
113 |        0b00110000,
114 |        0b11111100,
115 |        0b00110000,
116 |        0b01111000,
117 |        0b01111000,
118 |     },
119 |     { // ASCII 0x2B ('+')
120 |        0b00010000,
121 |        0b00010000,
122 |        0b01111100,
123 |        0b00010000,
124 |        0b00010000,
125 |        0b00000000,
126 |        0b00000000,
127 |        0b00000000,
128 |     },
129 |     { // ASCII 0x2C (',')
130 |        0b00000011,
131 |        0b00000011,
132 |        0b00000000,
133 |        0b00000000,
134 |        0b00000000,
135 |        0b00000000,
136 |        0b00000000,
137 |        0b00000000,
138 |     },
139 |     { // ASCII 0x2D ('-')
140 |        0b00010000,
141 |        0b00010000,
142 |        0b00010000,
143 |        0b00010000,
144 |        0b00000000,
145 |        0b00000000,
146 |        0b00000000,
147 |        0b00000000,
148 |     },
149 |     { // ASCII 0x2E ('.')
150 |        0b00000010,
151 |        0b00000010,
152 |        0b00000000,
153 |        0b00000000,
154 |        0b00000000,
155 |        0b00000000,
156 |        0b00000000,
157 |        0b00000000,
158 |     },
159 |     { // ASCII 0x2F ('/')
160 |        0b00001110,
161 |        0b01111110,
162 |        0b11111000,
163 |        0b11000000,
164 |        0b00000000,
165 |        0b00000000,
166 |        0b00000000,
167 |        0b00000000,
168 |     },
169 |     { // ASCII 0x30 ('0')
170 |        0b11111100,
171 |        0b11111110,
172 |        0b10111110,
173 |        0b10000010,
174 |        0b11111110,
175 |        0b11111100,
176 |        0b00000000,
177 |        0b00000000,
178 |     },
179 |     { // ASCII 0x31 ('1')
180 |        0b01000000,
181 |        0b01111110,
182 |        0b11111110,
183 |        0b00000000,
184 |        0b00000000,
185 |        0b00000000,
186 |        0b00000000,
187 |        0b00000000,
188 |     },
189 |     { // ASCII 0x32 ('2')
190 |        0b10011110,
191 |        0b10011110,
192 |        0b11010010,
193 |        0b11110010,
194 |        0b00000000,
195 |        0b00000000,
196 |        0b00000000,
197 |        0b00000000,
198 |     },
199 |     { // ASCII 0x33 ('3')
200 |        0b10010010,
201 |        0b10010010,
202 |        0b10111110,
203 |        0b11111110,
204 |        0b00000000,
205 |        0b00000000,
206 |        0b00000000,
207 |        0b00000000,
208 |     },
209 |     { // ASCII 0x34 ('4')
210 |        0b11110000,
211 |        0b00010000,
212 |        0b00010000,
213 |        0b00111110,
214 |        0b11111110,
215 |        0b00000000,
216 |        0b00000000,
217 |        0b00000000,
218 |     },
219 |     { // ASCII 0x35 ('5')
220 |        0b11110010,
221 |        0b11010010,
222 |        0b10010010,
223 |        0b10011110,
224 |        0b10011110,
225 |        0b00000000,
226 |        0b00000000,
227 |        0b00000000,
228 |     },
229 |     { // ASCII 0x36 ('6')
230 |        0b11111110,
231 |        0b11111110,
232 |        0b10111110,
233 |        0b10010010,
234 |        0b10011110,
235 |        0b00000000,
236 |        0b00000000,
237 |        0b00000000,
238 |     },
239 |     { // ASCII 0x37 ('7')
240 |        0b10000000,
241 |        0b10000000,
242 |        0b10111110,
243 |        0b11111110,
244 |        0b00000000,
245 |        0b00000000,
246 |        0b00000000,
247 |        0b00000000,
248 |     },
249 |     { // ASCII 0x38 ('8')
250 |        0b11111110,
251 |        0b11111110,
252 |        0b10111110,
253 |        0b10010010,
254 |        0b11111110,
255 |        0b00000000,
256 |        0b00000000,
257 |        0b00000000,
258 |     },
259 |     { // ASCII 0x39 ('9')
260 |        0b11110010,
261 |        0b11110010,
262 |        0b10010010,
263 |        0b10111110,
264 |        0b11111110,
265 |        0b00000000,
266 |        0b00000000,
267 |        0b00000000,
268 |     },
269 |     { // ASCII 0x3A (':')
270 |        0b00010100,
271 |        0b00010100,
272 |        0b00000000,
273 |        0b00000000,
274 |        0b00000000,
275 |        0b00000000,
276 |        0b00000000,
277 |        0b00000000,
278 |     },
279 |     { // ASCII 0x3B (';')
280 |        0b00001011,
281 |        0b00001011,
282 |        0b00000000,
283 |        0b00000000,
284 |        0b00000000,
285 |        0b00000000,
286 |        0b00000000,
287 |        0b00000000,
288 |     },
289 |     { // ASCII 0x3C ('<')
290 |        0b00010000,
291 |        0b00111000,
292 |        0b01101100,
293 |        0b01000100,
294 |        0b00000000,
295 |        0b00000000,
296 |        0b00000000,
297 |        0b00000000,
298 |     },
299 |     { // ASCII 0x3D ('=')
300 |        0b00101000,
301 |        0b00101000,
302 |        0b00101000,
303 |        0b00101000,
304 |        0b00000000,
305 |        0b00000000,
306 |        0b00000000,
307 |        0b00000000,
308 |     },
309 |     { // ASCII 0x3E ('>')
310 |        0b01000100,
311 |        0b01101100,
312 |        0b00111000,
313 |        0b00010000,
314 |        0b00000000,
315 |        0b00000000,
316 |        0b00000000,
317 |        0b00000000,
318 |     },
319 |     { // ASCII 0x3F ('?')
320 |        0b11000000,
321 |        0b10001010,
322 |        0b10011010,
323 |        0b11010000,
324 |        0b11110000,
325 |        0b00000000,
326 |        0b00000000,
327 |        0b00000000,
328 |     },
329 |     { // ASCII 0x40 ('@')
330 |        0b01111110,
331 |        0b11111111,
332 |        0b11000001,
333 |        0b10111100,
334 |        0b11111100,
335 |        0b11101000,
336 |        0b11111100,
337 |        0b11111100,
338 |     },
339 |     { // ASCII 0x41 ('A')
340 |        0b11111110,
341 |        0b11111110,
342 |        0b10111110,
343 |        0b10010000,
344 |        0b10010000,
345 |        0b11111110,
346 |        0b00000000,
347 |        0b00000000,
348 |     },
349 |     { // ASCII 0x42 ('B')
350 |        0b11111110,
351 |        0b11111110,
352 |        0b10110110,
353 |        0b10110110,
354 |        0b11111110,
355 |        0b11111100,
356 |        0b00000000,
357 |        0b00000000,
358 |     },
359 |     { // ASCII 0x43 ('C')
360 |        0b11111100,
361 |        0b11111110,
362 |        0b10000010,
363 |        0b10000010,
364 |        0b00000000,
365 |        0b00000000,
366 |        0b00000000,
367 |        0b00000000,
368 |     },
369 |     { // ASCII 0x44 ('D')
370 |        0b11111110,
371 |        0b10111110,
372 |        0b10000110,
373 |        0b10000110,
374 |        0b11111110,
375 |        0b11111100,
376 |        0b00000000,
377 |        0b00000000,
378 |     },
379 |     { // ASCII 0x45 ('E')
380 |        0b11111110,
381 |        0b11111110,
382 |        0b10111110,
383 |        0b10010010,
384 |        0b10010010,
385 |        0b00000000,
386 |        0b00000000,
387 |        0b00000000,
388 |     },
389 |     { // ASCII 0x46 ('F')
390 |        0b11111110,
391 |        0b11111110,
392 |        0b10111110,
393 |        0b10010000,
394 |        0b10010000,
395 |        0b00000000,
396 |        0b00000000,
397 |        0b00000000,
398 |     },
399 |     { // ASCII 0x47 ('G')
400 |        0b11111110,
401 |        0b11111110,
402 |        0b10111110,
403 |        0b10010010,
404 |        0b00011110,
405 |        0b00000000,
406 |        0b00000000,
407 |        0b00000000,
408 |     },
409 |     { // ASCII 0x48 ('H')
410 |        0b11111110,
411 |        0b00111110,
412 |        0b00010000,
413 |        0b00010000,
414 |        0b11111110,
415 |        0b00000000,
416 |        0b00000000,
417 |        0b00000000,
418 |     },
419 |     { // ASCII 0x49 ('I')
420 |        0b11111110,
421 |        0b00111110,
422 |        0b00000000,
423 |        0b00000000,
424 |        0b00000000,
425 |        0b00000000,
426 |        0b00000000,
427 |        0b00000000,
428 |     },
429 |     { // ASCII 0x4A ('J')
430 |        0b11111111,
431 |        0b00111111,
432 |        0b00000000,
433 |        0b00000000,
434 |        0b00000000,
435 |        0b00000000,
436 |        0b00000000,
437 |        0b00000000,
438 |     },
439 |     { // ASCII 0x4B ('K')
440 |        0b11111110,
441 |        0b01111110,
442 |        0b00110000,
443 |        0b00110000,
444 |        0b11111110,
445 |        0b11111110,
446 |        0b00000000,
447 |        0b00000000,
448 |     },
449 |     { // ASCII 0x4C ('L')
450 |        0b11111110,
451 |        0b00111110,
452 |        0b00000010,
453 |        0b00000010,
454 |        0b00000000,
455 |        0b00000000,
456 |        0b00000000,
457 |        0b00000000,
458 |     },
459 |     { // ASCII 0x4D ('M')
460 |        0b11111110,
461 |        0b10111110,
462 |        0b10000000,
463 |        0b11111110,
464 |        0b11111110,
465 |        0b10111110,
466 |        0b11111110,
467 |        0b11111110,
468 |     },
469 |     { // ASCII 0x4E ('N')
470 |        0b11111110,
471 |        0b10111110,
472 |        0b10000000,
473 |        0b10000000,
474 |        0b11111110,
475 |        0b11111110,
476 |        0b00000000,
477 |        0b00000000,
478 |     },
479 |     { // ASCII 0x4F ('O')
480 |        0b11111100,
481 |        0b11111110,
482 |        0b10000110,
483 |        0b11100110,
484 |        0b11111110,
485 |        0b11111100,
486 |        0b00000000,
487 |        0b00000000,
488 |     },
489 |     { // ASCII 0x50 ('P')
490 |        0b11111110,
491 |        0b11111110,
492 |        0b10110000,
493 |        0b10110000,
494 |        0b11110000,
495 |        0b11100000,
496 |        0b00000000,
497 |        0b00000000,
498 |     },
499 |     { // ASCII 0x51 ('Q')
500 |        0b11111100,
501 |        0b11111110,
502 |        0b10000110,
503 |        0b11100111,
504 |        0b11111111,
505 |        0b11111101,
506 |        0b00000000,
507 |        0b00000000,
508 |     },
509 |     { // ASCII 0x52 ('R')
510 |        0b11111110,
511 |        0b11111110,
512 |        0b10110000,
513 |        0b10110000,
514 |        0b11111110,
515 |        0b11111110,
516 |        0b00000000,
517 |        0b00000000,
518 |     },
519 |     { // ASCII 0x53 ('S')
520 |        0b11110110,
521 |        0b10110110,
522 |        0b10010010,
523 |        0b10010010,
524 |        0b11011110,
525 |        0b00000000,
526 |        0b00000000,
527 |        0b00000000,
528 |     },
529 |     { // ASCII 0x54 ('T')
530 |        0b10000000,
531 |        0b10000000,
532 |        0b11111110,
533 |        0b10111110,
534 |        0b10000000,
535 |        0b00000000,
536 |        0b00000000,
537 |        0b00000000,
538 |     },
539 |     { // ASCII 0x55 ('U')
540 |        0b11111100,
541 |        0b00111110,
542 |        0b00000010,
543 |        0b00000010,
544 |        0b11111110,
545 |        0b00000000,
546 |        0b00000000,
547 |        0b00000000,
548 |     },
549 |     { // ASCII 0x56 ('V')
550 |        0b11111000,
551 |        0b00111100,
552 |        0b00111110,
553 |        0b00000110,
554 |        0b00001110,
555 |        0b11111100,
556 |        0b11111000,
557 |        0b00000000,
558 |     },
559 |     { // ASCII 0x57 ('W')
560 |        0b11111100,
561 |        0b00111110,
562 |        0b00000110,
563 |        0b11111110,
564 |        0b00111110,
565 |        0b00000110,
566 |        0b11111110,
567 |        0b11111100,
568 |     },
569 |     { // ASCII 0x58 ('X')
570 |        0b11111110,
571 |        0b01111110,
572 |        0b00110000,
573 |        0b00110000,
574 |        0b11111110,
575 |        0b11111110,
576 |        0b00000000,
577 |        0b00000000,
578 |     },
579 |     { // ASCII 0x59 ('Y')
580 |        0b11110000,
581 |        0b11111010,
582 |        0b00011010,
583 |        0b11111010,
584 |        0b11111110,
585 |        0b11111100,
586 |        0b00000000,
587 |        0b00000000,
588 |     },
589 |     { // ASCII 0x5A ('Z')
590 |        0b10000110,
591 |        0b10001110,
592 |        0b10011010,
593 |        0b10110010,
594 |        0b11100010,
595 |        0b00000000,
596 |        0b00000000,
597 |        0b00000000,
598 |     },
599 |     { // ASCII 0x5B ('[')
600 |        0b11111111,
601 |        0b00111111,
602 |        0b00000000,
603 |        0b00000000,
604 |        0b00000000,
605 |        0b00000000,
606 |        0b00000000,
607 |        0b00000000,
608 |     },
609 |     { // ASCII 0x5C ('\')
610 |        0b11000000,
611 |        0b11111000,
612 |        0b01111110,
613 |        0b00001110,
614 |        0b00000000,
615 |        0b00000000,
616 |        0b00000000,
617 |        0b00000000,
618 |     },
619 |     { // ASCII 0x5D (']')
620 |        0b00000000,
621 |        0b11110000,
622 |        0b11111111,
623 |        0b00000000,
624 |        0b00000000,
625 |        0b00000000,
626 |        0b00000000,
627 |        0b00000000,
628 |     },
629 |     { // ASCII 0x5E ('^')
630 |        0b01000000,
631 |        0b11000000,
632 |        0b10000000,
633 |        0b11000000,
634 |        0b01000000,
635 |        0b00000000,
636 |        0b00000000,
637 |        0b00000000,
638 |     },
639 |     { // ASCII 0x5F ('_')
640 |        0b00000010,
641 |        0b00000010,
642 |        0b00000010,
643 |        0b00000010,
644 |        0b00000010,
645 |        0b00000000,
646 |        0b00000000,
647 |        0b00000000,
648 |     },
649 |     { // ASCII 0x60 ('`')
650 |        0b10000000,
651 |        0b11000000,
652 |        0b01000000,
653 |        0b00000000,
654 |        0b00000000,
655 |        0b00000000,
656 |        0b00000000,
657 |        0b00000000,
658 |     },
659 |     { // ASCII 0x61 ('a')
660 |        0b11111110,
661 |        0b11111110,
662 |        0b10111110,
663 |        0b10010000,
664 |        0b10010000,
665 |        0b11111110,
666 |        0b00000000,
667 |        0b00000000,
668 |     },
669 |     { // ASCII 0x62 ('b')
670 |        0b11111110,
671 |        0b11111110,
672 |        0b10110110,
673 |        0b10110110,
674 |        0b11111110,
675 |        0b11111100,
676 |        0b00000000,
677 |        0b00000000,
678 |     },
679 |     { // ASCII 0x63 ('c')
680 |        0b11111100,
681 |        0b11111110,
682 |        0b10000010,
683 |        0b10000010,
684 |        0b00000000,
685 |        0b00000000,
686 |        0b00000000,
687 |        0b00000000,
688 |     },
689 |     { // ASCII 0x64 ('d')
690 |        0b11111110,
691 |        0b10111110,
692 |        0b10000110,
693 |        0b10000110,
694 |        0b11111110,
695 |        0b11111100,
696 |        0b00000000,
697 |        0b00000000,
698 |     },
699 |     { // ASCII 0x65 ('e')
700 |        0b11111110,
701 |        0b11111110,
702 |        0b10111110,
703 |        0b10010010,
704 |        0b10010010,
705 |        0b00000000,
706 |        0b00000000,
707 |        0b00000000,
708 |     },
709 |     { // ASCII 0x66 ('f')
710 |        0b11111110,
711 |        0b11111110,
712 |        0b10111110,
713 |        0b10010000,
714 |        0b10010000,
715 |        0b00000000,
716 |        0b00000000,
717 |        0b00000000,
718 |     },
719 |     { // ASCII 0x67 ('g')
720 |        0b11111110,
721 |        0b11111110,
722 |        0b10111110,
723 |        0b10010010,
724 |        0b00011110,
725 |        0b00000000,
726 |        0b00000000,
727 |        0b00000000,
728 |     },
729 |     { // ASCII 0x68 ('h')
730 |        0b11111110,
731 |        0b00111110,
732 |        0b00010000,
733 |        0b00010000,
734 |        0b11111110,
735 |        0b00000000,
736 |        0b00000000,
737 |        0b00000000,
738 |     },
739 |     { // ASCII 0x69 ('i')
740 |        0b11111110,
741 |        0b00111110,
742 |        0b00000000,
743 |        0b00000000,
744 |        0b00000000,
745 |        0b00000000,
746 |        0b00000000,
747 |        0b00000000,
748 |     },
749 |     { // ASCII 0x6A ('j')
750 |        0b11111111,
751 |        0b00111111,
752 |        0b00000000,
753 |        0b00000000,
754 |        0b00000000,
755 |        0b00000000,
756 |        0b00000000,
757 |        0b00000000,
758 |     },
759 |     { // ASCII 0x6B ('k')
760 |        0b11111110,
761 |        0b01111110,
762 |        0b00110000,
763 |        0b00110000,
764 |        0b11111110,
765 |        0b11111110,
766 |        0b00000000,
767 |        0b00000000,
768 |     },
769 |     { // ASCII 0x6C ('l')
770 |        0b11111110,
771 |        0b00111110,
772 |        0b00000010,
773 |        0b00000010,
774 |        0b00000000,
775 |        0b00000000,
776 |        0b00000000,
777 |        0b00000000,
778 |     },
779 |     { // ASCII 0x6D ('m')
780 |        0b11111110,
781 |        0b10111110,
782 |        0b10000000,
783 |        0b11111110,
784 |        0b11111110,
785 |        0b10111110,
786 |        0b11111110,
787 |        0b11111110,
788 |     },
789 |     { // ASCII 0x6E ('n')
790 |        0b11111110,
791 |        0b10111110,
792 |        0b10000000,
793 |        0b10000000,
794 |        0b11111110,
795 |        0b11111110,
796 |        0b00000000,
797 |        0b00000000,
798 |     },
799 |     { // ASCII 0x6F ('o')
800 |        0b11111100,
801 |        0b11111110,
802 |        0b10000110,
803 |        0b11100110,
804 |        0b11111110,
805 |        0b11111100,
806 |        0b00000000,
807 |        0b00000000,
808 |     },
809 |     { // ASCII 0x70 ('p')
810 |        0b11111110,
811 |        0b11111110,
812 |        0b10110000,
813 |        0b10110000,
814 |        0b11110000,
815 |        0b11100000,
816 |        0b00000000,
817 |        0b00000000,
818 |     },
819 |     { // ASCII 0x71 ('q')
820 |        0b11111100,
821 |        0b11111110,
822 |        0b10000110,
823 |        0b11100111,
824 |        0b11111111,
825 |        0b11111101,
826 |        0b00000000,
827 |        0b00000000,
828 |     },
829 |     { // ASCII 0x72 ('r')
830 |        0b11111110,
831 |        0b11111110,
832 |        0b10110000,
833 |        0b10110000,
834 |        0b11111110,
835 |        0b11111110,
836 |        0b00000000,
837 |        0b00000000,
838 |     },
839 |     { // ASCII 0x73 ('s')
840 |        0b11110110,
841 |        0b10110110,
842 |        0b10010010,
843 |        0b10010010,
844 |        0b11011110,
845 |        0b00000000,
846 |        0b00000000,
847 |        0b00000000,
848 |     },
849 |     { // ASCII 0x74 ('t')
850 |        0b10000000,
851 |        0b10000000,
852 |        0b11111110,
853 |        0b10111110,
854 |        0b10000000,
855 |        0b00000000,
856 |        0b00000000,
857 |        0b00000000,
858 |     },
859 |     { // ASCII 0x75 ('u')
860 |        0b11111100,
861 |        0b00111110,
862 |        0b00000010,
863 |        0b00000010,
864 |        0b11111110,
865 |        0b00000000,
866 |        0b00000000,
867 |        0b00000000,
868 |     },
869 |     { // ASCII 0x76 ('v')
870 |        0b11111000,
871 |        0b00111100,
872 |        0b00111110,
873 |        0b00000110,
874 |        0b00001110,
875 |        0b11111100,
876 |        0b11111000,
877 |        0b00000000,
878 |     },
879 |     { // ASCII 0x77 ('w')
880 |        0b11111100,
881 |        0b00111110,
882 |        0b00000110,
883 |        0b11111110,
884 |        0b00111110,
885 |        0b00000110,
886 |        0b11111110,
887 |        0b11111100,
888 |     },
889 |     { // ASCII 0x78 ('x')
890 |        0b11111110,
891 |        0b01111110,
892 |        0b00110000,
893 |        0b00110000,
894 |        0b11111110,
895 |        0b11111110,
896 |        0b00000000,
897 |        0b00000000,
898 |     },
899 |     { // ASCII 0x79 ('y')
900 |        0b11110000,
901 |        0b11111010,
902 |        0b00011010,
903 |        0b11111010,
904 |        0b11111110,
905 |        0b11111100,
906 |        0b00000000,
907 |        0b00000000,
908 |     },
909 |     { // ASCII 0x7A ('z')
910 |        0b10000110,
911 |        0b10001110,
912 |        0b10011010,
913 |        0b10110010,
914 |        0b11100010,
915 |        0b00000000,
916 |        0b00000000,
917 |        0b00000000,
918 |     },
919 |     { // ASCII 0x7B ('{')
920 |        0b00100000,
921 |        0b11111111,
922 |        0b11111111,
923 |        0b00000000,
924 |        0b00000000,
925 |        0b00000000,
926 |        0b00000000,
927 |        0b00000000,
928 |     },
929 |     { // ASCII 0x7C ('|')
930 |        0b11111111,
931 |        0b00111111,
932 |        0b00000000,
933 |        0b00000000,
934 |        0b00000000,
935 |        0b00000000,
936 |        0b00000000,
937 |        0b00000000,
938 |     },
939 |     { // ASCII 0x7D ('}')
940 |        0b00000000,
941 |        0b00111111,
942 |        0b11111111,
943 |        0b11111111,
944 |        0b00100000,
945 |        0b00000000,
946 |        0b00000000,
947 |        0b00000000,
948 |     },
949 |     { // ASCII 0x7E ('~')
950 |        0b01000000,
951 |        0b11000000,
952 |        0b11000000,
953 |        0b10000000,
954 |        0b00000000,
955 |        0b00000000,
956 |        0b00000000,
957 |        0b00000000,
958 |     },
959 |     { // ASCII 0x7F       0b00000000,
960 |        0b00000000,
961 |        0b00000000,
962 |        0b00000000,
963 |        0b00000000,
964 |        0b00000000,
965 |        0b00000000,
966 |        0b00000000,
967 |     },
968 | };
969 | /*------------------- FONT CUT BOTTOM HERE -------------------------------*/


--------------------------------------------------------------------------------
/Arduino/Hunter thick and rich font.txt:
--------------------------------------------------------------------------------
  1 | /*------------------- FONT CUT TOP HERE -------------------------------*/
  2 | 
  3 | // A thick and rich font from...
  4 | // https://jared.geek.nz/2014/jan/custom-fonts-for-microcontrollers
  5 | 
  6 | #define ASCII_OFFSET (0x20)     // ASCII code of 1st char in font array
  7 | #define ASCII_NONPRINT (0x80)   // ASCII code of char to show for chars not included in the font (could also be a space)
  8 | #define FONT_WIDTH 9
  9 | const byte fontdata[][FONT_WIDTH] PROGMEM = {
 10 |     { // ASCII 0x20 (' ')
 11 |        0b00000000,
 12 |        0b00000000,
 13 |        0b00000000,
 14 |        0b00000000,
 15 |        0b00000000,
 16 |        0b00000000,
 17 |        0b00000000,
 18 |        0b00000000,
 19 |     },
 20 |     { // ASCII 0x21 ('!')
 21 |        0b11111010,
 22 |        0b11111010,
 23 |        0b00000000,
 24 |        0b00000000,
 25 |        0b00000000,
 26 |        0b00000000,
 27 |        0b00000000,
 28 |        0b00000000,
 29 |     },
 30 |     { // ASCII 0x22 ('"')
 31 |        0b11100000,
 32 |        0b11100000,
 33 |        0b00000000,
 34 |        0b11100000,
 35 |        0b11100000,
 36 |        0b00000000,
 37 |        0b00000000,
 38 |        0b00000000,
 39 |     },
 40 |     { // ASCII 0x23 ('#')
 41 |        0b00101000,
 42 |        0b11111110,
 43 |        0b11111110,
 44 |        0b00101000,
 45 |        0b11111110,
 46 |        0b11111110,
 47 |        0b00101000,
 48 |        0b00000000,
 49 |     },
 50 |     { // ASCII 0x24 ('$')
 51 |        0b11110110,
 52 |        0b11110110,
 53 |        0b11010110,
 54 |        0b11010111,
 55 |        0b11010110,
 56 |        0b11011110,
 57 |        0b11011110,
 58 |        0b00000000,
 59 |     },
 60 |     { // ASCII 0x25 ('%')
 61 |        0b11000110,
 62 |        0b11001110,
 63 |        0b00011100,
 64 |        0b00111000,
 65 |        0b01110000,
 66 |        0b11100110,
 67 |        0b11000110,
 68 |        0b00000000,
 69 |     },
 70 |     { // ASCII 0x26 ('&')
 71 |        0b11111110,
 72 |        0b11111110,
 73 |        0b11010110,
 74 |        0b11000110,
 75 |        0b00010110,
 76 |        0b00011110,
 77 |        0b00011110,
 78 |        0b00000000,
 79 |     },
 80 |     { // ASCII 0x27 (''')
 81 |        0b11100000,
 82 |        0b11100000,
 83 |        0b00000000,
 84 |        0b00000000,
 85 |        0b00000000,
 86 |        0b00000000,
 87 |        0b00000000,
 88 |        0b00000000,
 89 |     },
 90 |     { // ASCII 0x28 ('(')
 91 |        0b11111111,
 92 |        0b11111111,
 93 |        0b00000001,
 94 |        0b00000000,
 95 |        0b00000000,
 96 |        0b00000000,
 97 |        0b00000000,
 98 |        0b00000000,
 99 |     },
100 |     { // ASCII 0x29 (')')
101 |        0b00000001,
102 |        0b11111111,
103 |        0b11111111,
104 |        0b00000000,
105 |        0b00000000,
106 |        0b00000000,
107 |        0b00000000,
108 |        0b00000000,
109 |     },
110 |     { // ASCII 0x2A ('*')
111 |        0b01101100,
112 |        0b00010000,
113 |        0b11111110,
114 |        0b11111110,
115 |        0b11111110,
116 |        0b00010000,
117 |        0b01101100,
118 |        0b00000000,
119 |     },
120 |     { // ASCII 0x2B ('+')
121 |        0b00010000,
122 |        0b00010000,
123 |        0b01111100,
124 |        0b00010000,
125 |        0b00010000,
126 |        0b00000000,
127 |        0b00000000,
128 |        0b00000000,
129 |     },
130 |     { // ASCII 0x2C (',')
131 |        0b00000111,
132 |        0b00000111,
133 |        0b00000000,
134 |        0b00000000,
135 |        0b00000000,
136 |        0b00000000,
137 |        0b00000000,
138 |        0b00000000,
139 |     },
140 |     { // ASCII 0x2D ('-')
141 |        0b00010000,
142 |        0b00010000,
143 |        0b00010000,
144 |        0b00010000,
145 |        0b00010000,
146 |        0b00000000,
147 |        0b00000000,
148 |        0b00000000,
149 |     },
150 |     { // ASCII 0x2E ('.')
151 |        0b00000110,
152 |        0b00000110,
153 |        0b00000000,
154 |        0b00000000,
155 |        0b00000000,
156 |        0b00000000,
157 |        0b00000000,
158 |        0b00000000,
159 |     },
160 |     { // ASCII 0x2F ('/')
161 |        0b00001110,
162 |        0b00111000,
163 |        0b11100000,
164 |        0b00000000,
165 |        0b00000000,
166 |        0b00000000,
167 |        0b00000000,
168 |        0b00000000,
169 |     },
170 |     { // ASCII 0x30 ('0')
171 |        0b11111110,
172 |        0b11111110,
173 |        0b11000110,
174 |        0b11000110,
175 |        0b11000110,
176 |        0b11111110,
177 |        0b11111110,
178 |        0b00000000,
179 |     },
180 |     { // ASCII 0x31 ('1')
181 |        0b00000110,
182 |        0b01100110,
183 |        0b01100110,
184 |        0b11111110,
185 |        0b11111110,
186 |        0b00000110,
187 |        0b00000110,
188 |        0b00000000,
189 |     },
190 |     { // ASCII 0x32 ('2')
191 |        0b11011110,
192 |        0b11011110,
193 |        0b11010110,
194 |        0b11010110,
195 |        0b11010110,
196 |        0b11110110,
197 |        0b11110110,
198 |        0b00000000,
199 |     },
200 |     { // ASCII 0x33 ('3')
201 |        0b11000110,
202 |        0b11000110,
203 |        0b11010110,
204 |        0b11010110,
205 |        0b11010110,
206 |        0b11111110,
207 |        0b11111110,
208 |        0b00000000,
209 |     },
210 |     { // ASCII 0x34 ('4')
211 |        0b11111000,
212 |        0b11111000,
213 |        0b00011000,
214 |        0b00011000,
215 |        0b00011000,
216 |        0b01111110,
217 |        0b01111110,
218 |        0b00000000,
219 |     },
220 |     { // ASCII 0x35 ('5')
221 |        0b11110110,
222 |        0b11110110,
223 |        0b11010110,
224 |        0b11010110,
225 |        0b11010110,
226 |        0b11011110,
227 |        0b11011110,
228 |        0b00000000,
229 |     },
230 |     { // ASCII 0x36 ('6')
231 |        0b11111110,
232 |        0b11111110,
233 |        0b00110110,
234 |        0b00110110,
235 |        0b00110110,
236 |        0b00111110,
237 |        0b00111110,
238 |        0b00000000,
239 |     },
240 |     { // ASCII 0x37 ('7')
241 |        0b11000010,
242 |        0b11000110,
243 |        0b11001110,
244 |        0b11011100,
245 |        0b11111000,
246 |        0b11110000,
247 |        0b11100000,
248 |        0b00000000,
249 |     },
250 |     { // ASCII 0x38 ('8')
251 |        0b11111110,
252 |        0b11111110,
253 |        0b11010110,
254 |        0b11010110,
255 |        0b11010110,
256 |        0b11111110,
257 |        0b11111110,
258 |        0b00000000,
259 |     },
260 |     { // ASCII 0x39 ('9')
261 |        0b11111000,
262 |        0b11111000,
263 |        0b11011000,
264 |        0b11011000,
265 |        0b11011000,
266 |        0b11111110,
267 |        0b11111110,
268 |        0b00000000,
269 |     },
270 |     { // ASCII 0x3A (':')
271 |        0b00110110,
272 |        0b00110110,
273 |        0b00000000,
274 |        0b00000000,
275 |        0b00000000,
276 |        0b00000000,
277 |        0b00000000,
278 |        0b00000000,
279 |     },
280 |     { // ASCII 0x3B (';')
281 |        0b00110111,
282 |        0b00110111,
283 |        0b00000000,
284 |        0b00000000,
285 |        0b00000000,
286 |        0b00000000,
287 |        0b00000000,
288 |        0b00000000,
289 |     },
290 |     { // ASCII 0x3C ('<')
291 |        0b00010000,
292 |        0b00101000,
293 |        0b01000100,
294 |        0b01000100,
295 |        0b00000000,
296 |        0b00000000,
297 |        0b00000000,
298 |        0b00000000,
299 |     },
300 |     { // ASCII 0x3D ('=')
301 |        0b00101000,
302 |        0b00101000,
303 |        0b00101000,
304 |        0b00101000,
305 |        0b00101000,
306 |        0b00000000,
307 |        0b00000000,
308 |        0b00000000,
309 |     },
310 |     { // ASCII 0x3E ('>')
311 |        0b01000100,
312 |        0b01000100,
313 |        0b00101000,
314 |        0b00010000,
315 |        0b00000000,
316 |        0b00000000,
317 |        0b00000000,
318 |        0b00000000,
319 |     },
320 |     { // ASCII 0x3F ('?')
321 |        0b11000000,
322 |        0b11000000,
323 |        0b11011010,
324 |        0b11011010,
325 |        0b11010000,
326 |        0b11110000,
327 |        0b11110000,
328 |        0b00000000,
329 |     },
330 |     { // ASCII 0x40 ('@')
331 |        0b11111110,
332 |        0b11111110,
333 |        0b11000110,
334 |        0b11110110,
335 |        0b11010110,
336 |        0b11110110,
337 |        0b11110110,
338 |        0b00000000,
339 |     },
340 |     { // ASCII 0x41 ('A')
341 |        0b11111110,
342 |        0b11111110,
343 |        0b11011000,
344 |        0b11011000,
345 |        0b11011000,
346 |        0b11111110,
347 |        0b11111110,
348 |        0b00000000,
349 |     },
350 |     { // ASCII 0x42 ('B')
351 |        0b11111110,
352 |        0b11111110,
353 |        0b11010110,
354 |        0b11010110,
355 |        0b11110110,
356 |        0b01111110,
357 |        0b00111110,
358 |        0b00000000,
359 |     },
360 |     { // ASCII 0x43 ('C')
361 |        0b11111110,
362 |        0b11111110,
363 |        0b11000110,
364 |        0b11000110,
365 |        0b11000110,
366 |        0b11000110,
367 |        0b11000110,
368 |        0b00000000,
369 |     },
370 |     { // ASCII 0x44 ('D')
371 |        0b11111110,
372 |        0b11111110,
373 |        0b11000110,
374 |        0b11000110,
375 |        0b11100110,
376 |        0b01111110,
377 |        0b00111110,
378 |        0b00000000,
379 |     },
380 |     { // ASCII 0x45 ('E')
381 |        0b11111110,
382 |        0b11111110,
383 |        0b11010110,
384 |        0b11010110,
385 |        0b11010110,
386 |        0b11010110,
387 |        0b11010110,
388 |        0b00000000,
389 |     },
390 |     { // ASCII 0x46 ('F')
391 |        0b11111110,
392 |        0b11111110,
393 |        0b11010000,
394 |        0b11010000,
395 |        0b11010000,
396 |        0b11000000,
397 |        0b11000000,
398 |        0b00000000,
399 |     },
400 |     { // ASCII 0x47 ('G')
401 |        0b11111110,
402 |        0b11111110,
403 |        0b11000110,
404 |        0b11000110,
405 |        0b11010110,
406 |        0b11011110,
407 |        0b11011110,
408 |        0b00000000,
409 |     },
410 |     { // ASCII 0x48 ('H')
411 |        0b11111110,
412 |        0b11111110,
413 |        0b00011000,
414 |        0b00011000,
415 |        0b00011000,
416 |        0b11111110,
417 |        0b11111110,
418 |        0b00000000,
419 |     },
420 |     { // ASCII 0x49 ('I')
421 |        0b11000110,
422 |        0b11000110,
423 |        0b11111110,
424 |        0b11111110,
425 |        0b11000110,
426 |        0b11000110,
427 |        0b11000110,
428 |        0b00000000,
429 |     },
430 |     { // ASCII 0x4A ('J')
431 |        0b00000110,
432 |        0b00000110,
433 |        0b00000110,
434 |        0b00000110,
435 |        0b00000110,
436 |        0b11111110,
437 |        0b11111100,
438 |        0b00000000,
439 |     },
440 |     { // ASCII 0x4B ('K')
441 |        0b11111110,
442 |        0b11111110,
443 |        0b00011000,
444 |        0b00011000,
445 |        0b01111000,
446 |        0b11111110,
447 |        0b10011110,
448 |        0b00000000,
449 |     },
450 |     { // ASCII 0x4C ('L')
451 |        0b11111110,
452 |        0b11111110,
453 |        0b00000110,
454 |        0b00000110,
455 |        0b00000110,
456 |        0b00000110,
457 |        0b00000110,
458 |        0b00000000,
459 |     },
460 |     { // ASCII 0x4D ('M')
461 |        0b11111110,
462 |        0b11111110,
463 |        0b11000000,
464 |        0b01100000,
465 |        0b11000000,
466 |        0b11111110,
467 |        0b11111110,
468 |        0b00000000,
469 |     },
470 |     { // ASCII 0x4E ('N')
471 |        0b11111110,
472 |        0b11111110,
473 |        0b01110000,
474 |        0b00111000,
475 |        0b00011100,
476 |        0b11111110,
477 |        0b11111110,
478 |        0b00000000,
479 |     },
480 |     { // ASCII 0x4F ('O')
481 |        0b11111110,
482 |        0b11111110,
483 |        0b11000110,
484 |        0b11000110,
485 |        0b11000110,
486 |        0b11111110,
487 |        0b11111110,
488 |        0b00000000,
489 |     },
490 |     { // ASCII 0x50 ('P')
491 |        0b11111110,
492 |        0b11111110,
493 |        0b11011000,
494 |        0b11011000,
495 |        0b11011000,
496 |        0b11111000,
497 |        0b11111000,
498 |        0b00000000,
499 |     },
500 |     { // ASCII 0x51 ('Q')
501 |        0b11111110,
502 |        0b11111110,
503 |        0b11000110,
504 |        0b11001111,
505 |        0b11001111,
506 |        0b11111110,
507 |        0b11111110,
508 |        0b00000000,
509 |     },
510 |     { // ASCII 0x52 ('R')
511 |        0b11111110,
512 |        0b11111110,
513 |        0b11011000,
514 |        0b11011100,
515 |        0b11011110,
516 |        0b11111110,
517 |        0b11111010,
518 |        0b00000000,
519 |     },
520 |     { // ASCII 0x53 ('S')
521 |        0b11110110,
522 |        0b11110110,
523 |        0b11010110,
524 |        0b11010110,
525 |        0b11010110,
526 |        0b11011110,
527 |        0b11011110,
528 |        0b00000000,
529 |     },
530 |     { // ASCII 0x54 ('T')
531 |        0b11000000,
532 |        0b11000000,
533 |        0b11111110,
534 |        0b11111110,
535 |        0b11000000,
536 |        0b11000000,
537 |        0b11000000,
538 |        0b00000000,
539 |     },
540 |     { // ASCII 0x55 ('U')
541 |        0b11111110,
542 |        0b11111110,
543 |        0b00000110,
544 |        0b00000110,
545 |        0b00000110,
546 |        0b11111110,
547 |        0b11111110,
548 |        0b00000000,
549 |     },
550 |     { // ASCII 0x56 ('V')
551 |        0b11111000,
552 |        0b11111100,
553 |        0b00001110,
554 |        0b00000110,
555 |        0b00001110,
556 |        0b11111100,
557 |        0b11111000,
558 |        0b00000000,
559 |     },
560 |     { // ASCII 0x57 ('W')
561 |        0b11111100,
562 |        0b11111110,
563 |        0b00000110,
564 |        0b00001100,
565 |        0b00000110,
566 |        0b11111110,
567 |        0b11111100,
568 |        0b00000000,
569 |     },
570 |     { // ASCII 0x58 ('X')
571 |        0b11101110,
572 |        0b11111110,
573 |        0b00111000,
574 |        0b00010000,
575 |        0b00111000,
576 |        0b11111110,
577 |        0b11101110,
578 |        0b00000000,
579 |     },
580 |     { // ASCII 0x59 ('Y')
581 |        0b11100000,
582 |        0b11110000,
583 |        0b00111110,
584 |        0b00011110,
585 |        0b00111110,
586 |        0b11110000,
587 |        0b11100000,
588 |        0b00000000,
589 |     },
590 |     { // ASCII 0x5A ('Z')
591 |        0b11001110,
592 |        0b11011110,
593 |        0b11010110,
594 |        0b11010110,
595 |        0b11010110,
596 |        0b11110110,
597 |        0b11100110,
598 |        0b00000000,
599 |     },
600 |     { // ASCII 0x5B ('[')
601 |        0b11111111,
602 |        0b11111111,
603 |        0b00000001,
604 |        0b00000000,
605 |        0b00000000,
606 |        0b00000000,
607 |        0b00000000,
608 |        0b00000000,
609 |     },
610 |     { // ASCII 0x5C ('\')
611 |        0b11100000,
612 |        0b00111000,
613 |        0b00001110,
614 |        0b00000000,
615 |        0b00000000,
616 |        0b00000000,
617 |        0b00000000,
618 |        0b00000000,
619 |     },
620 |     { // ASCII 0x5D (']')
621 |        0b00000001,
622 |        0b11111111,
623 |        0b11111111,
624 |        0b00000000,
625 |        0b00000000,
626 |        0b00000000,
627 |        0b00000000,
628 |        0b00000000,
629 |     },
630 |     { // ASCII 0x5E ('^')
631 |        0b00000000,
632 |        0b11111110,
633 |        0b00000010,
634 |        0b11111110,
635 |        0b00000000,
636 |        0b00000000,
637 |        0b00000000,
638 |        0b00000000,
639 |     },
640 |     { // ASCII 0x5F ('_')
641 |        0b00000001,
642 |        0b00000001,
643 |        0b00000001,
644 |        0b00000001,
645 |        0b00000001,
646 |        0b00000001,
647 |        0b00000001,
648 |        0b00000000,
649 |     },
650 |     { // ASCII 0x60 ('`')
651 |        0b00000000,
652 |        0b11111110,
653 |        0b00000010,
654 |        0b11111110,
655 |        0b00000000,
656 |        0b00000000,
657 |        0b00000000,
658 |        0b00000000,
659 |     },
660 |     { // ASCII 0x61 ('a')
661 |        0b11111110,
662 |        0b11111110,
663 |        0b11011000,
664 |        0b11011000,
665 |        0b11011000,
666 |        0b11111110,
667 |        0b11111110,
668 |        0b00000000,
669 |     },
670 |     { // ASCII 0x62 ('b')
671 |        0b11111110,
672 |        0b11111110,
673 |        0b11010110,
674 |        0b11010110,
675 |        0b11110110,
676 |        0b01111110,
677 |        0b00111110,
678 |        0b00000000,
679 |     },
680 |     { // ASCII 0x63 ('c')
681 |        0b11111110,
682 |        0b11111110,
683 |        0b11000110,
684 |        0b11000110,
685 |        0b11000110,
686 |        0b11000110,
687 |        0b11000110,
688 |        0b00000000,
689 |     },
690 |     { // ASCII 0x64 ('d')
691 |        0b11111110,
692 |        0b11111110,
693 |        0b11000110,
694 |        0b11000110,
695 |        0b11100110,
696 |        0b01111110,
697 |        0b00111110,
698 |        0b00000000,
699 |     },
700 |     { // ASCII 0x65 ('e')
701 |        0b11111110,
702 |        0b11111110,
703 |        0b11010110,
704 |        0b11010110,
705 |        0b11010110,
706 |        0b11010110,
707 |        0b11010110,
708 |        0b00000000,
709 |     },
710 |     { // ASCII 0x66 ('f')
711 |        0b11111110,
712 |        0b11111110,
713 |        0b11010000,
714 |        0b11010000,
715 |        0b11010000,
716 |        0b11000000,
717 |        0b11000000,
718 |        0b00000000,
719 |     },
720 |     { // ASCII 0x67 ('g')
721 |        0b11111110,
722 |        0b11111110,
723 |        0b11000110,
724 |        0b11000110,
725 |        0b11010110,
726 |        0b11011110,
727 |        0b11011110,
728 |        0b00000000,
729 |     },
730 |     { // ASCII 0x68 ('h')
731 |        0b11111110,
732 |        0b11111110,
733 |        0b00011000,
734 |        0b00011000,
735 |        0b00011000,
736 |        0b11111110,
737 |        0b11111110,
738 |        0b00000000,
739 |     },
740 |     { // ASCII 0x69 ('i')
741 |        0b11000110,
742 |        0b11000110,
743 |        0b11111110,
744 |        0b11111110,
745 |        0b11000110,
746 |        0b11000110,
747 |        0b11000110,
748 |        0b00000000,
749 |     },
750 |     { // ASCII 0x6A ('j')
751 |        0b00000110,
752 |        0b00000110,
753 |        0b00000110,
754 |        0b00000110,
755 |        0b00000110,
756 |        0b11111110,
757 |        0b11111100,
758 |        0b00000000,
759 |     },
760 |     { // ASCII 0x6B ('k')
761 |        0b11111110,
762 |        0b11111110,
763 |        0b00011000,
764 |        0b00011000,
765 |        0b01111000,
766 |        0b11111110,
767 |        0b10011110,
768 |        0b00000000,
769 |     },
770 |     { // ASCII 0x6C ('l')
771 |        0b11111110,
772 |        0b11111110,
773 |        0b00000110,
774 |        0b00000110,
775 |        0b00000110,
776 |        0b00000110,
777 |        0b00000110,
778 |        0b00000000,
779 |     },
780 |     { // ASCII 0x6D ('m')
781 |        0b11111110,
782 |        0b11111110,
783 |        0b11000000,
784 |        0b01100000,
785 |        0b11000000,
786 |        0b11111110,
787 |        0b11111110,
788 |        0b00000000,
789 |     },
790 |     { // ASCII 0x6E ('n')
791 |        0b11111110,
792 |        0b11111110,
793 |        0b01110000,
794 |        0b00111000,
795 |        0b00011100,
796 |        0b11111110,
797 |        0b11111110,
798 |        0b00000000,
799 |     },
800 |     { // ASCII 0x6F ('o')
801 |        0b11111110,
802 |        0b11111110,
803 |        0b11000110,
804 |        0b11000110,
805 |        0b11000110,
806 |        0b11111110,
807 |        0b11111110,
808 |        0b00000000,
809 |     },
810 |     { // ASCII 0x70 ('p')
811 |        0b11111110,
812 |        0b11111110,
813 |        0b11011000,
814 |        0b11011000,
815 |        0b11011000,
816 |        0b11111000,
817 |        0b11111000,
818 |        0b00000000,
819 |     },
820 |     { // ASCII 0x71 ('q')
821 |        0b11111110,
822 |        0b11111110,
823 |        0b11000110,
824 |        0b11001111,
825 |        0b11001111,
826 |        0b11111110,
827 |        0b11111110,
828 |        0b00000000,
829 |     },
830 |     { // ASCII 0x72 ('r')
831 |        0b11111110,
832 |        0b11111110,
833 |        0b11011000,
834 |        0b11011100,
835 |        0b11011110,
836 |        0b11111110,
837 |        0b11111010,
838 |        0b00000000,
839 |     },
840 |     { // ASCII 0x73 ('s')
841 |        0b11110110,
842 |        0b11110110,
843 |        0b11010110,
844 |        0b11010110,
845 |        0b11010110,
846 |        0b11011110,
847 |        0b11011110,
848 |        0b00000000,
849 |     },
850 |     { // ASCII 0x74 ('t')
851 |        0b11000000,
852 |        0b11000000,
853 |        0b11111110,
854 |        0b11111110,
855 |        0b11000000,
856 |        0b11000000,
857 |        0b11000000,
858 |        0b00000000,
859 |     },
860 |     { // ASCII 0x75 ('u')
861 |        0b11111110,
862 |        0b11111110,
863 |        0b00000110,
864 |        0b00000110,
865 |        0b00000110,
866 |        0b11111110,
867 |        0b11111110,
868 |        0b00000000,
869 |     },
870 |     { // ASCII 0x76 ('v')
871 |        0b11111000,
872 |        0b11111100,
873 |        0b00001110,
874 |        0b00000110,
875 |        0b00001110,
876 |        0b11111100,
877 |        0b11111000,
878 |        0b00000000,
879 |     },
880 |     { // ASCII 0x77 ('w')
881 |        0b11111100,
882 |        0b11111110,
883 |        0b00000110,
884 |        0b00001100,
885 |        0b00000110,
886 |        0b11111110,
887 |        0b11111100,
888 |        0b00000000,
889 |     },
890 |     { // ASCII 0x78 ('x')
891 |        0b11101110,
892 |        0b11111110,
893 |        0b00111000,
894 |        0b00010000,
895 |        0b00111000,
896 |        0b11111110,
897 |        0b11101110,
898 |        0b00000000,
899 |     },
900 |     { // ASCII 0x79 ('y')
901 |        0b11100000,
902 |        0b11110000,
903 |        0b00111110,
904 |        0b00011110,
905 |        0b00111110,
906 |        0b11110000,
907 |        0b11100000,
908 |        0b00000000,
909 |     },
910 |     { // ASCII 0x7A ('z')
911 |        0b11001110,
912 |        0b11011110,
913 |        0b11010110,
914 |        0b11010110,
915 |        0b11010110,
916 |        0b11110110,
917 |        0b11100110,
918 |        0b00000000,
919 |     },
920 |     { // ASCII 0x7B ('{')
921 |        0b00111000,
922 |        0b11111111,
923 |        0b11111111,
924 |        0b00000001,
925 |        0b00000000,
926 |        0b00000000,
927 |        0b00000000,
928 |        0b00000000,
929 |     },
930 |     { // ASCII 0x7C ('|')
931 |        0b11111110,
932 |        0b00000000,
933 |        0b00000000,
934 |        0b00000000,
935 |        0b00000000,
936 |        0b00000000,
937 |        0b00000000,
938 |        0b00000000,
939 |     },
940 |     { // ASCII 0x7D ('}')
941 |        0b00000001,
942 |        0b11111111,
943 |        0b11111111,
944 |        0b00111000,
945 |        0b00000000,
946 |        0b00000000,
947 |        0b00000000,
948 |        0b00000000,
949 |     },
950 |     { // ASCII 0x7E ('~')
951 |        0b00000000,
952 |        0b11111110,
953 |        0b00000010,
954 |        0b11111110,
955 |        0b00000000,
956 |        0b00000000,
957 |        0b00000000,
958 |        0b00000000,
959 |     },
960 |     { // ASCII 0x7F       0b00000000,
961 |        0b00000000,
962 |        0b00000000,
963 |        0b00000000,
964 |        0b00000000,
965 |        0b00000000,
966 |        0b00000000,
967 |        0b00000000,
968 |     },
969 | };
970 | /*------------------- FONT CUT BOTTOM HERE -------------------------------*/


--------------------------------------------------------------------------------
/Arduino/bmspa font.txt:
--------------------------------------------------------------------------------
  1 | /*------------------- FONT CUT TOP HERE -------------------------------*/
  2 | // A wide, curvy font that looks a bit like Start Trek. From here..
  3 | // https://jared.geek.nz/2014/jan/custom-fonts-for-microcontrollers
  4 | 
  5 | #define ASCII_OFFSET (0x20)     // ASCII code of 1st char in font array
  6 | #define ASCII_NONPRINT (0x80)   // ASCII code of char to show for chars not included in the font (could also be a space)
  7 | #define FONT_WIDTH 9
  8 | const byte fontdata[][FONT_WIDTH] PROGMEM = {
  9 |     { // ASCII 0x20 (' ')
 10 |        0b00000000,
 11 |        0b00000000,
 12 |        0b00000000,
 13 |        0b00000000,
 14 |        0b00000000,
 15 |        0b00000000,
 16 |        0b00000000,
 17 |        0b00000000,
 18 |     },
 19 |     { // ASCII 0x21 ('!')
 20 |        0b00000000,
 21 |        0b11111010,
 22 |        0b00000000,
 23 |        0b00000000,
 24 |        0b00000000,
 25 |        0b00000000,
 26 |        0b00000000,
 27 |        0b00000000,
 28 |     },
 29 |     { // ASCII 0x22 ('"')
 30 |        0b00000000,
 31 |        0b11000000,
 32 |        0b00000000,
 33 |        0b11000000,
 34 |        0b00000000,
 35 |        0b00000000,
 36 |        0b00000000,
 37 |        0b00000000,
 38 |     },
 39 |     { // ASCII 0x23 ('#')
 40 |        0b01010000,
 41 |        0b11111000,
 42 |        0b01010000,
 43 |        0b11111000,
 44 |        0b01010000,
 45 |        0b00000000,
 46 |        0b00000000,
 47 |        0b00000000,
 48 |     },
 49 |     { // ASCII 0x24 ('$')
 50 |        0b00100100,
 51 |        0b01010100,
 52 |        0b01010100,
 53 |        0b11111110,
 54 |        0b01010100,
 55 |        0b01010100,
 56 |        0b01001000,
 57 |        0b00000000,
 58 |     },
 59 |     { // ASCII 0x25 ('%')
 60 |        0b00000000,
 61 |        0b11100010,
 62 |        0b10100100,
 63 |        0b11101000,
 64 |        0b00010000,
 65 |        0b00101110,
 66 |        0b01001010,
 67 |        0b10001110,
 68 |     },
 69 |     { // ASCII 0x26 ('&')
 70 |        0b00000000,
 71 |        0b01101100,
 72 |        0b10010010,
 73 |        0b10010010,
 74 |        0b10010010,
 75 |        0b10000010,
 76 |        0b10000010,
 77 |        0b00011100,
 78 |     },
 79 |     { // ASCII 0x27 (''')
 80 |        0b00000000,
 81 |        0b11000000,
 82 |        0b00000000,
 83 |        0b00000000,
 84 |        0b00000000,
 85 |        0b00000000,
 86 |        0b00000000,
 87 |        0b00000000,
 88 |     },
 89 |     { // ASCII 0x28 ('(')
 90 |        0b00000000,
 91 |        0b01111100,
 92 |        0b10000010,
 93 |        0b00000000,
 94 |        0b00000000,
 95 |        0b00000000,
 96 |        0b00000000,
 97 |        0b00000000,
 98 |     },
 99 |     { // ASCII 0x29 (')')
100 |        0b10000010,
101 |        0b01111100,
102 |        0b00000000,
103 |        0b00000000,
104 |        0b00000000,
105 |        0b00000000,
106 |        0b00000000,
107 |        0b00000000,
108 |     },
109 |     { // ASCII 0x2A ('*')
110 |        0b00100000,
111 |        0b10101000,
112 |        0b01110000,
113 |        0b10101000,
114 |        0b00100000,
115 |        0b00000000,
116 |        0b00000000,
117 |        0b00000000,
118 |     },
119 |     { // ASCII 0x2B ('+')
120 |        0b00010000,
121 |        0b00010000,
122 |        0b01111100,
123 |        0b00010000,
124 |        0b00010000,
125 |        0b00000000,
126 |        0b00000000,
127 |        0b00000000,
128 |     },
129 |     { // ASCII 0x2C (',')
130 |        0b00000000,
131 |        0b00000011,
132 |        0b00000000,
133 |        0b00000000,
134 |        0b00000000,
135 |        0b00000000,
136 |        0b00000000,
137 |        0b00000000,
138 |     },
139 |     { // ASCII 0x2D ('-')
140 |        0b00010000,
141 |        0b00010000,
142 |        0b00010000,
143 |        0b00010000,
144 |        0b00010000,
145 |        0b00000000,
146 |        0b00000000,
147 |        0b00000000,
148 |     },
149 |     { // ASCII 0x2E ('.')
150 |        0b00000010,
151 |        0b00000000,
152 |        0b00000000,
153 |        0b00000000,
154 |        0b00000000,
155 |        0b00000000,
156 |        0b00000000,
157 |        0b00000000,
158 |     },
159 |     { // ASCII 0x2F ('/')
160 |        0b00000010,
161 |        0b00000100,
162 |        0b00001000,
163 |        0b00010000,
164 |        0b00100000,
165 |        0b01000000,
166 |        0b10000000,
167 |        0b00000000,
168 |     },
169 |     { // ASCII 0x30 ('0')
170 |        0b00000000,
171 |        0b01111100,
172 |        0b10000110,
173 |        0b10001010,
174 |        0b10010010,
175 |        0b10100010,
176 |        0b11000010,
177 |        0b01111100,
178 |     },
179 |     { // ASCII 0x31 ('1')
180 |        0b10000000,
181 |        0b10000000,
182 |        0b01111110,
183 |        0b00000000,
184 |        0b00000000,
185 |        0b00000000,
186 |        0b00000000,
187 |        0b00000000,
188 |     },
189 |     { // ASCII 0x32 ('2')
190 |        0b00000000,
191 |        0b10001110,
192 |        0b10010010,
193 |        0b10010010,
194 |        0b10010010,
195 |        0b10010010,
196 |        0b10010010,
197 |        0b01100010,
198 |     },
199 |     { // ASCII 0x33 ('3')
200 |        0b10000010,
201 |        0b10010010,
202 |        0b10010010,
203 |        0b10010010,
204 |        0b10010010,
205 |        0b10010010,
206 |        0b01101100,
207 |        0b00000000,
208 |     },
209 |     { // ASCII 0x34 ('4')
210 |        0b00000000,
211 |        0b11110000,
212 |        0b00001000,
213 |        0b00001000,
214 |        0b00001000,
215 |        0b00001000,
216 |        0b00001000,
217 |        0b11111110,
218 |     },
219 |     { // ASCII 0x35 ('5')
220 |        0b00000000,
221 |        0b11110010,
222 |        0b10010010,
223 |        0b10010010,
224 |        0b10010010,
225 |        0b10010010,
226 |        0b10010010,
227 |        0b10001100,
228 |     },
229 |     { // ASCII 0x36 ('6')
230 |        0b00000000,
231 |        0b01111100,
232 |        0b10010010,
233 |        0b10010010,
234 |        0b10010010,
235 |        0b10010010,
236 |        0b10010010,
237 |        0b00001100,
238 |     },
239 |     { // ASCII 0x37 ('7')
240 |        0b10000000,
241 |        0b10000000,
242 |        0b10000000,
243 |        0b10000000,
244 |        0b10000000,
245 |        0b10000000,
246 |        0b01111110,
247 |        0b00000000,
248 |     },
249 |     { // ASCII 0x38 ('8')
250 |        0b00000000,
251 |        0b01101100,
252 |        0b10010010,
253 |        0b10010010,
254 |        0b10010010,
255 |        0b10010010,
256 |        0b10010010,
257 |        0b01101100,
258 |     },
259 |     { // ASCII 0x39 ('9')
260 |        0b00000000,
261 |        0b01100000,
262 |        0b10010010,
263 |        0b10010010,
264 |        0b10010010,
265 |        0b10010010,
266 |        0b10010010,
267 |        0b01111100,
268 |     },
269 |     { // ASCII 0x3A (':')
270 |        0b00101000,
271 |        0b00000000,
272 |        0b00000000,
273 |        0b00000000,
274 |        0b00000000,
275 |        0b00000000,
276 |        0b00000000,
277 |        0b00000000,
278 |     },
279 |     { // ASCII 0x3B (';')
280 |        0b00000010,
281 |        0b00101100,
282 |        0b00000000,
283 |        0b00000000,
284 |        0b00000000,
285 |        0b00000000,
286 |        0b00000000,
287 |        0b00000000,
288 |     },
289 |     { // ASCII 0x3C ('<')
290 |        0b00010000,
291 |        0b00101000,
292 |        0b01000100,
293 |        0b00000000,
294 |        0b00000000,
295 |        0b00000000,
296 |        0b00000000,
297 |        0b00000000,
298 |     },
299 |     { // ASCII 0x3D ('=')
300 |        0b00101000,
301 |        0b00101000,
302 |        0b00101000,
303 |        0b00101000,
304 |        0b00101000,
305 |        0b00000000,
306 |        0b00000000,
307 |        0b00000000,
308 |     },
309 |     { // ASCII 0x3E ('>')
310 |        0b01000100,
311 |        0b00101000,
312 |        0b00010000,
313 |        0b00000000,
314 |        0b00000000,
315 |        0b00000000,
316 |        0b00000000,
317 |        0b00000000,
318 |     },
319 |     { // ASCII 0x3F ('?')
320 |        0b00000000,
321 |        0b01100000,
322 |        0b10000000,
323 |        0b10000000,
324 |        0b10011010,
325 |        0b10010000,
326 |        0b10010000,
327 |        0b01100000,
328 |     },
329 |     { // ASCII 0x40 ('@')
330 |        0b00000000,
331 |        0b01111100,
332 |        0b10000010,
333 |        0b10111010,
334 |        0b10101010,
335 |        0b10111010,
336 |        0b10001010,
337 |        0b01111010,
338 |     },
339 |     { // ASCII 0x41 ('A')
340 |        0b00000000,
341 |        0b01111110,
342 |        0b10000000,
343 |        0b10010000,
344 |        0b10010000,
345 |        0b10010000,
346 |        0b10010000,
347 |        0b01111110,
348 |     },
349 |     { // ASCII 0x42 ('B')
350 |        0b00000000,
351 |        0b11111110,
352 |        0b10000010,
353 |        0b10010010,
354 |        0b10010010,
355 |        0b10010010,
356 |        0b10010010,
357 |        0b01101100,
358 |     },
359 |     { // ASCII 0x43 ('C')
360 |        0b00000000,
361 |        0b01111100,
362 |        0b10000010,
363 |        0b10000010,
364 |        0b10000010,
365 |        0b10000010,
366 |        0b10000010,
367 |        0b01000100,
368 |     },
369 |     { // ASCII 0x44 ('D')
370 |        0b00000000,
371 |        0b11111110,
372 |        0b10000010,
373 |        0b10000010,
374 |        0b10000010,
375 |        0b10000010,
376 |        0b10000010,
377 |        0b01111100,
378 |     },
379 |     { // ASCII 0x45 ('E')
380 |        0b00000000,
381 |        0b01111100,
382 |        0b10010010,
383 |        0b10010010,
384 |        0b10010010,
385 |        0b10010010,
386 |        0b10010010,
387 |        0b10000010,
388 |     },
389 |     { // ASCII 0x46 ('F')
390 |        0b00000000,
391 |        0b01111110,
392 |        0b10010000,
393 |        0b10010000,
394 |        0b10010000,
395 |        0b10010000,
396 |        0b10010000,
397 |        0b10000000,
398 |     },
399 |     { // ASCII 0x47 ('G')
400 |        0b00000000,
401 |        0b01111100,
402 |        0b10000010,
403 |        0b10010010,
404 |        0b10010010,
405 |        0b10010010,
406 |        0b10010010,
407 |        0b10011110,
408 |     },
409 |     { // ASCII 0x48 ('H')
410 |        0b00000000,
411 |        0b11111110,
412 |        0b00010000,
413 |        0b00010000,
414 |        0b00010000,
415 |        0b00010000,
416 |        0b00010000,
417 |        0b11111110,
418 |     },
419 |     { // ASCII 0x49 ('I')
420 |        0b00000000,
421 |        0b11111110,
422 |        0b00000000,
423 |        0b00000000,
424 |        0b00000000,
425 |        0b00000000,
426 |        0b00000000,
427 |        0b00000000,
428 |     },
429 |     { // ASCII 0x4A ('J')
430 |        0b00000000,
431 |        0b00011100,
432 |        0b00000010,
433 |        0b00000010,
434 |        0b10000010,
435 |        0b10000010,
436 |        0b10000010,
437 |        0b11111100,
438 |     },
439 |     { // ASCII 0x4B ('K')
440 |        0b00000000,
441 |        0b11111110,
442 |        0b00010000,
443 |        0b00010000,
444 |        0b00010000,
445 |        0b00110000,
446 |        0b01010000,
447 |        0b10001110,
448 |     },
449 |     { // ASCII 0x4C ('L')
450 |        0b00000000,
451 |        0b11111100,
452 |        0b00000010,
453 |        0b00000010,
454 |        0b00000010,
455 |        0b00000010,
456 |        0b00000010,
457 |        0b00000010,
458 |     },
459 |     { // ASCII 0x4D ('M')
460 |        0b00000000,
461 |        0b01111110,
462 |        0b10000000,
463 |        0b10000000,
464 |        0b01111110,
465 |        0b10000000,
466 |        0b10000000,
467 |        0b01111110,
468 |     },
469 |     { // ASCII 0x4E ('N')
470 |        0b00000000,
471 |        0b01111110,
472 |        0b10000000,
473 |        0b10000000,
474 |        0b01111100,
475 |        0b00000010,
476 |        0b00000010,
477 |        0b11111100,
478 |     },
479 |     { // ASCII 0x4F ('O')
480 |        0b00000000,
481 |        0b01111100,
482 |        0b10000010,
483 |        0b10000010,
484 |        0b10000010,
485 |        0b10000010,
486 |        0b10000010,
487 |        0b01111100,
488 |     },
489 |     { // ASCII 0x50 ('P')
490 |        0b00000000,
491 |        0b01111110,
492 |        0b10010000,
493 |        0b10010000,
494 |        0b10010000,
495 |        0b10010000,
496 |        0b10010000,
497 |        0b01100000,
498 |     },
499 |     { // ASCII 0x51 ('Q')
500 |        0b00000000,
501 |        0b01111100,
502 |        0b10000010,
503 |        0b10000010,
504 |        0b10001110,
505 |        0b10001010,
506 |        0b10001010,
507 |        0b01111110,
508 |     },
509 |     { // ASCII 0x52 ('R')
510 |        0b00000000,
511 |        0b01111110,
512 |        0b10000000,
513 |        0b10001100,
514 |        0b10010010,
515 |        0b10010010,
516 |        0b10010010,
517 |        0b01100010,
518 |     },
519 |     { // ASCII 0x53 ('S')
520 |        0b00000000,
521 |        0b01100010,
522 |        0b10010010,
523 |        0b10010010,
524 |        0b10010010,
525 |        0b10010010,
526 |        0b10010010,
527 |        0b10001100,
528 |     },
529 |     { // ASCII 0x54 ('T')
530 |        0b10000000,
531 |        0b10000000,
532 |        0b10000000,
533 |        0b11111110,
534 |        0b10000000,
535 |        0b10000000,
536 |        0b10000000,
537 |        0b00000000,
538 |     },
539 |     { // ASCII 0x55 ('U')
540 |        0b00000000,
541 |        0b11111100,
542 |        0b00000010,
543 |        0b00000010,
544 |        0b00000010,
545 |        0b00000010,
546 |        0b00000010,
547 |        0b11111100,
548 |     },
549 |     { // ASCII 0x56 ('V')
550 |        0b00000000,
551 |        0b11110000,
552 |        0b00001000,
553 |        0b00000100,
554 |        0b00000010,
555 |        0b00000100,
556 |        0b00001000,
557 |        0b11110000,
558 |     },
559 |     { // ASCII 0x57 ('W')
560 |        0b00000000,
561 |        0b11111100,
562 |        0b00000010,
563 |        0b00000010,
564 |        0b11111100,
565 |        0b00000010,
566 |        0b00000010,
567 |        0b11111100,
568 |     },
569 |     { // ASCII 0x58 ('X')
570 |        0b00000000,
571 |        0b11000110,
572 |        0b00101000,
573 |        0b00010000,
574 |        0b00010000,
575 |        0b00010000,
576 |        0b00101000,
577 |        0b11000110,
578 |     },
579 |     { // ASCII 0x59 ('Y')
580 |        0b00000000,
581 |        0b11100000,
582 |        0b00010000,
583 |        0b00010000,
584 |        0b00011110,
585 |        0b00010000,
586 |        0b00010000,
587 |        0b11100000,
588 |     },
589 |     { // ASCII 0x5A ('Z')
590 |        0b00000000,
591 |        0b10001110,
592 |        0b10010010,
593 |        0b10010010,
594 |        0b10010010,
595 |        0b10010010,
596 |        0b10010010,
597 |        0b11100010,
598 |     },
599 |     { // ASCII 0x5B ('[')
600 |        0b00000000,
601 |        0b11111110,
602 |        0b10000010,
603 |        0b00000000,
604 |        0b00000000,
605 |        0b00000000,
606 |        0b00000000,
607 |        0b00000000,
608 |     },
609 |     { // ASCII 0x5C ('\')
610 |        0b00000000,
611 |        0b00000000,
612 |        0b00000000,
613 |        0b00000000,
614 |        0b00000000,
615 |        0b00000000,
616 |        0b00000000,
617 |        0b00000000,
618 |     },
619 |     { // ASCII 0x5D (']')
620 |        0b10000010,
621 |        0b11111110,
622 |        0b00000000,
623 |        0b00000000,
624 |        0b00000000,
625 |        0b00000000,
626 |        0b00000000,
627 |        0b00000000,
628 |     },
629 |     { // ASCII 0x5E ('^')
630 |        0b00000000,
631 |        0b00000000,
632 |        0b00000000,
633 |        0b00000000,
634 |        0b00000000,
635 |        0b00000000,
636 |        0b00000000,
637 |        0b00000000,
638 |     },
639 |     { // ASCII 0x5F ('_')
640 |        0b00000010,
641 |        0b00000010,
642 |        0b00000010,
643 |        0b00000010,
644 |        0b00000010,
645 |        0b00000010,
646 |        0b00000010,
647 |        0b00000000,
648 |     },
649 |     { // ASCII 0x60 ('`')
650 |        0b00000000,
651 |        0b00000000,
652 |        0b00000000,
653 |        0b00000000,
654 |        0b00000000,
655 |        0b00000000,
656 |        0b00000000,
657 |        0b00000000,
658 |     },
659 |     { // ASCII 0x61 ('a')
660 |        0b00000000,
661 |        0b01111110,
662 |        0b10000000,
663 |        0b10010000,
664 |        0b10010000,
665 |        0b10010000,
666 |        0b10010000,
667 |        0b01111110,
668 |     },
669 |     { // ASCII 0x62 ('b')
670 |        0b00000000,
671 |        0b11111110,
672 |        0b10000010,
673 |        0b10010010,
674 |        0b10010010,
675 |        0b10010010,
676 |        0b10010010,
677 |        0b01101100,
678 |     },
679 |     { // ASCII 0x63 ('c')
680 |        0b00000000,
681 |        0b01111100,
682 |        0b10000010,
683 |        0b10000010,
684 |        0b10000010,
685 |        0b10000010,
686 |        0b10000010,
687 |        0b01000100,
688 |     },
689 |     { // ASCII 0x64 ('d')
690 |        0b00000000,
691 |        0b11111110,
692 |        0b10000010,
693 |        0b10000010,
694 |        0b10000010,
695 |        0b10000010,
696 |        0b10000010,
697 |        0b01111100,
698 |     },
699 |     { // ASCII 0x65 ('e')
700 |        0b00000000,
701 |        0b01111100,
702 |        0b10010010,
703 |        0b10010010,
704 |        0b10010010,
705 |        0b10010010,
706 |        0b10010010,
707 |        0b10000010,
708 |     },
709 |     { // ASCII 0x66 ('f')
710 |        0b00000000,
711 |        0b01111110,
712 |        0b10010000,
713 |        0b10010000,
714 |        0b10010000,
715 |        0b10010000,
716 |        0b10010000,
717 |        0b10000000,
718 |     },
719 |     { // ASCII 0x67 ('g')
720 |        0b00000000,
721 |        0b01111100,
722 |        0b10000010,
723 |        0b10010010,
724 |        0b10010010,
725 |        0b10010010,
726 |        0b10010010,
727 |        0b10011110,
728 |     },
729 |     { // ASCII 0x68 ('h')
730 |        0b00000000,
731 |        0b11111110,
732 |        0b00010000,
733 |        0b00010000,
734 |        0b00010000,
735 |        0b00010000,
736 |        0b00010000,
737 |        0b11111110,
738 |     },
739 |     { // ASCII 0x69 ('i')
740 |        0b00000000,
741 |        0b11111110,
742 |        0b00000000,
743 |        0b00000000,
744 |        0b00000000,
745 |        0b00000000,
746 |        0b00000000,
747 |        0b00000000,
748 |     },
749 |     { // ASCII 0x6A ('j')
750 |        0b00000000,
751 |        0b00011100,
752 |        0b00000010,
753 |        0b00000010,
754 |        0b10000010,
755 |        0b10000010,
756 |        0b10000010,
757 |        0b11111100,
758 |     },
759 |     { // ASCII 0x6B ('k')
760 |        0b00000000,
761 |        0b11111110,
762 |        0b00010000,
763 |        0b00010000,
764 |        0b00010000,
765 |        0b00110000,
766 |        0b01010000,
767 |        0b10001110,
768 |     },
769 |     { // ASCII 0x6C ('l')
770 |        0b00000000,
771 |        0b11111100,
772 |        0b00000010,
773 |        0b00000010,
774 |        0b00000010,
775 |        0b00000010,
776 |        0b00000010,
777 |        0b00000010,
778 |     },
779 |     { // ASCII 0x6D ('m')
780 |        0b00000000,
781 |        0b01111110,
782 |        0b10000000,
783 |        0b10000000,
784 |        0b01111110,
785 |        0b10000000,
786 |        0b10000000,
787 |        0b01111110,
788 |     },
789 |     { // ASCII 0x6E ('n')
790 |        0b00000000,
791 |        0b01111110,
792 |        0b10000000,
793 |        0b10000000,
794 |        0b01111100,
795 |        0b00000010,
796 |        0b00000010,
797 |        0b11111100,
798 |     },
799 |     { // ASCII 0x6F ('o')
800 |        0b00000000,
801 |        0b01111100,
802 |        0b10000010,
803 |        0b10000010,
804 |        0b10000010,
805 |        0b10000010,
806 |        0b10000010,
807 |        0b01111100,
808 |     },
809 |     { // ASCII 0x70 ('p')
810 |        0b00000000,
811 |        0b01111110,
812 |        0b10010000,
813 |        0b10010000,
814 |        0b10010000,
815 |        0b10010000,
816 |        0b10010000,
817 |        0b01100000,
818 |     },
819 |     { // ASCII 0x71 ('q')
820 |        0b00000000,
821 |        0b01111100,
822 |        0b10000010,
823 |        0b10000010,
824 |        0b10001110,
825 |        0b10001010,
826 |        0b10001010,
827 |        0b01111110,
828 |     },
829 |     { // ASCII 0x72 ('r')
830 |        0b00000000,
831 |        0b01111110,
832 |        0b10000000,
833 |        0b10001100,
834 |        0b10010010,
835 |        0b10010010,
836 |        0b10010010,
837 |        0b01100010,
838 |     },
839 |     { // ASCII 0x73 ('s')
840 |        0b00000000,
841 |        0b01100010,
842 |        0b10010010,
843 |        0b10010010,
844 |        0b10010010,
845 |        0b10010010,
846 |        0b10010010,
847 |        0b10001100,
848 |     },
849 |     { // ASCII 0x74 ('t')
850 |        0b10000000,
851 |        0b10000000,
852 |        0b10000000,
853 |        0b11111110,
854 |        0b10000000,
855 |        0b10000000,
856 |        0b10000000,
857 |        0b00000000,
858 |     },
859 |     { // ASCII 0x75 ('u')
860 |        0b00000000,
861 |        0b11111100,
862 |        0b00000010,
863 |        0b00000010,
864 |        0b00000010,
865 |        0b00000010,
866 |        0b00000010,
867 |        0b11111100,
868 |     },
869 |     { // ASCII 0x76 ('v')
870 |        0b00000000,
871 |        0b11110000,
872 |        0b00001000,
873 |        0b00000100,
874 |        0b00000010,
875 |        0b00000100,
876 |        0b00001000,
877 |        0b11110000,
878 |     },
879 |     { // ASCII 0x77 ('w')
880 |        0b00000000,
881 |        0b11111100,
882 |        0b00000010,
883 |        0b00000010,
884 |        0b11111100,
885 |        0b00000010,
886 |        0b00000010,
887 |        0b11111100,
888 |     },
889 |     { // ASCII 0x78 ('x')
890 |        0b00000000,
891 |        0b11000110,
892 |        0b00101000,
893 |        0b00010000,
894 |        0b00010000,
895 |        0b00010000,
896 |        0b00101000,
897 |        0b11000110,
898 |     },
899 |     { // ASCII 0x79 ('y')
900 |        0b00000000,
901 |        0b11100000,
902 |        0b00010000,
903 |        0b00010000,
904 |        0b00011110,
905 |        0b00010000,
906 |        0b00010000,
907 |        0b11100000,
908 |     },
909 |     { // ASCII 0x7A ('z')
910 |        0b00000000,
911 |        0b10001110,
912 |        0b10010010,
913 |        0b10010010,
914 |        0b10010010,
915 |        0b10010010,
916 |        0b10010010,
917 |        0b11100010,
918 |     },
919 |     { // ASCII 0x7B ('{')
920 |        0b00010000,
921 |        0b01101100,
922 |        0b10000010,
923 |        0b00000000,
924 |        0b00000000,
925 |        0b00000000,
926 |        0b00000000,
927 |        0b00000000,
928 |     },
929 |     { // ASCII 0x7C ('|')
930 |        0b00000000,
931 |        0b00000000,
932 |        0b00000000,
933 |        0b00000000,
934 |        0b00000000,
935 |        0b00000000,
936 |        0b00000000,
937 |        0b00000000,
938 |     },
939 |     { // ASCII 0x7D ('}')
940 |        0b10000010,
941 |        0b01101100,
942 |        0b00010000,
943 |        0b00000000,
944 |        0b00000000,
945 |        0b00000000,
946 |        0b00000000,
947 |        0b00000000,
948 |     },
949 |     { // ASCII 0x7E ('~')
950 |        0b01000000,
951 |        0b10000000,
952 |        0b10000000,
953 |        0b01000000,
954 |        0b01000000,
955 |        0b10000000,
956 |        0b00000000,
957 |        0b00000000,
958 |     },
959 |     { // ASCII 0x7F       0b00000000,
960 |        0b00000000,
961 |        0b00000000,
962 |        0b00000000,
963 |        0b00000000,
964 |        0b00000000,
965 |        0b00000000,
966 |        0b00000000,
967 |     },
968 | };
969 | /*------------------- FONT CUT BOTTOM HERE -------------------------------*/


--------------------------------------------------------------------------------
/Arduino/MacroMarquee/MacroMarquee.ino:
--------------------------------------------------------------------------------
  1 | // Change this to be at least as long as your pixel string (too long will work fine, just be a little slower)
  2 | 
  3 | #define PIXELS 96*4  // Number of pixels in the string. I am using 4 meters of 96LED/M
  4 | 
  5 | // These values depend on which pins your 8 strings are connected to and what board you are using 
  6 | // More info on how to find these at http://www.arduino.cc/en/Reference/PortManipulation
  7 | 
  8 | // PORTD controls Digital Pins 0-7 on the Uno
  9 | 
 10 | // You'll need to look up the port/bit combination for other boards. 
 11 | 
 12 | // Note that you could also include the DigitalWriteFast header file to not need to to this lookup.
 13 | 
 14 | #define PIXEL_PORT  PORTD  // Port of the pin the pixels are connected to
 15 | #define PIXEL_DDR   DDRD   // Port of the pin the pixels are connected to
 16 | 
 17 | 
 18 | static const uint8_t onBits=0b11111110;   // Bit pattern to write to port to turn on all pins connected to LED strips. 
 19 |                                           // If you do not want to use all 8 pins, you can mask off the ones you don't want
 20 |                                           // Note that these will still get 0 written to them when we send pixels
 21 |                                           // TODO: If we have time, we could even add a variable that will and/or into the bits before writing to the port to support any combination of bits/values                                  
 22 | 
 23 | // These are the timing constraints taken mostly from 
 24 | // imperically measuring the output from the Adafruit library strandtest program
 25 | 
 26 | // Note that some of these defined values are for refernce only - the actual timing is determinted by the hard code.
 27 | 
 28 | #define T1H  814    // Width of a 1 bit in ns - 13 cycles
 29 | #define T1L  438    // Width of a 1 bit in ns -  7 cycles
 30 | 
 31 | #define T0H  312    // Width of a 0 bit in ns -  5 cycles
 32 | #define T0L  936    // Width of a 0 bit in ns - 15 cycles 
 33 | 
 34 | // Phase #1 - Always 1  - 5 cycles
 35 | // Phase #2 - Data part - 8 cycles
 36 | // Phase #3 - Always 0  - 7 cycles
 37 | 
 38 | #define RES 50000   // Width of the low gap between bits to cause a frame to latch
 39 | 
 40 | // Here are some convience defines for using nanoseconds specs to generate actual CPU delays
 41 | 
 42 | #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
 43 | 
 44 | #define CYCLES_PER_SEC (F_CPU)
 45 | 
 46 | #define NS_PER_CYCLE ( NS_PER_SEC / CYCLES_PER_SEC )
 47 | 
 48 | #define NS_TO_CYCLES(n) ( (n) / NS_PER_CYCLE )
 49 | 
 50 | 
 51 | // Sends a full 8 bits down all the pins, represening a single color of 1 pixel
 52 | // 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. 
 53 | // 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. 
 54 | 
 55 | /// Unforntunately we have to drop to ASM for this so we can interleave the computaions durring the delays, otherwise things get too slow.
 56 | 
 57 | // OnBits is the mask of which bits are connected to strips. We pass it on so that we
 58 | // do not turn on unused pins becuase this would enable the pullup. Also, hopefully passing this
 59 | // will cause the compiler to allocate a Register for it and avoid a reload every pass.
 60 | 
 61 | static inline void sendBitx8(  const uint8_t row , const uint8_t colorbyte , const uint8_t onBits ) {  
 62 |               
 63 |     asm volatile (
 64 | 
 65 | 
 66 |       "L_%=: \n\r"  
 67 |       
 68 |       "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.
 69 | 
 70 |       // Next determine if we are going to be sending 1s or 0s based on the current bit in the color....
 71 |       
 72 |       "mov r0, %[bitwalker] \n\t"                   // (1 cycles) 
 73 |       "and r0, %[colorbyte] \n\t"                   // (1 cycles)  - is the current bit in the color byte set?
 74 |       "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)
 75 | 
 76 |       // If we get here, then we want to send a 1 for every row that has an ON dot...
 77 |       "nop \n\t  "                                  // (1 cycles) 
 78 |       "out %[port], %[row]   \n\t"                  // (1 cycles) - set the output bits to [row] This is phase for T0H-T1H.
 79 |                                                     // ==========
 80 |                                                     // (5 cycles) - T0H (Phase #1)
 81 | 
 82 | 
 83 |       "nop \n\t nop \n\t "                          // (2 cycles) 
 84 |       "nop \n\t nop \n\t "                          // (2 cycles) 
 85 |       "nop \n\t nop \n\t "                          // (2 cycles) 
 86 |       "nop \n\t "                                   // (1 cycles) 
 87 | 
 88 |       "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
 89 |                                                     // ==========
 90 |                                                     // (8 cycles) - Phase #2
 91 |                                                     
 92 |       "ror %[bitwalker] \n\t"                      // (1 cycles) - get ready for next pass. On last pass, the bit will end up in C flag
 93 |                   
 94 |       "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
 95 | 
 96 |       "nop \n\t \n\t "                             // (1 cycles) - When added to the 5 cycles in S:, we gte the 7 cycles of T1L
 97 |             
 98 |       "jmp L_%= \n\t"                              // (3 cycles) 
 99 |                                                    // (1 cycles) - The OUT on the next pass of the loop
100 |                                                    // ==========
101 |                                                    // (7 cycles) - T1L
102 |                                                    
103 |                                                           
104 |       "OFF_%=: \n\r"                                // (1 cycles)    Note that we land here becuase of breq, which takes takes 2 cycles
105 | 
106 |       "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
107 |                                                     // ==========
108 |                                                     // (5 cycles) - T0H
109 | 
110 |       "ror %[bitwalker] \n\t"                      // (1 cycles) - get ready for next pass. On last pass, the bit will end up in C flag
111 |                   
112 |       "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
113 | 
114 |       "nop \n\t nop \n\t "                          // (2 cycles) 
115 |       "nop \n\t nop \n\t "                          // (2 cycles) 
116 |       "nop \n\t nop \n\t "                          // (2 cycles)             
117 |       "nop \n\t nop \n\t "                          // (2 cycles)             
118 |       "nop \n\t "                                   // (1 cycles)             
119 |             
120 |       "jmp L_%= \n\t"                               // (3 cycles) 
121 |                                                     // (1 cycles) - The OUT on the next pass of the loop      
122 |                                                     // ==========
123 |                                                     //(15 cycles) - T0L 
124 |       
125 |             
126 |       "DONE_%=: \n\t"
127 | 
128 |       // Don't need an explicit delay here since the overhead that follows will always be long enough
129 |     
130 |       ::
131 |       [port]    "I" (_SFR_IO_ADDR(PIXEL_PORT)),
132 |       [row]   "d" (row),
133 |       [onBits]   "d" (onBits),
134 |       [colorbyte]   "d" (colorbyte ),     // Phase 2 of the signal where the actual data bits show up.                
135 |       [bitwalker] "r" (0x80)                      // Alocate a register to hold a bit that we will walk down though the color byte
136 | 
137 |     );
138 |                                   
139 |     // Note that the inter-bit gap can be as long as you want as long as it doesn't exceed the reset timeout (which is A long time)
140 |     
141 | } 
142 | 
143 | 
144 | // Just wait long enough without sending any bots to cause the pixels to latch and display the last sent frame
145 | 
146 | void show() {
147 |   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)
148 | }
149 | 
150 | 
151 | // Send 3 bytes of color data (R,G,B) for a signle pixel down all the connected stringsat the same time
152 | // A 1 bit in "row" means send the color, a 0 bit means send black. 
153 | 
154 | static inline void sendRowRGB( uint8_t row ,  uint8_t r,  uint8_t g,  uint8_t b ) {
155 | 
156 |   sendBitx8( row , g , onBits);    // WS2812 takes colors in GRB order
157 |   sendBitx8( row , r , onBits);    // WS2812 takes colors in GRB order
158 |   sendBitx8( row , b , onBits);    // WS2812 takes colors in GRB order
159 |   
160 | }
161 | 
162 | // Turn off all pixels
163 | 
164 | static inline void clear() {
165 | 
166 |   cli();
167 |   for( unsigned int i=0; i< PIXELS; i++ ) {
168 | 
169 |     sendRowRGB( 0 , 0 , 0 , 0 );
170 |   }
171 |   sei();
172 |   show(); 
173 | }
174 | 
175 | // This nice 5x7 font from here...
176 | // http://sunge.awardspace.com/glcd-sd/node4.html
177 | 
178 | // Font details:
179 | // 1) Each char is fixed 5x7 pixels. 
180 | // 2) Each byte is one column.
181 | // 3) Columns are left to right order, leftmost byte is leftmost column of pixels.
182 | // 4) Each column is 8 bits high.
183 | // 5) Bit #7 is top line of char, Bit #1 is bottom.
184 | // 6) Bit #0 is always 0, becuase this pin is used as serial input and setting to 1 would enable the pull-up.
185 | 
186 | // defines ascii characters 0x20-0x7F (32-127)
187 | // PROGMEM after variable name as per https://www.arduino.cc/en/Reference/PROGMEM
188 | 
189 | #define FONT_WIDTH 5      
190 | #define INTERCHAR_SPACE 1
191 | #define ASCII_OFFSET 0x20    // ASSCI code of 1st char in font array
192 | 
193 | const uint8_t Font5x7[] PROGMEM = {
194 | 0x00,0x00,0x00,0x00,0x00,//  
195 | 0x00,0x00,0xfa,0x00,0x00,// !
196 | 0x00,0xe0,0x00,0xe0,0x00,// "
197 | 0x28,0xfe,0x28,0xfe,0x28,// #
198 | 0x24,0x54,0xfe,0x54,0x48,// $
199 | 0xc4,0xc8,0x10,0x26,0x46,// %
200 | 0x6c,0x92,0xaa,0x44,0x0a,// &
201 | 0x00,0xa0,0xc0,0x00,0x00,// '
202 | 0x00,0x38,0x44,0x82,0x00,// (
203 | 0x00,0x82,0x44,0x38,0x00,// )
204 | 0x10,0x54,0x38,0x54,0x10,// *
205 | 0x10,0x10,0x7c,0x10,0x10,// +
206 | 0x00,0x0a,0x0c,0x00,0x00,// ,
207 | 0x10,0x10,0x10,0x10,0x10,// -
208 | 0x00,0x06,0x06,0x00,0x00,// .
209 | 0x04,0x08,0x10,0x20,0x40,// /
210 | 0x7c,0x8a,0x92,0xa2,0x7c,// 0
211 | 0x00,0x42,0xfe,0x02,0x00,// 1
212 | 0x42,0x86,0x8a,0x92,0x62,// 2
213 | 0x84,0x82,0xa2,0xd2,0x8c,// 3
214 | 0x18,0x28,0x48,0xfe,0x08,// 4
215 | 0xe4,0xa2,0xa2,0xa2,0x9c,// 5
216 | 0x3c,0x52,0x92,0x92,0x0c,// 6
217 | 0x80,0x8e,0x90,0xa0,0xc0,// 7
218 | 0x6c,0x92,0x92,0x92,0x6c,// 8
219 | 0x60,0x92,0x92,0x94,0x78,// 9
220 | 0x00,0x6c,0x6c,0x00,0x00,// :
221 | 0x00,0x6a,0x6c,0x00,0x00,// ;
222 | 0x00,0x10,0x28,0x44,0x82,// <
223 | 0x28,0x28,0x28,0x28,0x28,// =
224 | 0x82,0x44,0x28,0x10,0x00,// >
225 | 0x40,0x80,0x8a,0x90,0x60,// ?
226 | 0x4c,0x92,0x9e,0x82,0x7c,// @
227 | 0x7e,0x88,0x88,0x88,0x7e,// A
228 | 0xfe,0x92,0x92,0x92,0x6c,// B
229 | 0x7c,0x82,0x82,0x82,0x44,// C
230 | 0xfe,0x82,0x82,0x44,0x38,// D
231 | 0xfe,0x92,0x92,0x92,0x82,// E
232 | 0xfe,0x90,0x90,0x80,0x80,// F
233 | 0x7c,0x82,0x82,0x8a,0x4c,// G
234 | 0xfe,0x10,0x10,0x10,0xfe,// H
235 | 0x00,0x82,0xfe,0x82,0x00,// I
236 | 0x04,0x02,0x82,0xfc,0x80,// J
237 | 0xfe,0x10,0x28,0x44,0x82,// K
238 | 0xfe,0x02,0x02,0x02,0x02,// L
239 | 0xfe,0x40,0x20,0x40,0xfe,// M
240 | 0xfe,0x20,0x10,0x08,0xfe,// N
241 | 0x7c,0x82,0x82,0x82,0x7c,// O
242 | 0xfe,0x90,0x90,0x90,0x60,// P
243 | 0x7c,0x82,0x8a,0x84,0x7a,// Q
244 | 0xfe,0x90,0x98,0x94,0x62,// R
245 | 0x62,0x92,0x92,0x92,0x8c,// S
246 | 0x80,0x80,0xfe,0x80,0x80,// T
247 | 0xfc,0x02,0x02,0x02,0xfc,// U
248 | 0xf8,0x04,0x02,0x04,0xf8,// V
249 | 0xfe,0x04,0x18,0x04,0xfe,// W
250 | 0xc6,0x28,0x10,0x28,0xc6,// X
251 | 0xc0,0x20,0x1e,0x20,0xc0,// Y
252 | 0x86,0x8a,0x92,0xa2,0xc2,// Z
253 | 0x00,0x00,0xfe,0x82,0x82,// [
254 | 0x40,0x20,0x10,0x08,0x04,// (backslash)
255 | 0x82,0x82,0xfe,0x00,0x00,// ]
256 | 0x20,0x40,0x80,0x40,0x20,// ^
257 | 0x02,0x02,0x02,0x02,0x02,// _
258 | 0x00,0x80,0x40,0x20,0x00,// `
259 | 0x04,0x2a,0x2a,0x2a,0x1e,// a
260 | 0xfe,0x12,0x22,0x22,0x1c,// b
261 | 0x1c,0x22,0x22,0x22,0x04,// c
262 | 0x1c,0x22,0x22,0x12,0xfe,// d
263 | 0x1c,0x2a,0x2a,0x2a,0x18,// e
264 | 0x10,0x7e,0x90,0x80,0x40,// f
265 | 0x10,0x28,0x2a,0x2a,0x3c,// g
266 | 0xfe,0x10,0x20,0x20,0x1e,// h
267 | 0x00,0x22,0xbe,0x02,0x00,// i
268 | 0x04,0x02,0x22,0xbc,0x00,// j
269 | 0x00,0xfe,0x08,0x14,0x22,// k
270 | 0x00,0x82,0xfe,0x02,0x00,// l
271 | 0x3e,0x20,0x18,0x20,0x1e,// m
272 | 0x3e,0x10,0x20,0x20,0x1e,// n
273 | 0x1c,0x22,0x22,0x22,0x1c,// o
274 | 0x3e,0x28,0x28,0x28,0x10,// p
275 | 0x10,0x28,0x28,0x18,0x3e,// q
276 | 0x3e,0x10,0x20,0x20,0x10,// r
277 | 0x12,0x2a,0x2a,0x2a,0x04,// s
278 | 0x20,0xfc,0x22,0x02,0x04,// t
279 | 0x3c,0x02,0x02,0x04,0x3e,// u
280 | 0x38,0x04,0x02,0x04,0x38,// v
281 | 0x3c,0x02,0x0c,0x02,0x3c,// w
282 | 0x22,0x14,0x08,0x14,0x22,// x
283 | 0x30,0x0a,0x0a,0x0a,0x3c,// y
284 | 0x22,0x26,0x2a,0x32,0x22,// z
285 | 0x00,0x10,0x6c,0x82,0x00,// {
286 | 0x00,0x00,0xfe,0x00,0x00,// |
287 | 0x00,0x82,0x6c,0x10,0x00,// }
288 | 0x10,0x10,0x54,0x38,0x10,// ~
289 | 0x10,0x38,0x54,0x10,0x10,// 
290 | };
291 | 
292 | // Send the pixels to form the specified char, not including interchar space
293 | // skip is the number of pixels to skip at the begining to enable sub-char smooth scrolling
294 | 
295 | // TODO: Subtract the offset from the char before starting the send sequence to save time if nessisary
296 | // TODO: Also could pad the begining of the font table to aovid the offset subtraction at the cost of 20*8 bytes of progmem
297 | // TODO: Could pad all chars out to 8 bytes wide to turn the the multiply by FONT_WIDTH into a shift 
298 | 
299 | static inline void sendChar( uint8_t c ,  uint8_t skip , uint8_t r,  uint8_t g,  uint8_t b ) {
300 | 
301 |   const uint8_t *charbase = Font5x7 + (( c -' ')* FONT_WIDTH ) ; 
302 | 
303 |   uint8_t col=FONT_WIDTH; 
304 | 
305 |   while (skip--) {
306 |       charbase++;
307 |       col--;    
308 |   }
309 |   
310 |   while (col--) {
311 |       sendRowRGB( pgm_read_byte_near( charbase++ ) , r , g , b );
312 |   }    
313 | 
314 |   // TODO: FLexible interchar spacing
315 | 
316 |   sendRowRGB( 0 , r , g , b );    // Interchar space
317 |   
318 | }
319 | 
320 | 
321 | // Show the passed string. The last letter of the string will be in the rightmost pixels of the display.
322 | // Skip is how many cols of the 1st char to skip for smooth scrolling
323 | 
324 | static inline void sendString( const char *s , uint8_t skip ,  const uint8_t r,  const uint8_t g,  const uint8_t b ) {
325 | 
326 |   unsigned int l=PIXELS/(FONT_WIDTH+INTERCHAR_SPACE); 
327 | 
328 |   sendChar( *s , skip ,  r , g , b );   // First char is special case becuase it can be stepped for smooth scrolling
329 |   
330 |   while ( *(++s) && l--) {
331 | 
332 |     sendChar( *s , 0,  r , g , b );
333 | 
334 |   }
335 | }
336 | 
337 | // A nice arcade font from...
338 | // http://jared.geek.nz/2014/jan/custom-fonts-for-microcontrollers
339 | 
340 | #define ALTFONT_WIDTH 8
341 | 
342 | const uint8_t altfont[] PROGMEM = {
343 |   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//  
344 |   0x06,0x06,0x30,0x30,0x60,0xc0,0xc0,0x00,// !
345 |   0xe0,0xe0,0x00,0xe0,0xe0,0x00,0x00,0x00,// "
346 |   0x28,0xfe,0xfe,0x28,0xfe,0xfe,0x28,0x00,// #
347 |   0xf6,0xf6,0xd6,0xd6,0xd6,0xde,0xde,0x00,// $
348 |   0xc6,0xce,0x1c,0x38,0x70,0xe6,0xc6,0x00,// %
349 |   0xfe,0xfe,0xd6,0xc6,0x16,0x1e,0x1e,0x00,// &
350 |   0xe0,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,// '
351 |   0xfe,0xfe,0x00,0x00,0x00,0x00,0x00,0x00,// (
352 |   0x00,0xfe,0xfe,0x00,0x00,0x00,0x00,0x00,// )
353 |   0x6c,0x10,0xfe,0xfe,0xfe,0x10,0x6c,0x00,// *
354 |   0x10,0x10,0x7c,0x10,0x10,0x00,0x00,0x00,// +
355 |   0x06,0x06,0x00,0x00,0x00,0x00,0x00,0x00,// ,
356 |   0x10,0x10,0x10,0x10,0x10,0x00,0x00,0x00,// -
357 |   0x06,0x06,0x00,0x00,0x00,0x00,0x00,0x00,// .
358 |   0x0e,0x38,0xe0,0x00,0x00,0x00,0x00,0x00,// /
359 |   0xfe,0xfe,0xc6,0xc6,0xc6,0xfe,0xfe,0x00,// 0
360 |   0x06,0x66,0x66,0xfe,0xfe,0x06,0x06,0x00,// 1
361 |   0xde,0xde,0xd6,0xd6,0xd6,0xf6,0xf6,0x00,// 2
362 |   0xc6,0xc6,0xd6,0xd6,0xd6,0xfe,0xfe,0x00,// 3
363 |   0xf8,0xf8,0x18,0x18,0x18,0x7e,0x7e,0x00,// 4
364 |   0xf6,0xf6,0xd6,0xd6,0xd6,0xde,0xde,0x00,// 5
365 |   0xfe,0xfe,0x36,0x36,0x36,0x3e,0x3e,0x00,// 6
366 |   0xc2,0xc6,0xce,0xdc,0xf8,0xf0,0xe0,0x00,// 7
367 |   0xfe,0xfe,0xd6,0xd6,0xd6,0xfe,0xfe,0x00,// 8
368 |   0xf8,0xf8,0xd8,0xd8,0xd8,0xfe,0xfe,0x00,// 9
369 |   0x36,0x36,0x00,0x00,0x00,0x00,0x00,0x00,// :
370 |   0x36,0x36,0x00,0x00,0x00,0x00,0x00,0x00,// ;
371 |   0x10,0x28,0x44,0x44,0x00,0x00,0x00,0x00,// <
372 |   0x28,0x28,0x28,0x28,0x28,0x00,0x00,0x00,// =
373 |   0x44,0x44,0x28,0x10,0x00,0x00,0x00,0x00,// >
374 |   0xc0,0xc0,0xda,0xda,0xd0,0xf0,0xf0,0x00,// ?
375 |   0xfe,0xfe,0xc6,0xf6,0xd6,0xf6,0xf6,0x00,// @
376 |   0xfe,0xfe,0xd8,0xd8,0xd8,0xfe,0xfe,0x00,// A
377 |   0xfe,0xfe,0xd6,0xd6,0xf6,0x7e,0x3e,0x00,// B
378 |   0xfe,0xfe,0xc6,0xc6,0xc6,0xc6,0xc6,0x00,// C
379 |   0xfe,0xfe,0xc6,0xc6,0xe6,0x7e,0x3e,0x00,// D
380 |   0xfe,0xfe,0xd6,0xd6,0xd6,0xd6,0xd6,0x00,// E
381 |   0xfe,0xfe,0xd0,0xd0,0xd0,0xc0,0xc0,0x00,// F
382 |   0xfe,0xfe,0xc6,0xc6,0xd6,0xde,0xde,0x00,// G
383 |   0xfe,0xfe,0x18,0x18,0x18,0xfe,0xfe,0x00,// H
384 |   0xc6,0xc6,0xfe,0xfe,0xc6,0xc6,0xc6,0x00,// I
385 |   0x06,0x06,0x06,0x06,0x06,0xfe,0xfc,0x00,// J
386 |   0xfe,0xfe,0x18,0x18,0x78,0xfe,0x9e,0x00,// K
387 |   0xfe,0xfe,0x06,0x06,0x06,0x06,0x06,0x00,// L
388 |   0xfe,0xfe,0xc0,0x60,0xc0,0xfe,0xfe,0x00,// M
389 |   0xfe,0xfe,0x70,0x38,0x1c,0xfe,0xfe,0x00,// N
390 |   0xfe,0xfe,0xc6,0xc6,0xc6,0xfe,0xfe,0x00,// O
391 |   0xfe,0xfe,0xd8,0xd8,0xd8,0xf8,0xf8,0x00,// P
392 |   0xfe,0xfe,0xc6,0xce,0xce,0xfe,0xfe,0x00,// Q
393 |   0xfe,0xfe,0xd8,0xdc,0xde,0xfe,0xfa,0x00,// R
394 |   0xf6,0xf6,0xd6,0xd6,0xd6,0xde,0xde,0x00,// S
395 |   0xc0,0xc0,0xfe,0xfe,0xc0,0xc0,0xc0,0x00,// T
396 |   0xfe,0xfe,0x06,0x06,0x06,0xfe,0xfe,0x00,// U
397 |   0xf8,0xfc,0x0e,0x06,0x0e,0xfc,0xf8,0x00,// V
398 |   0xfc,0xfe,0x06,0x0c,0x06,0xfe,0xfc,0x00,// W
399 |   0xee,0xfe,0x38,0x10,0x38,0xfe,0xee,0x00,// X
400 |   0xe0,0xf0,0x3e,0x1e,0x3e,0xf0,0xe0,0x00,// Y
401 |   0xce,0xde,0xd6,0xd6,0xd6,0xf6,0xe6,0x00,// Z
402 |   0xfe,0xfe,0x00,0x00,0x00,0x00,0x00,0x00,// [
403 |   0xe0,0x38,0x0e,0x00,0x00,0x00,0x00,0x00,// \
404 |   0x00,0xfe,0xfe,0x00,0x00,0x00,0x00,0x00,// ]
405 |   0x00,0xfe,0x02,0xfe,0x00,0x00,0x00,0x00,// ^
406 |   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,// _
407 |   0x00,0xfe,0x02,0xfe,0x00,0x00,0x00,0x00,// `
408 |   0xfe,0xfe,0xd8,0xd8,0xd8,0xfe,0xfe,0x00,// a
409 |   0xfe,0xfe,0xd6,0xd6,0xf6,0x7e,0x3e,0x00,// b
410 |   0xfe,0xfe,0xc6,0xc6,0xc6,0xc6,0xc6,0x00,// c
411 |   0xfe,0xfe,0xc6,0xc6,0xe6,0x7e,0x3e,0x00,// d
412 |   0xfe,0xfe,0xd6,0xd6,0xd6,0xd6,0xd6,0x00,// e
413 |   0xfe,0xfe,0xd0,0xd0,0xd0,0xc0,0xc0,0x00,// f
414 |   0xfe,0xfe,0xc6,0xc6,0xd6,0xde,0xde,0x00,// g
415 |   0xfe,0xfe,0x18,0x18,0x18,0xfe,0xfe,0x00,// h
416 |   0xc6,0xc6,0xfe,0xfe,0xc6,0xc6,0xc6,0x00,// i
417 |   0x06,0x06,0x06,0x06,0x06,0xfe,0xfc,0x00,// j
418 |   0xfe,0xfe,0x18,0x18,0x78,0xfe,0x9e,0x00,// k
419 |   0xfe,0xfe,0x06,0x06,0x06,0x06,0x06,0x00,// l
420 |   0xfe,0xfe,0xc0,0x60,0xc0,0xfe,0xfe,0x00,// m
421 |   0xfe,0xfe,0x70,0x38,0x1c,0xfe,0xfe,0x00,// n
422 |   0xfe,0xfe,0xc6,0xc6,0xc6,0xfe,0xfe,0x00,// o
423 |   0xfe,0xfe,0xd8,0xd8,0xd8,0xf8,0xf8,0x00,// p
424 |   0xfe,0xfe,0xc6,0xce,0xce,0xfe,0xfe,0x00,// q
425 |   0xfe,0xfe,0xd8,0xdc,0xde,0xfe,0xfa,0x00,// r
426 |   0xf6,0xf6,0xd6,0xd6,0xd6,0xde,0xde,0x00,// s
427 |   0xc0,0xc0,0xfe,0xfe,0xc0,0xc0,0xc0,0x00,// t
428 |   0xfe,0xfe,0x06,0x06,0x06,0xfe,0xfe,0x00,// u
429 |   0xf8,0xfc,0x0e,0x06,0x0e,0xfc,0xf8,0x00,// v
430 |   0xfc,0xfe,0x06,0x0c,0x06,0xfe,0xfc,0x00,// w
431 |   0xee,0xfe,0x38,0x10,0x38,0xfe,0xee,0x00,// x
432 |   0xe0,0xf0,0x3e,0x1e,0x3e,0xf0,0xe0,0x00,// y
433 |   0xce,0xde,0xd6,0xd6,0xd6,0xf6,0xe6,0x00,// z
434 |   0x38,0xfe,0xfe,0x00,0x00,0x00,0x00,0x00,// {
435 |   0xfe,0x00,0x00,0x00,0x00,0x00,0x00,0x00,// |
436 |   0x00,0xfe,0xfe,0x38,0x00,0x00,0x00,0x00,// }
437 |   0x00,0xfe,0x02,0xfe,0x00,0x00,0x00,0x00,// ~
438 | };
439 | 
440 | 
441 | // Keep track of where we are in the color cycle between chars
442 | static uint8_t altbright =0; 
443 | 
444 | // Send a char with a column-based color cycle
445 | static inline void sendCharAlt( uint8_t c ) {
446 | 
447 |   const uint8_t *charbase = altfont + (( c -' ')* ALTFONT_WIDTH) ; 
448 | 
449 |   uint8_t col=ALTFONT_WIDTH; 
450 |   
451 |   while (col--) {
452 | 
453 |       sendRowRGB(  pgm_read_byte_near( charbase++ ) , altbright , 0 , 0x80  );
454 |    
455 |       altbright+=10;
456 |   }
457 | 
458 |   sendRowRGB( 0 ,0, 0 , 0 );
459 |   altbright+=10;
460 | 
461 | }
462 | 
463 | // Show the passed string with the arcade font and a nice vertical color cycle effect
464 | 
465 | static inline void sendStringAlt( const char *s  ) {
466 | 
467 |   unsigned int l=PIXELS/(ALTFONT_WIDTH+INTERCHAR_SPACE); 
468 | 
469 |   while ( l--) {
470 | 
471 |     char c;  
472 | 
473 |     c =   *s++;
474 | 
475 |     if (!c) break;
476 |     
477 |     sendCharAlt( c  );
478 | 
479 |   }
480 | }
481 | 
482 | 
483 | 
484 | // Set the specified pins up as digital out
485 | 
486 | void ledsetup() {
487 | 
488 |   PIXEL_DDR |= onBits;   // Set all used pins to output
489 |     
490 | }
491 | 
492 | 
493 | 
494 | void setup() {
495 |     
496 |   ledsetup();  
497 |   
498 | }
499 | 
500 | 
501 | // https://learn.adafruit.com/led-tricks-gamma-correction/the-quick-fix
502 | 
503 | const uint8_t PROGMEM gamma[] = {
504 |     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
505 |     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,
506 |     1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,
507 |     2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  5,  5,  5,
508 |     5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9, 10,
509 |    10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,
510 |    17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
511 |    25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,
512 |    37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,
513 |    51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,
514 |    69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,
515 |    90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,
516 |   115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,
517 |   144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,
518 |   177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,
519 |   215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255 };
520 | 
521 | // Map 0-255 visual brightness to 0-255 LED brightness 
522 | #define GAMMA(x) (pgm_read_byte(&gamma[x]))
523 | 
524 | 
525 | void showcountdown() {
526 | 
527 |   // Start sequence.....
528 | 
529 |   const char *countdownstr = "            FIRE ROLLERBALL IN ";
530 | 
531 |   unsigned int count = 600; 
532 | 
533 |   clear();
534 |   while (count>0) {
535 | 
536 |     count--;
537 | 
538 |     uint8_t digit1 = count/100;
539 |     uint8_t digit2 = (count - (digit1*100)) / 10;
540 |     uint8_t digit3 = (count - (digit1*100) - (digit2*10));
541 | 
542 |     uint8_t char1 = digit1 + '0';
543 |     uint8_t char2 = digit2 + '0';
544 |     uint8_t char3 = digit3 + '0';
545 |     
546 |     uint8_t brightness = GAMMA( ((count % 100) * 256)  / 100 );
547 | 
548 |     cli();
549 |     sendString( countdownstr , 1 , brightness , brightness , brightness );      
550 |  
551 |     sendRowRGB( 0x00 , 0 , 0 , 0xff );
552 |  
553 |   //  sendChar( '0' , 0 , 0x80, 0 , 0 );
554 |     
555 |     sendChar( char1 , 0 , 0x80, 0 , 0 );
556 |     sendChar( '.'   , 0 , 0x80, 0 , 0  );
557 |     sendChar( char2 , 0 , 0x80, 0 , 0  );
558 |     sendChar( char3 , 0 , 0x80, 0 , 0 );
559 |     
560 |     sei();
561 |     show();
562 |   }
563 | 
564 |   count = 100;
565 | 
566 |   // One last farewell blink
567 | 
568 |   while (count>0) {
569 | 
570 |     count--;
571 | 
572 |     
573 |     uint8_t brightness = GAMMA( ((count % 100) * 256)  / 100 );
574 | 
575 |     cli();
576 |     sendString( countdownstr , 1 , brightness , brightness , brightness );      
577 | 
578 |     sendRowRGB( 0x00 , 0 , 0 , 0xff );   // We need to quickly send a blank byte just to keep from missing our deadlne.
579 |     sendChar( '0' , 0 , brightness, 0 , 0 );
580 |     sendChar( '.' , 0 , brightness, 0 , 0 );
581 |     sendChar( '0' , 0 , brightness, 0 , 0 );
582 |     sendChar( '0' , 0 , brightness, 0 , 0 );
583 |      
584 |     
585 |     sei();
586 |     show();
587 |   }
588 |   
589 |   
590 | }
591 | 
592 | 
593 | void showstarfield() {
594 | 
595 |   const uint8_t field = 40;       // Good size for a field, must be less than 256 so counters fit in a byte
596 |  
597 |   uint8_t sectors = (PIXELS / field);      // Repeating sectors makes for more stars and faster update
598 | 
599 |   for(unsigned int i=0; i<300;i++) {
600 | 
601 |     unsigned int r = random( PIXELS * 8 );   // Random slow, so grab one big number and we will break it down. 
602 | 
603 |     unsigned int x = r /8; 
604 |     uint8_t y = r & 0x07;                // We use 7 rows
605 |     uint8_t bitmask = (2<<y);           // Start at bit #1 since we enver use the bottom bit
606 | 
607 |     cli();    
608 | 
609 |       unsigned int l=x; 
610 |     
611 |       while (l--) {
612 |            sendRowRGB( 0 , 0x00, 0x00, 0x00);          
613 |       }
614 |         
615 |       sendRowRGB( bitmask , 0x40, 0x40, 0xff);  // Starlight blue
616 | 
617 |       l = PIXELS-x;
618 |       
619 |       while (l--) {
620 |            sendRowRGB( 0 , 0x00, 0x00, 0x00);          
621 |       }      
622 |         
623 |           
624 | 
625 |     sei();
626 | 
627 |    // show(); // Not needed - random is alwasy slow enough to trigger a reset
628 |        
629 |   }
630 | 
631 | }
632 | 
633 | static inline void sendIcon( const uint8_t *fontbase , uint8_t which, int8_t shift , uint8_t width , uint8_t r , uint8_t g , uint8_t b ) {
634 | 
635 |   const uint8_t *charbase = fontbase + (which*width);
636 | 
637 |   if (shift <0) {
638 | 
639 |         uint8_t shiftabs = -1 * shift;
640 |   
641 |         while (width--) {
642 | 
643 |           uint8_t row = pgm_read_byte_near( charbase++ );
644 |     
645 |           sendRowRGB(  row << shiftabs , r , g , b );
646 |      
647 |     }
648 | 
649 |   } else {
650 | 
651 | 
652 |     
653 |     while (width--) {
654 |   
655 |         sendRowRGB(  (pgm_read_byte_near( charbase++ ) >> shift) & onBits , r , g , b );
656 |      
657 |     }
658 | 
659 |   }
660 | 
661 | }
662 | 
663 | 
664 | #define ENIMIES_WIDTH 12
665 | 
666 | const uint8_t enimies[] PROGMEM = {
667 | 
668 |   0x70,0xf4,0xfe,0xda,0xd8,0xf4,0xf4,0xd8,0xda,0xfe,0xf4,0x70, // Enimie 1 - open
669 |   0x72,0xf2,0xf4,0xdc,0xd8,0xf4,0xf4,0xd8,0xdc,0xf4,0xf2,0x72, // Enimie 1 - close
670 |   0x1c,0x30,0x7c,0xda,0x7a,0x78,0x7a,0xda,0x7c,0x30,0x1c,0x00, // Enimie 2 - open
671 |   0xf0,0x3a,0x7c,0xd8,0x78,0x78,0x78,0xd8,0x7c,0x3a,0xf0,0x00, // Enimie 2 - closed
672 |   0x92,0x54,0x10,0x82,0x44,0x00,0x00,0x44,0x82,0x10,0x54,0x92, // Explosion
673 | };
674 | 
675 | 
676 | void showinvaderwipe( uint8_t which , const char *pointsStr , uint8_t r , uint8_t g, uint8_t b) {
677 | 
678 |   clear();
679 |   delay(500);
680 | 
681 |   for( uint8_t p = 0 ; p<strlen( pointsStr) ; p++ ) {
682 | 
683 |       cli();
684 |       sendStringAlt( "                " );
685 |       sendIcon( enimies , which , 0 , ENIMIES_WIDTH , r , g , b );
686 |       for(uint8_t i=0; i<=p ;i++ ){        
687 |         sendChar( *(pointsStr+i) , 0 ,r>>2 , g>>2 , b>>2 );     // Dim text slightly
688 |       }
689 |       sei();
690 |       delay(100);
691 |     
692 |   }
693 | 
694 |   delay(1500);
695 | 
696 |   
697 | }
698 | 
699 | void showinvaders() {
700 |   
701 |   showinvaderwipe(   3 ,  " = 20 POINTS" , 0x80 , 0x80 ,0x80 );
702 |   showinvaderwipe(   1 ,  " = 10 POINTS" , 0x00 , 0xff ,0x00 );
703 | 
704 |   uint8_t acount = PIXELS/(ENIMIES_WIDTH+FONT_WIDTH);      // How many aliens do we have room for?  
705 | 
706 |   for( int8_t row = -4 ; row < 6 ; row++ ) {     // Walk down the rows
707 | 
708 |     //  Walk them 6 pixels per row 
709 | 
710 |     // ALternate direction on each row
711 | 
712 |     uint8_t s,e,d;
713 | 
714 |     if (row & 1) {
715 | 
716 |       s=1; e=8; d=1;
717 |       
718 |     } else {
719 | 
720 |       s=7; e=0; d=-1;
721 |             
722 |     }
723 | 
724 |     
725 |     for( char p = s ; p!=e ; p +=d ) {
726 |    
727 |         // Now slowly move aliens
728 |   
729 |         // work our way though the alines moving each one to the left
730 |         
731 |       
732 |           cli();
733 |     
734 |           // Start with margin
735 | 
736 |           uint8_t margin = p ;
737 | 
738 |           while (margin--) {
739 |             sendRowRGB( 0 , 0x00 , 0x00 , 0x00 );
740 |           }
741 | 
742 |           for( uint8_t l=0; l<acount ; l++ ) {
743 | 
744 |             sendIcon( enimies , p&1 , row, ENIMIES_WIDTH , 0xFF , 0xFF , 0xFF );
745 |             sendChar( ' ' , 0 , 0x00 , 0x00 , 0x00 ) ; // No over crowding
746 |             
747 |           }
748 |   
749 |           sei();
750 |           delay(70);
751 |             
752 |         }
753 |    }
754 |      // delay(200);            
755 |   
756 | }
757 | 
758 | 
759 | 
760 | 
761 | 
762 | void showallyourbase() {
763 |   
764 |   const char *allyourbase = "CAT: ALL YOUR BASE ARE BELONG TO US !!!" ;
765 | 
766 |   clear();
767 |   for(unsigned int slide=10000; slide ; slide-=10 ) {
768 |       altbright = (slide & 0xff);
769 |       cli();      
770 |       sendChar(' ' , 0 , 0 , 0 , 0 );
771 |       sendStringAlt( allyourbase);
772 |       sei();
773 |       show();
774 |   }
775 |   
776 | }
777 | 
778 |   
779 | 
780 | #define JAB_MAX_BRIGHTNESS 0xff
781 | #define JAB_MIN_BRIGHTNESS 0x00
782 | #define JAB_STEPS (JAB_MAX_BRIGHTNESS-JAB_MIN_BRIGHTNESS)
783 | 
784 | void showjabber() {
785 | 
786 |   const char *m = 
787 |           
788 |       "Twas brillig, and the slithy toves "
789 |             "Did gyre and gimble in the wabe: "
790 |       "All mimsy were the borogoves, "
791 |             "And the mome raths outgrabe. "
792 |       
793 |       "Beware the Jabberwock, my son! "
794 |             "The jaws that bite, the claws that catch! "
795 |       "Beware the Jubjub bird, and shun "      
796 |             "The frumious Bandersnatch! "
797 |       
798 |       "He took his vorpal sword in hand; "
799 |             "Long time the manxome foe he sought- "
800 |       "So rested he by the Tumtum tree "
801 |             "And stood awhile in thought. "
802 |       
803 |       "And, as in uffish thought he stood, "
804 |             "The Jabberwock, with eyes of flame, "
805 |       "Came whiffling through the tulgey wood, "      
806 |             "And burbled as it came! "
807 |       
808 |       "One, two! One, two! And through and through "
809 |             "The vorpal blade went snicker-snack! "
810 |       "He left it dead, and with its head "
811 |             "He went galumphing back. "
812 |       
813 |       "And hast thou slain the Jabberwock? "
814 |             "Come to my arms, my beamish boy! "
815 |       "O frabjous day! Callooh! Callay! "
816 |             "He chortled in his joy. "
817 |       
818 |       "Twas brillig, and the slithy toves "
819 |             "Did gyre and gimble in the wabe: "
820 |       "All mimsy were the borogoves, "
821 |             "And the mome raths outgrabe."  
822 |       
823 |             ;
824 | 
825 |   // Text foreground color cycle effect
826 |   uint8_t sector =0;
827 |   uint8_t step=0;
828 |     
829 |   while (*m) {      
830 | 
831 |       if (step== JAB_STEPS) {
832 |         step=0;
833 |         sector++;
834 |         if (sector==3) {
835 |           sector=0;
836 |         }
837 |       } else {
838 |         step++;
839 |       }
840 | 
841 |       uint8_t rampup = JAB_MIN_BRIGHTNESS + step;
842 |       uint8_t rampdown = JAB_MIN_BRIGHTNESS + (JAB_STEPS - step); 
843 |       
844 |       uint8_t r,g,b;
845 |       
846 |       switch( sector ) {
847 |         case 0: 
848 |             r=rampup;
849 |             g=rampdown;
850 |             b=JAB_MIN_BRIGHTNESS;
851 |             break;
852 |          case 1:
853 |             r=rampdown;
854 |             g=JAB_MIN_BRIGHTNESS;
855 |             b=rampup;
856 |             break;
857 |          case 2:
858 |             r=JAB_MIN_BRIGHTNESS;
859 |             g=rampup;
860 |             b=rampdown;
861 |             break;
862 |       
863 |       };
864 | 
865 |       for( uint8_t step=0; step<FONT_WIDTH+INTERCHAR_SPACE  ; step++ ) {   // step though each column of the 1st char for smooth scrolling
866 | 
867 | 
868 |        cli();
869 | 
870 |        sendString( m , step , r, g, b );
871 |       
872 |        sei();
873 | 
874 |        PORTB|=0x01;      
875 |        delay(1);
876 |        PORTB&=~0x01;
877 | 
878 |       }
879 | 
880 |     m++;
881 | 
882 |   }
883 | 
884 | }
885 | 
886 | 
887 | void loop() {
888 | 
889 |   showcountdown();
890 |   showallyourbase();
891 |   showstarfield();
892 |   showinvaders();
893 |   showjabber();
894 | 
895 |   // TODO: Actually sample the state of the pullup on unused pins and OR it into the mask so we maintain the state.
896 |   // Must do AFTER the cli(). 
897 |   // TODO: Add offBits also to maintain the pullup state of unused pins. 
898 |   
899 |   return;  
900 | }
901 | 
902 | 
903 | 
904 | 


--------------------------------------------------------------------------------
/Arduino/SimpleScroll/SimpleScroll.ino:
--------------------------------------------------------------------------------
   1 | // This simplified demo scrolls the text of the Jaberwoky poem directly from flash memory
   2 | // Full article at  http://wp.josh.com/2016/05/20/huge-scrolling-arduino-led-sign/
   3 | 
   4 | // Change this to be at least as long as your pixel string (too long will work fine, just be a little slower)
   5 | 
   6 | #define PIXEL_COUNT 96  // Number of pixels in the string. I am using 4 meters of 96LED/M
   7 | 
   8 | // These values depend on which pins your 8 strings are connected to and what board you are using 
   9 | // More info on how to find these at http://www.arduino.cc/en/Reference/PortManipulation
  10 | 
  11 | // PORTD controls Digital Pins 0-7 on the Uno
  12 | 
  13 | // You'll need to look up the port/bit combination for other boards. 
  14 | 
  15 | // Note that you could also include the DigitalWriteFast header file to not need to to this lookup.
  16 | 
  17 | #define PIXEL_PORT  PORTD  // Port of the pin the pixels are connected to
  18 | #define PIXEL_DDR   DDRD   // Port of the pin the pixels are connected to
  19 | 
  20 | 
  21 | static const uint8_t onBits=0b11111110;   // Bit pattern to write to port to turn on all pins connected to LED strips. 
  22 |                                           // If you do not want to use all 8 pins, you can mask off the ones you don't want
  23 |                                           // Note that these will still get 0 written to them when we send pixels
  24 |                                           // TODO: If we have time, we could even add a variable that will and/or into the bits before writing to the port to support any combination of bits/values                                  
  25 | 
  26 | // These are the timing constraints taken mostly from 
  27 | // imperically measuring the output from the Adafruit library strandtest program
  28 | 
  29 | // Note that some of these defined values are for refernce only - the actual timing is determinted by the hard code.
  30 | 
  31 | #define T1H  814    // Width of a 1 bit in ns - 13 cycles
  32 | #define T1L  438    // Width of a 1 bit in ns -  7 cycles
  33 | 
  34 | #define T0H  312    // Width of a 0 bit in ns -  5 cycles
  35 | #define T0L  936    // Width of a 0 bit in ns - 15 cycles 
  36 | 
  37 | // Phase #1 - Always 1  - 5 cycles
  38 | // Phase #2 - Data part - 8 cycles
  39 | // Phase #3 - Always 0  - 7 cycles
  40 | 
  41 | 
  42 | #define RES 500000   // Width of the low gap between bits to cause a frame to latch
  43 | 
  44 | // Here are some convience defines for using nanoseconds specs to generate actual CPU delays
  45 | 
  46 | #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
  47 | 
  48 | #define CYCLES_PER_SEC (F_CPU)
  49 | 
  50 | #define NS_PER_CYCLE ( NS_PER_SEC / CYCLES_PER_SEC )
  51 | 
  52 | #define NS_TO_CYCLES(n) ( (n) / NS_PER_CYCLE )
  53 | 
  54 | 
  55 | // Sends a full 8 bits down all the pins, represening a single color of 1 pixel
  56 | // 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. 
  57 | // 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. 
  58 | 
  59 | /// Unforntunately we have to drop to ASM for this so we can interleave the computaions durring the delays, otherwise things get too slow.
  60 | 
  61 | // OnBits is the mask of which bits are connected to strips. We pass it on so that we
  62 | // do not turn on unused pins becuase this would enable the pullup. Also, hopefully passing this
  63 | // will cause the compiler to allocate a Register for it and avoid a reload every pass.
  64 | 
  65 | static inline void sendBitx8(  const uint8_t row , const uint8_t colorbyte , const uint8_t onBits ) {  
  66 |               
  67 |     asm volatile (
  68 | 
  69 | 
  70 |       "L_%=: \n\r"  
  71 | 
  72 |             
  73 |       "cli \n\t"                                   //              Turn off interrupts to make sure we meet the T0H deadline. 
  74 |       "out %[port], %[onBits] \n\t"                 //              Send either T0H or the first part of T1H. Onbits is a mask of which bits have strings attached.
  75 | 
  76 |       // Next determine if we are going to be sending 1s or 0s based on the current bit in the color....
  77 |       "mov r0, %[bitwalker] \n\t"                   // (1 cycles)  - Get ready to check if we should send all zeros      
  78 |       "and r0, %[colorbyte] \n\t"                   // (1 cycles)  - is the current bit in the color byte set?
  79 |       "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)
  80 | 
  81 |       "nop \n\t \n\t "                             // (1 cycles) - Balances out the extra cycle on the other path
  82 |       
  83 |       // If we get here, then we want to send a 1 for every row that has an ON dot...
  84 |       // So if there is a 1 in [row] then the output will still high, otherwise it will go low
  85 |       // making a short zero bit signal. 
  86 |       "out %[port], %[row]   \n\t"                  // (1 cycles) - set the output bits to [row] This is phase for T0H-T1H.
  87 |                                                     // ==========
  88 |                                                     // (5 cycles) - T0H (Phase #1) 4 cycles / 16Mhz = 310 nanoseconds. We should be able to get by with 200ns, but I found a WS2813 that says 300ns. 
  89 | 
  90 |       "sei \n\t"                                    // (1 cycles) OK to reenable interrupt now - T0H is the only timing sensitive phase https://wp.josh.com/2014/05/13/ws2812-neopixels-are-not-so-finicky-once-you-get-to-know-them/
  91 |                                                     
  92 |               
  93 |       "jmp NEXT_%= \n\t"                              // (3 cycles) 
  94 |                                                    // (1 cycles) - The OUT on the next pass of the loop
  95 |                                                    // ==========
  96 |                                                    // (7 cycles) - T1L
  97 |                                                    
  98 |                                                           
  99 |       "OFF_%=: \n\r"                                // (1 cycles)    Note that we land here becuase of breq, which takes takes 2 cycles
 100 | 
 101 |       "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
 102 |                                                     // ==========
 103 |                                                     // (4 cycles) - T0H
 104 |                                                     
 105 |       "sei \n\t"                                    // (1 cycles) OK to reenable interrupt now - T0H is the only timing sensitive phase https://wp.josh.com/2014/05/13/ws2812-neopixels-are-not-so-finicky-once-you-get-to-know-them/
 106 | 
 107 |       "nop \n\t \n\t "                             // (1 cycles) - Balances out the extra cycle on the other path
 108 |                   
 109 |       "NEXT_%=: \n\t"
 110 | 
 111 |       "nop \n\t nop \n\t "                          // (2 cycles) 
 112 | 
 113 |       "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
 114 |                                                     // ==========
 115 |                                                     // (9 cycles) - T1H (Phase #2 ) 9 cycles / 16Mhz = 560ns      
 116 | 
 117 |       // OK we are done sending this set of bits. Now we need a bit of space for time between bits (T1L 600ns) 
 118 | 
 119 |       "nop \n\t nop \n\t "                          // (2 cycles) 
 120 |       "nop \n\t nop \n\t "                          // (2 cycles)      
 121 |       "nop \n\t nop \n\t "                          // (2 cycles)      
 122 | 
 123 |       "nop \n\t nop \n\t "                          // (2 cycles)      
 124 |       "nop \n\t nop \n\t "                          // (2 cycles)      
 125 | 
 126 |       "ror %[bitwalker] \n\t"                      // (1 cycles) - get ready for next pass. On last pass, the bit will end up in C flag
 127 |                   
 128 |       "brcc L_%= \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 takw long enough to cover the phase 3 delay
 129 | 
 130 |                                                    // Above is at least 9 cycles including either the return + next call , or the brcc branch + cli at top
 131 |           
 132 |       ::
 133 |       [port]    "I" (_SFR_IO_ADDR(PIXEL_PORT)),
 134 |       [row]   "d" (row),
 135 |       [onBits]   "d" (onBits),
 136 |       [colorbyte]   "d" (colorbyte ),     // Phase 2 of the signal where the actual data bits show up.                
 137 |       [bitwalker] "r" (0x80)                      // Alocate a register to hold a bit that we will walk down though the color byte
 138 | 
 139 |     );
 140 |                                   
 141 |     // Note that the inter-bit gap can be as long as you want as long as it doesn't exceed the reset timeout (which is A long time)
 142 |     
 143 | } 
 144 | 
 145 | 
 146 | 
 147 | 
 148 | // Just wait long enough without sending any bits to cause the pixels to latch and display the last sent frame
 149 | 
 150 | void show() {
 151 |   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)
 152 | }
 153 | 
 154 | 
 155 | 
 156 | 
 157 | // This nice 5x7 font from here...
 158 | // http://sunge.awardspace.com/glcd-sd/node4.html
 159 | 
 160 | // Font details:
 161 | // 1) Each char is fixed 5x7 pixels. 
 162 | // 2) Each byte is one column.
 163 | // 3) Columns are left to right order, leftmost byte is leftmost column of pixels.
 164 | // 4) Each column is 8 bits high.
 165 | // 5) Bit #7 is top line of char, Bit #1 is bottom.
 166 | // 6) Bit #0 is always 0, becuase this pin is used as serial input and setting to 1 would enable the pull-up.
 167 | 
 168 | // defines ascii characters 0x20-0x7F (32-127)
 169 | // PROGMEM after variable name as per https://www.arduino.cc/en/Reference/PROGMEM
 170 | 
 171 | #define FONT_WIDTH 5      
 172 | #define INTERCHAR_SPACE 1
 173 | #define ASCII_OFFSET 0x20    // ASSCI code of 1st char in font array
 174 | 
 175 | const uint8_t fontdata[][FONT_WIDTH] PROGMEM = {
 176 |     { //  ASCII 0x20 (' ')
 177 |         0b00000000 ,
 178 |         0b00000000 ,
 179 |         0b00000000 ,
 180 |         0b00000000 ,
 181 |         0b00000000 ,
 182 |     },
 183 | 
 184 |     { //  ASCII 0x21 ('!')
 185 |         0b00000000 ,
 186 |         0b00000000 ,
 187 |         0b11111010 ,
 188 |         0b00000000 ,
 189 |         0b00000000 ,
 190 |     },
 191 | 
 192 |     { //  ASCII 0x22 ('"')
 193 |         0b00000000 ,
 194 |         0b11100000 ,
 195 |         0b00000000 ,
 196 |         0b11100000 ,
 197 |         0b00000000 ,
 198 |     },
 199 | 
 200 |     { //  ASCII 0x23 ('#')
 201 |         0b00101000 ,
 202 |         0b11111110 ,
 203 |         0b00101000 ,
 204 |         0b11111110 ,
 205 |         0b00101000 ,
 206 |     },
 207 | 
 208 |     { //  ASCII 0x24 ('$')
 209 |         0b00100100 ,
 210 |         0b01010100 ,
 211 |         0b11111110 ,
 212 |         0b01010100 ,
 213 |         0b01001000 ,
 214 |     },
 215 | 
 216 |     { //  ASCII 0x25 ('%')
 217 |         0b11000100 ,
 218 |         0b11001000 ,
 219 |         0b00010000 ,
 220 |         0b00100110 ,
 221 |         0b01000110 ,
 222 |     },
 223 | 
 224 |     { //  ASCII 0x26 ('&')
 225 |         0b01101100 ,
 226 |         0b10010010 ,
 227 |         0b10101010 ,
 228 |         0b01000100 ,
 229 |         0b00001010 ,
 230 |     },
 231 | 
 232 |     { //  ASCII 0x27 (''')
 233 |         0b00000000 ,
 234 |         0b10100000 ,
 235 |         0b11000000 ,
 236 |         0b00000000 ,
 237 |         0b00000000 ,
 238 |     },
 239 | 
 240 |     { //  ASCII 0x28 ('(')
 241 |         0b00000000 ,
 242 |         0b00111000 ,
 243 |         0b01000100 ,
 244 |         0b10000010 ,
 245 |         0b00000000 ,
 246 |     },
 247 | 
 248 |     { //  ASCII 0x29 (')')
 249 |         0b00000000 ,
 250 |         0b10000010 ,
 251 |         0b01000100 ,
 252 |         0b00111000 ,
 253 |         0b00000000 ,
 254 |     },
 255 | 
 256 |     { //  ASCII 0x2a ('*')
 257 |         0b00010000 ,
 258 |         0b01010100 ,
 259 |         0b00111000 ,
 260 |         0b01010100 ,
 261 |         0b00010000 ,
 262 |     },
 263 | 
 264 |     { //  ASCII 0x2b ('+')
 265 |         0b00010000 ,
 266 |         0b00010000 ,
 267 |         0b01111100 ,
 268 |         0b00010000 ,
 269 |         0b00010000 ,
 270 |     },
 271 | 
 272 |     { //  ASCII 0x2c (',')
 273 |         0b00000000 ,
 274 |         0b00001010 ,
 275 |         0b00001100 ,
 276 |         0b00000000 ,
 277 |         0b00000000 ,
 278 |     },
 279 | 
 280 |     { //  ASCII 0x2d ('-')
 281 |         0b00010000 ,
 282 |         0b00010000 ,
 283 |         0b00010000 ,
 284 |         0b00010000 ,
 285 |         0b00010000 ,
 286 |     },
 287 | 
 288 |     { //  ASCII 0x2e ('.')
 289 |         0b00000000 ,
 290 |         0b00000110 ,
 291 |         0b00000110 ,
 292 |         0b00000000 ,
 293 |         0b00000000 ,
 294 |     },
 295 | 
 296 |     { //  ASCII 0x2f ('/')
 297 |         0b00000100 ,
 298 |         0b00001000 ,
 299 |         0b00010000 ,
 300 |         0b00100000 ,
 301 |         0b01000000 ,
 302 |     },
 303 | 
 304 |     { //  ASCII 0x30 ('0')
 305 |         0b01111100 ,
 306 |         0b10001010 ,
 307 |         0b10010010 ,
 308 |         0b10100010 ,
 309 |         0b01111100 ,
 310 |     },
 311 | 
 312 |     { //  ASCII 0x31 ('1')
 313 |         0b00000000 ,
 314 |         0b01000010 ,
 315 |         0b11111110 ,
 316 |         0b00000010 ,
 317 |         0b00000000 ,
 318 |     },
 319 | 
 320 |     { //  ASCII 0x32 ('2')
 321 |         0b01000010 ,
 322 |         0b10000110 ,
 323 |         0b10001010 ,
 324 |         0b10010010 ,
 325 |         0b01100010 ,
 326 |     },
 327 | 
 328 |     { //  ASCII 0x33 ('3')
 329 |         0b10000100 ,
 330 |         0b10000010 ,
 331 |         0b10100010 ,
 332 |         0b11010010 ,
 333 |         0b10001100 ,
 334 |     },
 335 | 
 336 |     { //  ASCII 0x34 ('4')
 337 |         0b00011000 ,
 338 |         0b00101000 ,
 339 |         0b01001000 ,
 340 |         0b11111110 ,
 341 |         0b00001000 ,
 342 |     },
 343 | 
 344 |     { //  ASCII 0x35 ('5')
 345 |         0b11100100 ,
 346 |         0b10100010 ,
 347 |         0b10100010 ,
 348 |         0b10100010 ,
 349 |         0b10011100 ,
 350 |     },
 351 | 
 352 |     { //  ASCII 0x36 ('6')
 353 |         0b00111100 ,
 354 |         0b01010010 ,
 355 |         0b10010010 ,
 356 |         0b10010010 ,
 357 |         0b00001100 ,
 358 |     },
 359 | 
 360 |     { //  ASCII 0x37 ('7')
 361 |         0b10000000 ,
 362 |         0b10001110 ,
 363 |         0b10010000 ,
 364 |         0b10100000 ,
 365 |         0b11000000 ,
 366 |     },
 367 | 
 368 |     { //  ASCII 0x38 ('8')
 369 |         0b01101100 ,
 370 |         0b10010010 ,
 371 |         0b10010010 ,
 372 |         0b10010010 ,
 373 |         0b01101100 ,
 374 |     },
 375 | 
 376 |     { //  ASCII 0x39 ('9')
 377 |         0b01100000 ,
 378 |         0b10010010 ,
 379 |         0b10010010 ,
 380 |         0b10010100 ,
 381 |         0b01111000 ,
 382 |     },
 383 | 
 384 |     { //  ASCII 0x3a (':')
 385 |         0b00000000 ,
 386 |         0b01101100 ,
 387 |         0b01101100 ,
 388 |         0b00000000 ,
 389 |         0b00000000 ,
 390 |     },
 391 | 
 392 |     { //  ASCII 0x3b (';')
 393 |         0b00000000 ,
 394 |         0b01101010 ,
 395 |         0b01101100 ,
 396 |         0b00000000 ,
 397 |         0b00000000 ,
 398 |     },
 399 | 
 400 |     { //  ASCII 0x3c ('<')
 401 |         0b00000000 ,
 402 |         0b00010000 ,
 403 |         0b00101000 ,
 404 |         0b01000100 ,
 405 |         0b10000010 ,
 406 |     },
 407 | 
 408 |     { //  ASCII 0x3d ('=')
 409 |         0b00101000 ,
 410 |         0b00101000 ,
 411 |         0b00101000 ,
 412 |         0b00101000 ,
 413 |         0b00101000 ,
 414 |     },
 415 | 
 416 |     { //  ASCII 0x3e ('>')
 417 |         0b10000010 ,
 418 |         0b01000100 ,
 419 |         0b00101000 ,
 420 |         0b00010000 ,
 421 |         0b00000000 ,
 422 |     },
 423 | 
 424 |     { //  ASCII 0x3f ('?')
 425 |         0b01000000 ,
 426 |         0b10000000 ,
 427 |         0b10001010 ,
 428 |         0b10010000 ,
 429 |         0b01100000 ,
 430 |     },
 431 | 
 432 |     { //  ASCII 0x40 ('@')
 433 |         0b01001100 ,
 434 |         0b10010010 ,
 435 |         0b10011110 ,
 436 |         0b10000010 ,
 437 |         0b01111100 ,
 438 |     },
 439 | 
 440 |     { //  ASCII 0x41 ('A')
 441 |         0b01111110 ,
 442 |         0b10001000 ,
 443 |         0b10001000 ,
 444 |         0b10001000 ,
 445 |         0b01111110 ,
 446 |     },
 447 | 
 448 |     { //  ASCII 0x42 ('B')
 449 |         0b11111110 ,
 450 |         0b10010010 ,
 451 |         0b10010010 ,
 452 |         0b10010010 ,
 453 |         0b01101100 ,
 454 |     },
 455 | 
 456 |     { //  ASCII 0x43 ('C')
 457 |         0b01111100 ,
 458 |         0b10000010 ,
 459 |         0b10000010 ,
 460 |         0b10000010 ,
 461 |         0b01000100 ,
 462 |     },
 463 | 
 464 |     { //  ASCII 0x44 ('D')
 465 |         0b11111110 ,
 466 |         0b10000010 ,
 467 |         0b10000010 ,
 468 |         0b01000100 ,
 469 |         0b00111000 ,
 470 |     },
 471 | 
 472 |     { //  ASCII 0x45 ('E')
 473 |         0b11111110 ,
 474 |         0b10010010 ,
 475 |         0b10010010 ,
 476 |         0b10010010 ,
 477 |         0b10000010 ,
 478 |     },
 479 | 
 480 |     { //  ASCII 0x46 ('F')
 481 |         0b11111110 ,
 482 |         0b10010000 ,
 483 |         0b10010000 ,
 484 |         0b10000000 ,
 485 |         0b10000000 ,
 486 |     },
 487 | 
 488 |     { //  ASCII 0x47 ('G')
 489 |         0b01111100 ,
 490 |         0b10000010 ,
 491 |         0b10000010 ,
 492 |         0b10001010 ,
 493 |         0b01001100 ,
 494 |     },
 495 | 
 496 |     { //  ASCII 0x48 ('H')
 497 |         0b11111110 ,
 498 |         0b00010000 ,
 499 |         0b00010000 ,
 500 |         0b00010000 ,
 501 |         0b11111110 ,
 502 |     },
 503 | 
 504 |     { //  ASCII 0x49 ('I')
 505 |         0b00000000 ,
 506 |         0b10000010 ,
 507 |         0b11111110 ,
 508 |         0b10000010 ,
 509 |         0b00000000 ,
 510 |     },
 511 | 
 512 |     { //  ASCII 0x4a ('J')
 513 |         0b00000100 ,
 514 |         0b00000010 ,
 515 |         0b10000010 ,
 516 |         0b11111100 ,
 517 |         0b10000000 ,
 518 |     },
 519 | 
 520 |     { //  ASCII 0x4b ('K')
 521 |         0b11111110 ,
 522 |         0b00010000 ,
 523 |         0b00101000 ,
 524 |         0b01000100 ,
 525 |         0b10000010 ,
 526 |     },
 527 | 
 528 |     { //  ASCII 0x4c ('L')
 529 |         0b11111110 ,
 530 |         0b00000010 ,
 531 |         0b00000010 ,
 532 |         0b00000010 ,
 533 |         0b00000010 ,
 534 |     },
 535 | 
 536 |     { //  ASCII 0x4d ('M')
 537 |         0b11111110 ,
 538 |         0b01000000 ,
 539 |         0b00100000 ,
 540 |         0b01000000 ,
 541 |         0b11111110 ,
 542 |     },
 543 | 
 544 |     { //  ASCII 0x4e ('N')
 545 |         0b11111110 ,
 546 |         0b00100000 ,
 547 |         0b00010000 ,
 548 |         0b00001000 ,
 549 |         0b11111110 ,
 550 |     },
 551 | 
 552 |     { //  ASCII 0x4f ('O')
 553 |         0b01111100 ,
 554 |         0b10000010 ,
 555 |         0b10000010 ,
 556 |         0b10000010 ,
 557 |         0b01111100 ,
 558 |     },
 559 | 
 560 |     { //  ASCII 0x50 ('P')
 561 |         0b11111110 ,
 562 |         0b10010000 ,
 563 |         0b10010000 ,
 564 |         0b10010000 ,
 565 |         0b01100000 ,
 566 |     },
 567 | 
 568 |     { //  ASCII 0x51 ('Q')
 569 |         0b01111100 ,
 570 |         0b10000010 ,
 571 |         0b10001010 ,
 572 |         0b10000100 ,
 573 |         0b01111010 ,
 574 |     },
 575 | 
 576 |     { //  ASCII 0x52 ('R')
 577 |         0b11111110 ,
 578 |         0b10010000 ,
 579 |         0b10011000 ,
 580 |         0b10010100 ,
 581 |         0b01100010 ,
 582 |     },
 583 | 
 584 |     { //  ASCII 0x53 ('S')
 585 |         0b01100010 ,
 586 |         0b10010010 ,
 587 |         0b10010010 ,
 588 |         0b10010010 ,
 589 |         0b10001100 ,
 590 |     },
 591 | 
 592 |     { //  ASCII 0x54 ('T')
 593 |         0b10000000 ,
 594 |         0b10000000 ,
 595 |         0b11111110 ,
 596 |         0b10000000 ,
 597 |         0b10000000 ,
 598 |     },
 599 | 
 600 |     { //  ASCII 0x55 ('U')
 601 |         0b11111100 ,
 602 |         0b00000010 ,
 603 |         0b00000010 ,
 604 |         0b00000010 ,
 605 |         0b11111100 ,
 606 |     },
 607 | 
 608 |     { //  ASCII 0x56 ('V')
 609 |         0b11111000 ,
 610 |         0b00000100 ,
 611 |         0b00000010 ,
 612 |         0b00000100 ,
 613 |         0b11111000 ,
 614 |     },
 615 | 
 616 |     { //  ASCII 0x57 ('W')
 617 |         0b11111110 ,
 618 |         0b00000100 ,
 619 |         0b00011000 ,
 620 |         0b00000100 ,
 621 |         0b11111110 ,
 622 |     },
 623 | 
 624 |     { //  ASCII 0x58 ('X')
 625 |         0b11000110 ,
 626 |         0b00101000 ,
 627 |         0b00010000 ,
 628 |         0b00101000 ,
 629 |         0b11000110 ,
 630 |     },
 631 | 
 632 |     { //  ASCII 0x59 ('Y')
 633 |         0b11000000 ,
 634 |         0b00100000 ,
 635 |         0b00011110 ,
 636 |         0b00100000 ,
 637 |         0b11000000 ,
 638 |     },
 639 | 
 640 |     { //  ASCII 0x5a ('Z')
 641 |         0b10000110 ,
 642 |         0b10001010 ,
 643 |         0b10010010 ,
 644 |         0b10100010 ,
 645 |         0b11000010 ,
 646 |     },
 647 | 
 648 |     { //  ASCII 0x5b ('[')
 649 |         0b00000000 ,
 650 |         0b00000000 ,
 651 |         0b11111110 ,
 652 |         0b10000010 ,
 653 |         0b10000010 ,
 654 |     },
 655 | 
 656 |     { //  ASCII 0x5c ('\')
 657 |         0b01000000 ,
 658 |         0b00100000 ,
 659 |         0b00010000 ,
 660 |         0b00001000 ,
 661 |         0b00000100 ,
 662 |     },
 663 | 
 664 |     { //  ASCII 0x5d (']')
 665 |         0b10000010 ,
 666 |         0b10000010 ,
 667 |         0b11111110 ,
 668 |         0b00000000 ,
 669 |         0b00000000 ,
 670 |     },
 671 | 
 672 |     { //  ASCII 0x5e ('^')
 673 |         0b00100000 ,
 674 |         0b01000000 ,
 675 |         0b10000000 ,
 676 |         0b01000000 ,
 677 |         0b00100000 ,
 678 |     },
 679 | 
 680 |     { //  ASCII 0x5f ('_')
 681 |         0b00000010 ,
 682 |         0b00000010 ,
 683 |         0b00000010 ,
 684 |         0b00000010 ,
 685 |         0b00000010 ,
 686 |     },
 687 | 
 688 |     { //  ASCII 0x60 ('`')
 689 |         0b00000000 ,
 690 |         0b10000000 ,
 691 |         0b01000000 ,
 692 |         0b00100000 ,
 693 |         0b00000000 ,
 694 |     },
 695 | 
 696 |     { //  ASCII 0x61 ('a')
 697 |         0b00000100 ,
 698 |         0b00101010 ,
 699 |         0b00101010 ,
 700 |         0b00101010 ,
 701 |         0b00011110 ,
 702 |     },
 703 | 
 704 |     { //  ASCII 0x62 ('b')
 705 |         0b11111110 ,
 706 |         0b00010010 ,
 707 |         0b00100010 ,
 708 |         0b00100010 ,
 709 |         0b00011100 ,
 710 |     },
 711 | 
 712 |     { //  ASCII 0x63 ('c')
 713 |         0b00011100 ,
 714 |         0b00100010 ,
 715 |         0b00100010 ,
 716 |         0b00100010 ,
 717 |         0b00000100 ,
 718 |     },
 719 | 
 720 |     { //  ASCII 0x64 ('d')
 721 |         0b00011100 ,
 722 |         0b00100010 ,
 723 |         0b00100010 ,
 724 |         0b00010010 ,
 725 |         0b11111110 ,
 726 |     },
 727 | 
 728 |     { //  ASCII 0x65 ('e')
 729 |         0b00011100 ,
 730 |         0b00101010 ,
 731 |         0b00101010 ,
 732 |         0b00101010 ,
 733 |         0b00011000 ,
 734 |     },
 735 | 
 736 |     { //  ASCII 0x66 ('f')
 737 |         0b00010000 ,
 738 |         0b01111110 ,
 739 |         0b10010000 ,
 740 |         0b10000000 ,
 741 |         0b01000000 ,
 742 |     },
 743 | 
 744 |     { //  ASCII 0x67 ('g')
 745 |         0b00010000 ,
 746 |         0b00101000 ,
 747 |         0b00101010 ,
 748 |         0b00101010 ,
 749 |         0b00111100 ,
 750 |     },
 751 | 
 752 |     { //  ASCII 0x68 ('h')
 753 |         0b11111110 ,
 754 |         0b00010000 ,
 755 |         0b00100000 ,
 756 |         0b00100000 ,
 757 |         0b00011110 ,
 758 |     },
 759 | 
 760 |     { //  ASCII 0x69 ('i')
 761 |         0b00000000 ,
 762 |         0b00100010 ,
 763 |         0b10111110 ,
 764 |         0b00000010 ,
 765 |         0b00000000 ,
 766 |     },
 767 | 
 768 |     { //  ASCII 0x6a ('j')
 769 |         0b00000100 ,
 770 |         0b00000010 ,
 771 |         0b00100010 ,
 772 |         0b10111100 ,
 773 |         0b00000000 ,
 774 |     },
 775 | 
 776 |     { //  ASCII 0x6b ('k')
 777 |         0b00000000 ,
 778 |         0b11111110 ,
 779 |         0b00001000 ,
 780 |         0b00010100 ,
 781 |         0b00100010 ,
 782 |     },
 783 | 
 784 |     { //  ASCII 0x6c ('l')
 785 |         0b00000000 ,
 786 |         0b10000010 ,
 787 |         0b11111110 ,
 788 |         0b00000010 ,
 789 |         0b00000000 ,
 790 |     },
 791 | 
 792 |     { //  ASCII 0x6d ('m')
 793 |         0b00111110 ,
 794 |         0b00100000 ,
 795 |         0b00011000 ,
 796 |         0b00100000 ,
 797 |         0b00011110 ,
 798 |     },
 799 | 
 800 |     { //  ASCII 0x6e ('n')
 801 |         0b00111110 ,
 802 |         0b00010000 ,
 803 |         0b00100000 ,
 804 |         0b00100000 ,
 805 |         0b00011110 ,
 806 |     },
 807 | 
 808 |     { //  ASCII 0x6f ('o')
 809 |         0b00011100 ,
 810 |         0b00100010 ,
 811 |         0b00100010 ,
 812 |         0b00100010 ,
 813 |         0b00011100 ,
 814 |     },
 815 | 
 816 |     { //  ASCII 0x70 ('p')
 817 |         0b00111110 ,
 818 |         0b00101000 ,
 819 |         0b00101000 ,
 820 |         0b00101000 ,
 821 |         0b00010000 ,
 822 |     },
 823 | 
 824 |     { //  ASCII 0x71 ('q')
 825 |         0b00010000 ,
 826 |         0b00101000 ,
 827 |         0b00101000 ,
 828 |         0b00011000 ,
 829 |         0b00111110 ,
 830 |     },
 831 | 
 832 |     { //  ASCII 0x72 ('r')
 833 |         0b00111110 ,
 834 |         0b00010000 ,
 835 |         0b00100000 ,
 836 |         0b00100000 ,
 837 |         0b00010000 ,
 838 |     },
 839 | 
 840 |     { //  ASCII 0x73 ('s')
 841 |         0b00010010 ,
 842 |         0b00101010 ,
 843 |         0b00101010 ,
 844 |         0b00101010 ,
 845 |         0b00000100 ,
 846 |     },
 847 | 
 848 |     { //  ASCII 0x74 ('t')
 849 |         0b00100000 ,
 850 |         0b11111100 ,
 851 |         0b00100010 ,
 852 |         0b00000010 ,
 853 |         0b00000100 ,
 854 |     },
 855 | 
 856 |     { //  ASCII 0x75 ('u')
 857 |         0b00111100 ,
 858 |         0b00000010 ,
 859 |         0b00000010 ,
 860 |         0b00000100 ,
 861 |         0b00111110 ,
 862 |     },
 863 | 
 864 |     { //  ASCII 0x76 ('v')
 865 |         0b00111000 ,
 866 |         0b00000100 ,
 867 |         0b00000010 ,
 868 |         0b00000100 ,
 869 |         0b00111000 ,
 870 |     },
 871 | 
 872 |     { //  ASCII 0x77 ('w')
 873 |         0b00111100 ,
 874 |         0b00000010 ,
 875 |         0b00001100 ,
 876 |         0b00000010 ,
 877 |         0b00111100 ,
 878 |     },
 879 | 
 880 |     { //  ASCII 0x78 ('x')
 881 |         0b00100010 ,
 882 |         0b00010100 ,
 883 |         0b00001000 ,
 884 |         0b00010100 ,
 885 |         0b00100010 ,
 886 |     },
 887 | 
 888 |     { //  ASCII 0x79 ('y')
 889 |         0b00110000 ,
 890 |         0b00001010 ,
 891 |         0b00001010 ,
 892 |         0b00001010 ,
 893 |         0b00111100 ,
 894 |     },
 895 | 
 896 |     { //  ASCII 0x7a ('z')
 897 |         0b00100010 ,
 898 |         0b00100110 ,
 899 |         0b00101010 ,
 900 |         0b00110010 ,
 901 |         0b00100010 ,
 902 |     },
 903 | 
 904 |     { //  ASCII 0x7b ('{')
 905 |         0b00000000 ,
 906 |         0b00010000 ,
 907 |         0b01101100 ,
 908 |         0b10000010 ,
 909 |         0b00000000 ,
 910 |     },
 911 | 
 912 |     { //  ASCII 0x7c ('|')
 913 |         0b00000000 ,
 914 |         0b00000000 ,
 915 |         0b11111110 ,
 916 |         0b00000000 ,
 917 |         0b00000000 ,
 918 |     },
 919 | 
 920 |     { //  ASCII 0x7d ('}')
 921 |         0b00000000 ,
 922 |         0b10000010 ,
 923 |         0b01101100 ,
 924 |         0b00010000 ,
 925 |         0b00000000 ,
 926 |     },
 927 | 
 928 |     { //  ASCII 0x7e ('~')
 929 |         0b00010000 ,
 930 |         0b00010000 ,
 931 |         0b01010100 ,
 932 |         0b00111000 ,
 933 |         0b00010000 ,
 934 |     },
 935 | 
 936 |     { //  ASCII 0x7f
 937 |         0b00010000 ,
 938 |         0b00111000 ,
 939 |         0b01010100 ,
 940 |         0b00010000 ,
 941 |         0b00010000 ,
 942 |     },
 943 | };
 944 | 
 945 | 
 946 | struct colorState_t {
 947 |   uint8_t r;
 948 |   uint8_t g;
 949 |   uint8_t b;
 950 | };
 951 | 
 952 | struct displayState_t {
 953 |   colorState_t colorState;
 954 |   
 955 | };
 956 | 
 957 | // Current display state with default values. 
 958 | 
 959 | displayState_t displayState = {
 960 |   { 0x00 , 0x40 , 0x00 } ,        // nice blue
 961 |   
 962 | };
 963 | 
 964 | 
 965 | // Send 3 bytes of color data (R,G,B) for a signle pixel down all the connected stringsat the same time
 966 | // A 1 bit in "row" means send the color, a 0 bit means send black. 
 967 | 
 968 | static inline void sendCol( uint8_t colBits  ) {
 969 | 
 970 |   sendBitx8( colBits , displayState.colorState.g , onBits);    // WS2812 takes colors in GRB order
 971 |   sendBitx8( colBits , displayState.colorState.r , onBits);    // WS2812 takes colors in GRB order
 972 |   sendBitx8( colBits , displayState.colorState.b , onBits);    // WS2812 takes colors in GRB order
 973 |   
 974 | }
 975 | 
 976 | 
 977 | 
 978 | uint8_t parsehexdigit( const char c ) {
 979 |   if ( isdigit(c) ) return c-'0';
 980 |   if ( isxdigit(c) ) return toupper(c)-'A';
 981 |   return 0; // Sensible error value  
 982 | }
 983 | 
 984 | 
 985 | uint8_t parse2hexdigits( const char *s ) {
 986 |   return (parsehexdigit( s[0] ) << 4 ) + parsehexdigit( s[1] );
 987 | }
 988 | 
 989 | // Size of array from https://stackoverflow.com/a/18078435/3152071
 990 | template<class T, size_t N>
 991 | constexpr size_t size(T (&)[N]) { return N; }
 992 | 
 993 | 
 994 | // Show the passed string starting at the requested pixel column of the string in the rightmost col of the LED display.
 995 | // So if you draw a string with start_col=0, then the first col of the first letter will be in the rightmost col of the display
 996 | // and the rest will be blank. 
 997 | 
 998 | // To show the string starting at the leftmost col of the display, use drawString( s , PIXEL_COUNT );
 999 | 
1000 | void drawString( const char *s , int start_col ) {
1001 | 
1002 |   unsigned int l=PIXEL_COUNT; // L is the col we are currently sending to the LEDs. Note we do not start sending to the LEDs until we get to start_col 
1003 | 
1004 |   int col = 0;       // col we are at in the input string 
1005 | 
1006 |   while (l && start_col < 0) {
1007 |     sendCol( 0  );    
1008 |     start_col++;
1009 |     l--;
1010 |   }
1011 |  
1012 |   while (l) {   // We need to fill all pixels so keep going until l == 0, then we have filled the LEDs
1013 |    
1014 |     if (*s) {   // Still any chars left to show? Work our way though col, only sending to LEDs when col > startcol 
1015 | 
1016 |       uint8_t c = *s;
1017 | 
1018 |       s++;
1019 |             
1020 |       if ( c == '#' && isxdigit( s[0] ) && isxdigit( s[1] ) && isxdigit( s[2] )&& isxdigit( s[3] ) && isxdigit( s[4]) && isxdigit( s[5] ) ) {   // Color set command has format #rrggbb with values in 2 digit hex
1021 | 
1022 |         // Note that the isxdigit() check above will not match a 0x00 so will keep us form overrunning past the end of the string buffer
1023 |         
1024 |         displayState.colorState.r = parse2hexdigits( s );
1025 |         s+=2;
1026 |         displayState.colorState.g = parse2hexdigits( s );
1027 |         s+=2;
1028 |         displayState.colorState.b = parse2hexdigits( s );
1029 |         s+=2;
1030 | 
1031 |         c=0x00;   // Do not display anything on the actual LEDs.         
1032 |         
1033 |       }
1034 | 
1035 |        if (c) {
1036 | 
1037 |         if ( c  >= ASCII_OFFSET && c <= (ASCII_OFFSET + size( fontdata )) ) {   // Check that we have a font entry for this char
1038 |   
1039 |           const uint8_t *charbase = fontdata[ c - ASCII_OFFSET ];    // The font pixels for the current char
1040 |   
1041 |           uint8_t c_col = 0;  // What col are we at in the char
1042 |           
1043 |   
1044 |           while ( l && (c_col < FONT_WIDTH) ) {
1045 |   
1046 |               if ( col >= start_col ) {
1047 |                 sendCol( pgm_read_byte_near( charbase + c_col ) );
1048 |                 l--;                          
1049 |               }
1050 |               col++;
1051 |               c_col++;
1052 |           }      
1053 |   
1054 |           while ( l && ( c_col < (FONT_WIDTH + INTERCHAR_SPACE) ) ) {
1055 |   
1056 |               if ( col >= start_col ) {          
1057 |                 sendCol( 0  );    // Interchar space
1058 |                 l--;              
1059 |               }
1060 |               col++;
1061 |               c_col++;
1062 |           }
1063 |   
1064 |         }
1065 |         
1066 |       }
1067 |       
1068 | 
1069 |     } else {
1070 | 
1071 |       // This fills out the rest of the LEDs with off pixels if the string was too short
1072 |       // This is neesisary becuase (1) it keeps send time aprox consistant regardless of string, and 
1073 |       // (2) some WS2813 LEDs freak out if you do not seen a full data stream each time. 
1074 | 
1075 |       sendCol( 0  );    // Interchar space
1076 |       l--;
1077 |       
1078 |     }
1079 | 
1080 |     
1081 |   }
1082 | 
1083 |   show();
1084 |   
1085 | }
1086 | 
1087 | void scrollString( const char *s ) {
1088 | 
1089 |   const int pixel_len = strlen( s ) * (FONT_WIDTH+INTERCHAR_SPACE);     // Length of the string in pixels. Note this must be signed to allow the compare in the line below. 
1090 | 
1091 |   for( int step= -1 * pixel_len ; step<  pixel_len ; step++ ) {   // step though each column of the 1st char for smooth scrolling
1092 | 
1093 |     drawString( s , step  );    // Nice and not-too-bright blue hue         
1094 |     delay(10);
1095 |      
1096 |   }
1097 |   
1098 | }
1099 |         
1100 | 
1101 | 
1102 | void setup() {
1103 |   PIXEL_DDR |= onBits;         // Set used pins to output mode
1104 | 
1105 |   // This eems to reset some stuck pixels and leaves all outputs cleanly low
1106 |   PIXEL_PORT |= onBits;       // Set all outputs to 1
1107 |   delay( 100);
1108 |   PIXEL_PORT &= ~onBits;       // Set all outputs to 0
1109 |   delay( 100);
1110 | 
1111 |   //Serial.begin(9600);
1112 |   
1113 | }
1114 | 
1115 | static char jabberText[] = 
1116 |       "                                       " 
1117 |       "Twas brillig, and the slithy toves "
1118 |             "Did gyre and gimble in the wabe: "
1119 |       "All mimsy were the borogoves, "
1120 |             "And the mome raths outgrabe. "
1121 |       
1122 |       "Beware the Jabberwock, my son! "
1123 |             "The jaws that bite, the claws that catch! "
1124 |       "Beware the Jubjub bird, and shun "      
1125 |             "The frumious Bandersnatch! "
1126 |       
1127 |       "He took his vorpal sword in hand; "
1128 |             "Long time the manxome foe he sought- "
1129 |       "So rested he by the Tumtum tree "
1130 |             "And stood awhile in thought. "
1131 |       
1132 |       "And, as in uffish thought he stood, "
1133 |             "The Jabberwock, with eyes of flame, "
1134 |       "Came whiffling through the tulgey wood, "      
1135 |             "And burbled as it came! "
1136 |       
1137 |       "One, two! One, two! And through and through "
1138 |             "The vorpal blade went snicker-snack! "
1139 |       "He left it dead, and with its head "
1140 |             "He went galumphing back. "
1141 |       
1142 |       "And hast thou slain the Jabberwock? "
1143 |             "Come to my arms, my beamish boy! "
1144 |       "O frabjous day! Callooh! Callay! "
1145 |             "He chortled in his joy. "
1146 |       
1147 |       "Twas brillig, and the slithy toves "
1148 |             "Did gyre and gimble in the wabe: "
1149 |       "All mimsy were the borogoves, "
1150 |             "And the mome raths outgrabe."  
1151 |       
1152 |       ;
1153 | 
1154 | 
1155 | void loop() {
1156 | 
1157 |   //sendString( "josh is very nice and I like him." , 0 , 0x00, 0x00 , 0x42 );    // Nice and not-too-bright blue hue         
1158 | 
1159 |   int x=-10;
1160 |   
1161 |   while (1) {
1162 |     scrollString(  "josh is #440000very#000040 nice and I like him." );
1163 |     drawString( "1234567890." , x  );
1164 |     x++;
1165 |     delay(1000);
1166 |   }
1167 |   while (1); 
1168 |   scrollString( jabberText );
1169 | 
1170 | }
1171 | 


--------------------------------------------------------------------------------