├── README.md ├── examples ├── Demo │ └── Demo.ino ├── Scrolling │ └── Scrolling.ino ├── Smooth_Scrolling │ └── Smooth_Scrolling.ino └── cp437_fonts.png ├── keywords.txt ├── library.properties └── src ├── MAX7219_Dot_Matrix.cpp ├── MAX7219_Dot_Matrix.h └── MAX7219_Dot_Matrix_font.h /README.md: -------------------------------------------------------------------------------- 1 | MAX7219\_Dot\_Matrix 2 | ==================== 3 | 4 | Arduino library for MAX7219 display using SPI. 5 | 6 | For use with 8x8 LED dot-matrix displays. 7 | 8 | 9 | For details about the theory, wiring, schematic, etc. see: 10 | 11 | [Read more](http://www.gammon.com.au/forum/?id=11516) 12 | 13 | 14 | The bit-banged SPI library used in this library can be found at: 15 | 16 | [bitBangedSPI](https://github.com/nickgammon/bitBangedSPI) 17 | -------------------------------------------------------------------------------- /examples/Demo/Demo.ino: -------------------------------------------------------------------------------- 1 | // Demo of MAX7219_Dot_Matrix library 2 | // Author: Nick Gammon 3 | // Date: 13 May 2015 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | MAX7219_Dot_Matrix myDisplay (8, 10); // 8 chips, and then specify the LOAD pin only 10 | 11 | void setup () 12 | { 13 | myDisplay.begin (); 14 | myDisplay.setIntensity (15); 15 | myDisplay.sendString ("Hello there"); 16 | } // end of setup 17 | 18 | void loop () 19 | { 20 | // do whatever here 21 | } // end of loop 22 | 23 | -------------------------------------------------------------------------------- /examples/Scrolling/Scrolling.ino: -------------------------------------------------------------------------------- 1 | // Demo of MAX7219_Dot_Matrix library - sideways scrolling 2 | // Author: Nick Gammon 3 | // Date: 13 May 2015 4 | 5 | // Note: This does not scroll a pixel at a time, but rather a character (8 pixels) 6 | // Doing a pixel would be more complex (you would need to build up a bitmap 7 | // in memory. If memory is tight you may not want to do that. 8 | // If you really want smooth scrolling I'm sure you can make it work. :) 9 | 10 | #include 11 | #include 12 | #include 13 | 14 | const byte chips = 8; 15 | 16 | // 8 chips, SPI with load on D10 17 | MAX7219_Dot_Matrix display (chips, 10); // Chips / LOAD 18 | 19 | const char message [] = "Hello there - testing 123456789 "; 20 | 21 | void setup () 22 | { 23 | display.begin (); 24 | } // end of setup 25 | 26 | unsigned long lastMoved = 0; 27 | unsigned long MOVE_INTERVAL = 500; // mS 28 | unsigned int messageOffset; 29 | 30 | void updateDisplay () 31 | { 32 | display.sendString (& message [messageOffset]); 33 | 34 | // next time show one character on 35 | if (messageOffset++ >= strlen (message)) 36 | messageOffset = 0; 37 | } // end of updateDisplay 38 | 39 | void loop () 40 | { 41 | 42 | // update display if time is up 43 | if (millis () - lastMoved >= MOVE_INTERVAL) 44 | { 45 | updateDisplay (); 46 | lastMoved = millis (); 47 | } 48 | 49 | // do other stuff here 50 | 51 | } // end of loop 52 | 53 | -------------------------------------------------------------------------------- /examples/Smooth_Scrolling/Smooth_Scrolling.ino: -------------------------------------------------------------------------------- 1 | // Demo of MAX7219_Dot_Matrix library - sideways scrolling 2 | // Author: Nick Gammon 3 | // Date: 2 October 2015 4 | 5 | // Scrolls a pixel at a time. 6 | 7 | #include 8 | #include 9 | #include 10 | const byte chips = 12; 11 | 12 | // 12 chips (display modules), hardware SPI with load on D10 13 | MAX7219_Dot_Matrix display (chips, 10); // Chips / LOAD 14 | 15 | const char message [] = "Testing 1234567890"; 16 | 17 | void setup () 18 | { 19 | display.begin (); 20 | } // end of setup 21 | 22 | unsigned long lastMoved = 0; 23 | unsigned long MOVE_INTERVAL = 20; // mS 24 | int messageOffset; 25 | 26 | void updateDisplay () 27 | { 28 | display.sendSmooth (message, messageOffset); 29 | 30 | // next time show one pixel onwards 31 | if (messageOffset++ >= (int) (strlen (message) * 8)) 32 | messageOffset = - chips * 8; 33 | } // end of updateDisplay 34 | 35 | void loop () 36 | { 37 | 38 | // update display if time is up 39 | if (millis () - lastMoved >= MOVE_INTERVAL) 40 | { 41 | updateDisplay (); 42 | lastMoved = millis (); 43 | } 44 | 45 | // do other stuff here 46 | 47 | } // end of loop 48 | 49 | -------------------------------------------------------------------------------- /examples/cp437_fonts.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nickgammon/MAX7219_Dot_Matrix/1210f235ba8349ac913414f7b2668d60c4adfe57/examples/cp437_fonts.png -------------------------------------------------------------------------------- /keywords.txt: -------------------------------------------------------------------------------- 1 | ####################################### 2 | # Syntax Coloring Map For MAX7219_Dot_Matrix 3 | ####################################### 4 | 5 | ####################################### 6 | # Datatypes (KEYWORD1) 7 | ####################################### 8 | 9 | MAX7219_Dot_Matrix KEYWORD1 10 | 11 | ####################################### 12 | # Methods and Functions (KEYWORD2) 13 | ####################################### 14 | 15 | MAX7219_REG_SCANLIMIT KEYWORD2 16 | MAX7219_REG_DECODEMODE KEYWORD2 17 | MAX7219_REG_DISPLAYTEST KEYWORD2 18 | MAX7219_REG_INTENSITY KEYWORD2 19 | MAX7219_REG_SHUTDOWN KEYWORD2 20 | 21 | 22 | ####################################### 23 | # Instances (KEYWORD2) 24 | ####################################### 25 | 26 | ####################################### 27 | # Constants (LITERAL1) 28 | ####################################### 29 | 30 | 31 | -------------------------------------------------------------------------------- /library.properties: -------------------------------------------------------------------------------- 1 | name=MAX7219_Dot_Matrix 2 | version=1.0.1 3 | author=Nick Gammon 4 | maintainer=Nick Gammon 5 | sentence=Arduino library for MAX7219 display chip used with 8x8 LED dot-matrix display. 6 | paragraph=MAX7219 display using SPI. 7 | category=Display 8 | url=http://www.gammon.com.au/forum/?id=11516 9 | architectures=avr 10 | includes=MAX7219_Dot_Matrix.h, bitBangedSPI.h -------------------------------------------------------------------------------- /src/MAX7219_Dot_Matrix.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | MAX7219_Dot_Matrix class 4 | Author: Nick Gammon 5 | Date: 13 May 2015 6 | 7 | 8 | PERMISSION TO DISTRIBUTE 9 | 10 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software 11 | and associated documentation files (the "Software"), to deal in the Software without restriction, 12 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, 13 | and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, 14 | subject to the following conditions: 15 | 16 | The above copyright notice and this permission notice shall be included in 17 | all copies or substantial portions of the Software. 18 | 19 | 20 | LIMITATION OF LIABILITY 21 | 22 | The software is provided "as is", without warranty of any kind, express or implied, 23 | including but not limited to the warranties of merchantability, fitness for a particular 24 | purpose and noninfringement. In no event shall the authors or copyright holders be liable 25 | for any claim, damages or other liability, whether in an action of contract, 26 | tort or otherwise, arising from, out of or in connection with the software 27 | or the use or other dealings in the software. 28 | 29 | */ 30 | 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | /* 37 | 38 | Wiring: 39 | 40 | Hardware SPI: 41 | 42 | Wire DIN (data) to the MOSI pin (D11 on a Uno) 43 | Wire CLK (clock) to the SCK pin (D13 on a Uno) 44 | Wire LOAD to the /SS (slave select) pin (D10 on a Uno) 45 | 46 | Make an instance of the class: 47 | 48 | MAX7219_Dot_Matrix myDisplay (1, 10); // 1 chip, and then specify the LOAD pin only 49 | 50 | Bit-banged SPI: 51 | 52 | Wire LOAD, DIN, CLK to any pins of your choice. 53 | 54 | Make an instance of the class: 55 | 56 | MAX7219_Dot_Matrix myDisplay (2, 6, 7, 8); // 2 chips, then specify the LOAD, DIN, CLK pins 57 | 58 | Usage: 59 | 60 | Initialize: 61 | 62 | myDisplay.begin (); 63 | 64 | Shut down: 65 | 66 | myDisplay.end (); 67 | 68 | Write to display: 69 | 70 | myDisplay.sendString ("Hello there"); 71 | 72 | Smooth scrolling: 73 | 74 | myDisplay.sendSmooth.("Hello there", 10); // start at pixel 10 75 | 76 | Set the intensity (from 0 to 15): 77 | 78 | myDisplay.setIntensity (8); 79 | 80 | For the class to compile you need to include these three files: 81 | 82 | SPI.h 83 | bitBangedSPI.h 84 | MAX7219_Dot_Matrix.h 85 | 86 | You can obtain the bitBangedSPI library from: 87 | 88 | https://github.com/nickgammon/bitBangedSPI 89 | 90 | */ 91 | 92 | 93 | 94 | // destructor 95 | MAX7219_Dot_Matrix::~MAX7219_Dot_Matrix () 96 | { 97 | end (); 98 | } // end of destructor 99 | 100 | void MAX7219_Dot_Matrix::begin () 101 | { 102 | pinMode (load_, OUTPUT); 103 | digitalWrite (load_, HIGH); 104 | 105 | // prepare SPI 106 | if (bitBanged_) 107 | { 108 | if (bbSPI_ == NULL) 109 | bbSPI_ = new bitBangedSPI (din_, bitBangedSPI::NO_PIN, clock_); 110 | bbSPI_->begin (); 111 | } // end of bit banged SPI 112 | else 113 | { // hardware SPI 114 | SPI.begin (); 115 | // SPI.setClockDivider (SPI_CLOCK_DIV8); 116 | } // end of hardware SPI 117 | 118 | // repeatedly configure the chips in case they start up in a mode which 119 | // draws a lot of current 120 | for (byte chip = 0; chip < chips_; chip++) 121 | { 122 | sendToAll (MAX7219_REG_SCANLIMIT, 7); // show 8 digits 123 | sendToAll (MAX7219_REG_DECODEMODE, 0); // use bit patterns 124 | sendToAll (MAX7219_REG_DISPLAYTEST, 0); // no display test 125 | sendToAll (MAX7219_REG_INTENSITY, 15); // character intensity: range: 0 to 15 126 | sendString (""); // clear display 127 | sendToAll (MAX7219_REG_SHUTDOWN, 1); // not in shutdown mode (ie. start it up) 128 | } 129 | } // end of MAX7219_Dot_Matrix::begin 130 | 131 | void MAX7219_Dot_Matrix::end () 132 | { 133 | sendToAll (MAX7219_REG_SHUTDOWN, 0); // shutdown mode (ie. turn it off) 134 | 135 | if (bbSPI_ != NULL) 136 | { 137 | delete bbSPI_; 138 | bbSPI_ = NULL; 139 | } 140 | 141 | if (!bitBanged_) 142 | SPI.end (); 143 | 144 | } // end of MAX7219_Dot_Matrix::end 145 | 146 | void MAX7219_Dot_Matrix::setIntensity (const byte amount) 147 | { 148 | sendToAll (MAX7219_REG_INTENSITY, amount & 0xF); // character intensity: range: 0 to 15 149 | } // end of MAX7219_Dot_Matrix::setIntensity 150 | 151 | // send one byte to MAX7219 152 | void MAX7219_Dot_Matrix::sendByte (const byte reg, const byte data) 153 | { 154 | if (bitBanged_) 155 | { 156 | if (bbSPI_ != NULL) 157 | { 158 | bbSPI_->transfer (reg); 159 | bbSPI_->transfer (data); 160 | } 161 | } 162 | else 163 | { 164 | SPI.transfer (reg); 165 | SPI.transfer (data); 166 | } 167 | } // end of sendByte 168 | 169 | void MAX7219_Dot_Matrix::sendToAll (const byte reg, const byte data) 170 | { 171 | digitalWrite (load_, LOW); 172 | for (byte chip = 0; chip < chips_; chip++) 173 | sendByte (reg, data); 174 | digitalWrite (load_, HIGH); 175 | } // end of sendToAll 176 | 177 | void MAX7219_Dot_Matrix::sendChar (const byte chip, const byte data) 178 | { 179 | // get this character from PROGMEM 180 | byte pixels [8]; 181 | for (byte i = 0; i < 8; i++) 182 | pixels [i] = pgm_read_byte (&MAX7219_Dot_Matrix_font [data] [i]); 183 | 184 | send64pixels (chip, pixels); 185 | } // end of sendChar 186 | 187 | // send one character (data) to position (chip) 188 | void MAX7219_Dot_Matrix::send64pixels (const byte chip, const byte pixels [8]) 189 | { 190 | for (byte col = 0; col < 8; col++) 191 | { 192 | // start sending 193 | digitalWrite (load_, LOW); 194 | // send extra NOPs to push the pixels out to extra displays 195 | for (byte i = 0; i < chip; i++) 196 | sendByte (MAX7219_REG_NOOP, MAX7219_REG_NOOP); 197 | // rotate pixels 90 degrees 198 | byte b = 0; 199 | for (byte i = 0; i < 8; i++) 200 | b |= bitRead (pixels [i], col) << (7 - i); 201 | sendByte (col + 1, b); 202 | // end with enough NOPs so later chips don't update 203 | for (int i = 0; i < chips_ - chip - 1; i++) 204 | sendByte (MAX7219_REG_NOOP, MAX7219_REG_NOOP); 205 | // all done! 206 | digitalWrite (load_, HIGH); 207 | } // end of for each column 208 | } // end of sendChar 209 | 210 | // write an entire null-terminated string to the LEDs 211 | void MAX7219_Dot_Matrix::sendString (const char * s) 212 | { 213 | byte chip; 214 | 215 | for (chip = 0; chip < chips_ && *s; chip++) 216 | sendChar (chip, *s++); 217 | 218 | // space out rest 219 | while (chip < (chips_)) 220 | sendChar (chip++, ' '); 221 | 222 | } // end of sendString 223 | 224 | void MAX7219_Dot_Matrix::sendSmooth (const char * s, const int pixel) 225 | { 226 | int len = strlen (s); 227 | byte thisChip [3 * 8]; // pixels for current chip with allowance for one each side 228 | int firstByte = pixel / 8; 229 | int offset = pixel - (firstByte * 8); 230 | 231 | byte chip; 232 | 233 | for (chip = 0; chip < chips_; chip++) 234 | { 235 | memset (thisChip, 0, sizeof thisChip); 236 | 237 | // get pixels to left of current character in case "pixel" is negative 238 | if (offset < 0) 239 | { 240 | if (firstByte + chip - 1 >= 0 && firstByte + chip - 1 < len) 241 | for (byte i = 0; i < 8; i++) 242 | thisChip [i] = pgm_read_byte (&MAX7219_Dot_Matrix_font [((const byte *) s) [firstByte + chip - 1]] [i]); 243 | } // negative offset 244 | 245 | // get the current character 246 | if (firstByte + chip >= 0 && firstByte + chip < len) 247 | for (byte i = 0; i < 8; i++) 248 | thisChip [i + 8] = pgm_read_byte (&MAX7219_Dot_Matrix_font [((const byte *) s) [firstByte + chip]] [i]); 249 | 250 | // get pixels to right of current character in case "pixel" is positive 251 | if (offset > 0) 252 | { 253 | if (firstByte + chip + 1 >= 0 && firstByte + chip + 1 < len) 254 | for (byte i = 0; i < 8; i++) 255 | thisChip [i + 16] = pgm_read_byte (&MAX7219_Dot_Matrix_font [((const byte *) s) [firstByte + chip + 1]] [i]); 256 | } // positive offset 257 | 258 | // send the appropriate 8 pixels (offset will be from -7 to +7) 259 | send64pixels (chip, &thisChip [8 + offset]); 260 | 261 | } // for each chip 262 | 263 | } // end of MAX7219_Dot_Matrix::sendSmooth 264 | -------------------------------------------------------------------------------- /src/MAX7219_Dot_Matrix.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | class MAX7219_Dot_Matrix 4 | { 5 | // pins 6 | const byte chips_; 7 | const byte load_; 8 | const byte din_; 9 | const byte clock_; 10 | const bool bitBanged_; 11 | bitBangedSPI * bbSPI_; 12 | 13 | void sendByte (const byte reg, const byte data); 14 | void sendToAll (const byte reg, const byte data); 15 | 16 | // registers 17 | enum { 18 | MAX7219_REG_NOOP = 0x0, 19 | // codes 1 to 8 are digit positions 1 to 8 20 | MAX7219_REG_DECODEMODE = 0x9, 21 | MAX7219_REG_INTENSITY = 0xA, 22 | MAX7219_REG_SCANLIMIT = 0xB, 23 | MAX7219_REG_SHUTDOWN = 0xC, 24 | MAX7219_REG_DISPLAYTEST = 0xF, 25 | }; // end of enum 26 | 27 | 28 | public: 29 | // constructor 30 | MAX7219_Dot_Matrix (const byte chips, 31 | const byte load, 32 | const byte din = 0, 33 | const byte clock = 0) 34 | : chips_ (chips), load_ (load), din_ (din), clock_ (clock), 35 | bitBanged_ ((din | clock) != 0), bbSPI_ (NULL) { } 36 | 37 | ~MAX7219_Dot_Matrix (); // destructor 38 | void begin (); 39 | void end (); 40 | 41 | void sendChar (const byte pos, const byte data); 42 | void send64pixels (const byte pos, const byte data [8]); 43 | void sendString (const char * s); 44 | void sendSmooth (const char * s, const int pixel); 45 | void setIntensity (const byte amount); // 0 to 15 46 | 47 | static const byte HYPHEN = 0b0000001; 48 | 49 | }; // end of class MAX7219_Dot_Matrix 50 | -------------------------------------------------------------------------------- /src/MAX7219_Dot_Matrix_font.h: -------------------------------------------------------------------------------- 1 | 2 | // bit patterns for the CP437 font 3 | 4 | const byte MAX7219_Dot_Matrix_font [256] [8] PROGMEM = { 5 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // 0x00 6 | { 0x7E, 0x81, 0x95, 0xB1, 0xB1, 0x95, 0x81, 0x7E }, // 0x01 7 | { 0x7E, 0xFF, 0xEB, 0xCF, 0xCF, 0xEB, 0xFF, 0x7E }, // 0x02 8 | { 0x0E, 0x1F, 0x3F, 0x7E, 0x3F, 0x1F, 0x0E, 0x00 }, // 0x03 9 | { 0x08, 0x1C, 0x3E, 0x7F, 0x3E, 0x1C, 0x08, 0x00 }, // 0x04 10 | { 0x18, 0xBA, 0xFF, 0xFF, 0xFF, 0xBA, 0x18, 0x00 }, // 0x05 11 | { 0x10, 0xB8, 0xFC, 0xFF, 0xFC, 0xB8, 0x10, 0x00 }, // 0x06 12 | { 0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00 }, // 0x07 13 | { 0xFF, 0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF }, // 0x08 14 | { 0x00, 0x3C, 0x66, 0x42, 0x42, 0x66, 0x3C, 0x00 }, // 0x09 15 | { 0xFF, 0xC3, 0x99, 0xBD, 0xBD, 0x99, 0xC3, 0xFF }, // 0x0A 16 | { 0x70, 0xF8, 0x88, 0x88, 0xFD, 0x7F, 0x07, 0x0F }, // 0x0B 17 | { 0x00, 0x4E, 0x5F, 0xF1, 0xF1, 0x5F, 0x4E, 0x00 }, // 0x0C 18 | { 0xC0, 0xE0, 0xFF, 0x7F, 0x05, 0x05, 0x07, 0x07 }, // 0x0D 19 | { 0xC0, 0xFF, 0x7F, 0x05, 0x05, 0x65, 0x7F, 0x3F }, // 0x0E 20 | { 0x99, 0x5A, 0x3C, 0xE7, 0xE7, 0x3C, 0x5A, 0x99 }, // 0x0F 21 | { 0x7F, 0x3E, 0x3E, 0x1C, 0x1C, 0x08, 0x08, 0x00 }, // 0x10 22 | { 0x08, 0x08, 0x1C, 0x1C, 0x3E, 0x3E, 0x7F, 0x00 }, // 0x11 23 | { 0x00, 0x24, 0x66, 0xFF, 0xFF, 0x66, 0x24, 0x00 }, // 0x12 24 | { 0x00, 0x5F, 0x5F, 0x00, 0x00, 0x5F, 0x5F, 0x00 }, // 0x13 25 | { 0x06, 0x0F, 0x09, 0x7F, 0x7F, 0x01, 0x7F, 0x7F }, // 0x14 26 | { 0x40, 0xDA, 0xBF, 0xA5, 0xFD, 0x59, 0x03, 0x02 }, // 0x15 27 | { 0x00, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x00 }, // 0x16 28 | { 0x80, 0x94, 0xB6, 0xFF, 0xFF, 0xB6, 0x94, 0x80 }, // 0x17 29 | { 0x00, 0x04, 0x06, 0x7F, 0x7F, 0x06, 0x04, 0x00 }, // 0x18 30 | { 0x00, 0x10, 0x30, 0x7F, 0x7F, 0x30, 0x10, 0x00 }, // 0x19 31 | { 0x08, 0x08, 0x08, 0x2A, 0x3E, 0x1C, 0x08, 0x00 }, // 0x1A 32 | { 0x08, 0x1C, 0x3E, 0x2A, 0x08, 0x08, 0x08, 0x00 }, // 0x1B 33 | { 0x3C, 0x3C, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00 }, // 0x1C 34 | { 0x08, 0x1C, 0x3E, 0x08, 0x08, 0x3E, 0x1C, 0x08 }, // 0x1D 35 | { 0x30, 0x38, 0x3C, 0x3E, 0x3E, 0x3C, 0x38, 0x30 }, // 0x1E 36 | { 0x06, 0x0E, 0x1E, 0x3E, 0x3E, 0x1E, 0x0E, 0x06 }, // 0x1F 37 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // ' ' 38 | { 0x00, 0x06, 0x5F, 0x5F, 0x06, 0x00, 0x00, 0x00 }, // '!' 39 | { 0x00, 0x07, 0x07, 0x00, 0x07, 0x07, 0x00, 0x00 }, // '"' 40 | { 0x14, 0x7F, 0x7F, 0x14, 0x7F, 0x7F, 0x14, 0x00 }, // '#' 41 | { 0x24, 0x2E, 0x6B, 0x6B, 0x3A, 0x12, 0x00, 0x00 }, // '$' 42 | { 0x46, 0x66, 0x30, 0x18, 0x0C, 0x66, 0x62, 0x00 }, // '%' 43 | { 0x30, 0x7A, 0x4F, 0x5D, 0x37, 0x7A, 0x48, 0x00 }, // '&' 44 | { 0x04, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00 }, // ''' 45 | { 0x00, 0x1C, 0x3E, 0x63, 0x41, 0x00, 0x00, 0x00 }, // '(' 46 | { 0x00, 0x41, 0x63, 0x3E, 0x1C, 0x00, 0x00, 0x00 }, // ')' 47 | { 0x08, 0x2A, 0x3E, 0x1C, 0x1C, 0x3E, 0x2A, 0x08 }, // '*' 48 | { 0x08, 0x08, 0x3E, 0x3E, 0x08, 0x08, 0x00, 0x00 }, // '+' 49 | { 0x00, 0x80, 0xE0, 0x60, 0x00, 0x00, 0x00, 0x00 }, // ',' 50 | { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00 }, // '-' 51 | { 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00 }, // '.' 52 | { 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x00 }, // '/' 53 | { 0x3E, 0x7F, 0x71, 0x59, 0x4D, 0x7F, 0x3E, 0x00 }, // '0' 54 | { 0x40, 0x42, 0x7F, 0x7F, 0x40, 0x40, 0x00, 0x00 }, // '1' 55 | { 0x62, 0x73, 0x59, 0x49, 0x6F, 0x66, 0x00, 0x00 }, // '2' 56 | { 0x22, 0x63, 0x49, 0x49, 0x7F, 0x36, 0x00, 0x00 }, // '3' 57 | { 0x18, 0x1C, 0x16, 0x53, 0x7F, 0x7F, 0x50, 0x00 }, // '4' 58 | { 0x27, 0x67, 0x45, 0x45, 0x7D, 0x39, 0x00, 0x00 }, // '5' 59 | { 0x3C, 0x7E, 0x4B, 0x49, 0x79, 0x30, 0x00, 0x00 }, // '6' 60 | { 0x03, 0x03, 0x71, 0x79, 0x0F, 0x07, 0x00, 0x00 }, // '7' 61 | { 0x36, 0x7F, 0x49, 0x49, 0x7F, 0x36, 0x00, 0x00 }, // '8' 62 | { 0x06, 0x4F, 0x49, 0x69, 0x3F, 0x1E, 0x00, 0x00 }, // '9' 63 | { 0x00, 0x00, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00 }, // ':' 64 | { 0x00, 0x80, 0xE6, 0x66, 0x00, 0x00, 0x00, 0x00 }, // ';' 65 | { 0x08, 0x1C, 0x36, 0x63, 0x41, 0x00, 0x00, 0x00 }, // '<' 66 | { 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x00, 0x00 }, // '=' 67 | { 0x00, 0x41, 0x63, 0x36, 0x1C, 0x08, 0x00, 0x00 }, // '>' 68 | { 0x02, 0x03, 0x51, 0x59, 0x0F, 0x06, 0x00, 0x00 }, // '?' 69 | { 0x3E, 0x7F, 0x41, 0x5D, 0x5D, 0x1F, 0x1E, 0x00 }, // '@' 70 | { 0x7C, 0x7E, 0x13, 0x13, 0x7E, 0x7C, 0x00, 0x00 }, // 'A' 71 | { 0x41, 0x7F, 0x7F, 0x49, 0x49, 0x7F, 0x36, 0x00 }, // 'B' 72 | { 0x1C, 0x3E, 0x63, 0x41, 0x41, 0x63, 0x22, 0x00 }, // 'C' 73 | { 0x41, 0x7F, 0x7F, 0x41, 0x63, 0x3E, 0x1C, 0x00 }, // 'D' 74 | { 0x41, 0x7F, 0x7F, 0x49, 0x5D, 0x41, 0x63, 0x00 }, // 'E' 75 | { 0x41, 0x7F, 0x7F, 0x49, 0x1D, 0x01, 0x03, 0x00 }, // 'F' 76 | { 0x1C, 0x3E, 0x63, 0x41, 0x51, 0x73, 0x72, 0x00 }, // 'G' 77 | { 0x7F, 0x7F, 0x08, 0x08, 0x7F, 0x7F, 0x00, 0x00 }, // 'H' 78 | { 0x00, 0x41, 0x7F, 0x7F, 0x41, 0x00, 0x00, 0x00 }, // 'I' 79 | { 0x30, 0x70, 0x40, 0x41, 0x7F, 0x3F, 0x01, 0x00 }, // 'J' 80 | { 0x41, 0x7F, 0x7F, 0x08, 0x1C, 0x77, 0x63, 0x00 }, // 'K' 81 | { 0x41, 0x7F, 0x7F, 0x41, 0x40, 0x60, 0x70, 0x00 }, // 'L' 82 | { 0x7F, 0x7F, 0x0E, 0x1C, 0x0E, 0x7F, 0x7F, 0x00 }, // 'M' 83 | { 0x7F, 0x7F, 0x06, 0x0C, 0x18, 0x7F, 0x7F, 0x00 }, // 'N' 84 | { 0x1C, 0x3E, 0x63, 0x41, 0x63, 0x3E, 0x1C, 0x00 }, // 'O' 85 | { 0x41, 0x7F, 0x7F, 0x49, 0x09, 0x0F, 0x06, 0x00 }, // 'P' 86 | { 0x1E, 0x3F, 0x21, 0x71, 0x7F, 0x5E, 0x00, 0x00 }, // 'Q' 87 | { 0x41, 0x7F, 0x7F, 0x09, 0x19, 0x7F, 0x66, 0x00 }, // 'R' 88 | { 0x26, 0x6F, 0x4D, 0x59, 0x73, 0x32, 0x00, 0x00 }, // 'S' 89 | { 0x03, 0x41, 0x7F, 0x7F, 0x41, 0x03, 0x00, 0x00 }, // 'T' 90 | { 0x7F, 0x7F, 0x40, 0x40, 0x7F, 0x7F, 0x00, 0x00 }, // 'U' 91 | { 0x1F, 0x3F, 0x60, 0x60, 0x3F, 0x1F, 0x00, 0x00 }, // 'V' 92 | { 0x7F, 0x7F, 0x30, 0x18, 0x30, 0x7F, 0x7F, 0x00 }, // 'W' 93 | { 0x43, 0x67, 0x3C, 0x18, 0x3C, 0x67, 0x43, 0x00 }, // 'X' 94 | { 0x07, 0x4F, 0x78, 0x78, 0x4F, 0x07, 0x00, 0x00 }, // 'Y' 95 | { 0x47, 0x63, 0x71, 0x59, 0x4D, 0x67, 0x73, 0x00 }, // 'Z' 96 | { 0x00, 0x7F, 0x7F, 0x41, 0x41, 0x00, 0x00, 0x00 }, // '[' 97 | { 0x01, 0x03, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x00 }, // backslash 98 | { 0x00, 0x41, 0x41, 0x7F, 0x7F, 0x00, 0x00, 0x00 }, // ']' 99 | { 0x08, 0x0C, 0x06, 0x03, 0x06, 0x0C, 0x08, 0x00 }, // '^' 100 | { 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 }, // '_' 101 | { 0x00, 0x00, 0x03, 0x07, 0x04, 0x00, 0x00, 0x00 }, // '`' 102 | { 0x20, 0x74, 0x54, 0x54, 0x3C, 0x78, 0x40, 0x00 }, // 'a' 103 | { 0x41, 0x7F, 0x3F, 0x48, 0x48, 0x78, 0x30, 0x00 }, // 'b' 104 | { 0x38, 0x7C, 0x44, 0x44, 0x6C, 0x28, 0x00, 0x00 }, // 'c' 105 | { 0x30, 0x78, 0x48, 0x49, 0x3F, 0x7F, 0x40, 0x00 }, // 'd' 106 | { 0x38, 0x7C, 0x54, 0x54, 0x5C, 0x18, 0x00, 0x00 }, // 'e' 107 | { 0x48, 0x7E, 0x7F, 0x49, 0x03, 0x02, 0x00, 0x00 }, // 'f' 108 | { 0x98, 0xBC, 0xA4, 0xA4, 0xF8, 0x7C, 0x04, 0x00 }, // 'g' 109 | { 0x41, 0x7F, 0x7F, 0x08, 0x04, 0x7C, 0x78, 0x00 }, // 'h' 110 | { 0x00, 0x44, 0x7D, 0x7D, 0x40, 0x00, 0x00, 0x00 }, // 'i' 111 | { 0x60, 0xE0, 0x80, 0x80, 0xFD, 0x7D, 0x00, 0x00 }, // 'j' 112 | { 0x41, 0x7F, 0x7F, 0x10, 0x38, 0x6C, 0x44, 0x00 }, // 'k' 113 | { 0x00, 0x41, 0x7F, 0x7F, 0x40, 0x00, 0x00, 0x00 }, // 'l' 114 | { 0x7C, 0x7C, 0x18, 0x38, 0x1C, 0x7C, 0x78, 0x00 }, // 'm' 115 | { 0x7C, 0x7C, 0x04, 0x04, 0x7C, 0x78, 0x00, 0x00 }, // 'n' 116 | { 0x38, 0x7C, 0x44, 0x44, 0x7C, 0x38, 0x00, 0x00 }, // 'o' 117 | { 0x84, 0xFC, 0xF8, 0xA4, 0x24, 0x3C, 0x18, 0x00 }, // 'p' 118 | { 0x18, 0x3C, 0x24, 0xA4, 0xF8, 0xFC, 0x84, 0x00 }, // 'q' 119 | { 0x44, 0x7C, 0x78, 0x4C, 0x04, 0x1C, 0x18, 0x00 }, // 'r' 120 | { 0x48, 0x5C, 0x54, 0x54, 0x74, 0x24, 0x00, 0x00 }, // 's' 121 | { 0x00, 0x04, 0x3E, 0x7F, 0x44, 0x24, 0x00, 0x00 }, // 't' 122 | { 0x3C, 0x7C, 0x40, 0x40, 0x3C, 0x7C, 0x40, 0x00 }, // 'u' 123 | { 0x1C, 0x3C, 0x60, 0x60, 0x3C, 0x1C, 0x00, 0x00 }, // 'v' 124 | { 0x3C, 0x7C, 0x70, 0x38, 0x70, 0x7C, 0x3C, 0x00 }, // 'w' 125 | { 0x44, 0x6C, 0x38, 0x10, 0x38, 0x6C, 0x44, 0x00 }, // 'x' 126 | { 0x9C, 0xBC, 0xA0, 0xA0, 0xFC, 0x7C, 0x00, 0x00 }, // 'y' 127 | { 0x4C, 0x64, 0x74, 0x5C, 0x4C, 0x64, 0x00, 0x00 }, // 'z' 128 | { 0x08, 0x08, 0x3E, 0x77, 0x41, 0x41, 0x00, 0x00 }, // '{' 129 | { 0x00, 0x00, 0x00, 0x77, 0x77, 0x00, 0x00, 0x00 }, // '|' 130 | { 0x41, 0x41, 0x77, 0x3E, 0x08, 0x08, 0x00, 0x00 }, // '}' 131 | { 0x02, 0x03, 0x01, 0x03, 0x02, 0x03, 0x01, 0x00 }, // '~' 132 | { 0x70, 0x78, 0x4C, 0x46, 0x4C, 0x78, 0x70, 0x00 }, // 0x7F 133 | { 0x0E, 0x9F, 0x91, 0xB1, 0xFB, 0x4A, 0x00, 0x00 }, // 0x80 134 | { 0x3A, 0x7A, 0x40, 0x40, 0x7A, 0x7A, 0x40, 0x00 }, // 0x81 135 | { 0x38, 0x7C, 0x54, 0x55, 0x5D, 0x19, 0x00, 0x00 }, // 0x82 136 | { 0x02, 0x23, 0x75, 0x55, 0x55, 0x7D, 0x7B, 0x42 }, // 0x83 137 | { 0x21, 0x75, 0x54, 0x54, 0x7D, 0x79, 0x40, 0x00 }, // 0x84 138 | { 0x21, 0x75, 0x55, 0x54, 0x7C, 0x78, 0x40, 0x00 }, // 0x85 139 | { 0x20, 0x74, 0x57, 0x57, 0x7C, 0x78, 0x40, 0x00 }, // 0x86 140 | { 0x18, 0x3C, 0xA4, 0xA4, 0xE4, 0x40, 0x00, 0x00 }, // 0x87 141 | { 0x02, 0x3B, 0x7D, 0x55, 0x55, 0x5D, 0x1B, 0x02 }, // 0x88 142 | { 0x39, 0x7D, 0x54, 0x54, 0x5D, 0x19, 0x00, 0x00 }, // 0x89 143 | { 0x39, 0x7D, 0x55, 0x54, 0x5C, 0x18, 0x00, 0x00 }, // 0x8A 144 | { 0x01, 0x45, 0x7C, 0x7C, 0x41, 0x01, 0x00, 0x00 }, // 0x8B 145 | { 0x02, 0x03, 0x45, 0x7D, 0x7D, 0x43, 0x02, 0x00 }, // 0x8C 146 | { 0x01, 0x45, 0x7D, 0x7C, 0x40, 0x00, 0x00, 0x00 }, // 0x8D 147 | { 0x79, 0x7D, 0x16, 0x12, 0x16, 0x7D, 0x79, 0x00 }, // 0x8E 148 | { 0x70, 0x78, 0x2B, 0x2B, 0x78, 0x70, 0x00, 0x00 }, // 0x8F 149 | { 0x44, 0x7C, 0x7C, 0x55, 0x55, 0x45, 0x00, 0x00 }, // 0x90 150 | { 0x20, 0x74, 0x54, 0x54, 0x7C, 0x7C, 0x54, 0x54 }, // 0x91 151 | { 0x7C, 0x7E, 0x0B, 0x09, 0x7F, 0x7F, 0x49, 0x00 }, // 0x92 152 | { 0x32, 0x7B, 0x49, 0x49, 0x7B, 0x32, 0x00, 0x00 }, // 0x93 153 | { 0x32, 0x7A, 0x48, 0x48, 0x7A, 0x32, 0x00, 0x00 }, // 0x94 154 | { 0x32, 0x7A, 0x4A, 0x48, 0x78, 0x30, 0x00, 0x00 }, // 0x95 155 | { 0x3A, 0x7B, 0x41, 0x41, 0x7B, 0x7A, 0x40, 0x00 }, // 0x96 156 | { 0x3A, 0x7A, 0x42, 0x40, 0x78, 0x78, 0x40, 0x00 }, // 0x97 157 | { 0x9A, 0xBA, 0xA0, 0xA0, 0xFA, 0x7A, 0x00, 0x00 }, // 0x98 158 | { 0x01, 0x19, 0x3C, 0x66, 0x66, 0x3C, 0x19, 0x01 }, // 0x99 159 | { 0x3D, 0x7D, 0x40, 0x40, 0x7D, 0x3D, 0x00, 0x00 }, // 0x9A 160 | { 0x18, 0x3C, 0x24, 0xE7, 0xE7, 0x24, 0x24, 0x00 }, // 0x9B 161 | { 0x68, 0x7E, 0x7F, 0x49, 0x43, 0x66, 0x20, 0x00 }, // 0x9C 162 | { 0x2B, 0x2F, 0xFC, 0xFC, 0x2F, 0x2B, 0x00, 0x00 }, // 0x9D 163 | { 0xFF, 0xFF, 0x09, 0x09, 0x2F, 0xF6, 0xF8, 0xA0 }, // 0x9E 164 | { 0x40, 0xC0, 0x88, 0xFE, 0x7F, 0x09, 0x03, 0x02 }, // 0x9F 165 | { 0x20, 0x74, 0x54, 0x55, 0x7D, 0x79, 0x40, 0x00 }, // 0xA0 166 | { 0x00, 0x44, 0x7D, 0x7D, 0x41, 0x00, 0x00, 0x00 }, // 0xA1 167 | { 0x30, 0x78, 0x48, 0x4A, 0x7A, 0x32, 0x00, 0x00 }, // 0xA2 168 | { 0x38, 0x78, 0x40, 0x42, 0x7A, 0x7A, 0x40, 0x00 }, // 0xA3 169 | { 0x7A, 0x7A, 0x0A, 0x0A, 0x7A, 0x70, 0x00, 0x00 }, // 0xA4 170 | { 0x7D, 0x7D, 0x19, 0x31, 0x7D, 0x7D, 0x00, 0x00 }, // 0xA5 171 | { 0x00, 0x26, 0x2F, 0x29, 0x2F, 0x2F, 0x28, 0x00 }, // 0xA6 172 | { 0x00, 0x26, 0x2F, 0x29, 0x2F, 0x26, 0x00, 0x00 }, // 0xA7 173 | { 0x30, 0x78, 0x4D, 0x45, 0x60, 0x20, 0x00, 0x00 }, // 0xA8 174 | { 0x38, 0x38, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00 }, // 0xA9 175 | { 0x08, 0x08, 0x08, 0x08, 0x38, 0x38, 0x00, 0x00 }, // 0xAA 176 | { 0x4F, 0x6F, 0x30, 0x18, 0xCC, 0xEE, 0xBB, 0x91 }, // 0xAB 177 | { 0x4F, 0x6F, 0x30, 0x18, 0x6C, 0x76, 0xFB, 0xF9 }, // 0xAC 178 | { 0x00, 0x00, 0x00, 0x7B, 0x7B, 0x00, 0x00, 0x00 }, // 0xAD 179 | { 0x08, 0x1C, 0x36, 0x22, 0x08, 0x1C, 0x36, 0x22 }, // 0xAE 180 | { 0x22, 0x36, 0x1C, 0x08, 0x22, 0x36, 0x1C, 0x08 }, // 0xAF 181 | { 0xAA, 0x00, 0x55, 0x00, 0xAA, 0x00, 0x55, 0x00 }, // 0xB0 182 | { 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55 }, // 0xB1 183 | { 0xDD, 0xFF, 0xAA, 0x77, 0xDD, 0xAA, 0xFF, 0x77 }, // 0xB2 184 | { 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00 }, // 0xB3 185 | { 0x10, 0x10, 0x10, 0xFF, 0xFF, 0x00, 0x00, 0x00 }, // 0xB4 186 | { 0x14, 0x14, 0x14, 0xFF, 0xFF, 0x00, 0x00, 0x00 }, // 0xB5 187 | { 0x10, 0x10, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00 }, // 0xB6 188 | { 0x10, 0x10, 0xF0, 0xF0, 0x10, 0xF0, 0xF0, 0x00 }, // 0xB7 189 | { 0x14, 0x14, 0x14, 0xFC, 0xFC, 0x00, 0x00, 0x00 }, // 0xB8 190 | { 0x14, 0x14, 0xF7, 0xF7, 0x00, 0xFF, 0xFF, 0x00 }, // 0xB9 191 | { 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00 }, // 0xBA 192 | { 0x14, 0x14, 0xF4, 0xF4, 0x04, 0xFC, 0xFC, 0x00 }, // 0xBB 193 | { 0x14, 0x14, 0x17, 0x17, 0x10, 0x1F, 0x1F, 0x00 }, // 0xBC 194 | { 0x10, 0x10, 0x1F, 0x1F, 0x10, 0x1F, 0x1F, 0x00 }, // 0xBD 195 | { 0x14, 0x14, 0x14, 0x1F, 0x1F, 0x00, 0x00, 0x00 }, // 0xBE 196 | { 0x10, 0x10, 0x10, 0xF0, 0xF0, 0x00, 0x00, 0x00 }, // 0xBF 197 | { 0x00, 0x00, 0x00, 0x1F, 0x1F, 0x10, 0x10, 0x10 }, // 0xC0 198 | { 0x10, 0x10, 0x10, 0x1F, 0x1F, 0x10, 0x10, 0x10 }, // 0xC1 199 | { 0x10, 0x10, 0x10, 0xF0, 0xF0, 0x10, 0x10, 0x10 }, // 0xC2 200 | { 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x10, 0x10, 0x10 }, // 0xC3 201 | { 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 }, // 0xC4 202 | { 0x10, 0x10, 0x10, 0xFF, 0xFF, 0x10, 0x10, 0x10 }, // 0xC5 203 | { 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x14, 0x14, 0x14 }, // 0xC6 204 | { 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x10 }, // 0xC7 205 | { 0x00, 0x00, 0x1F, 0x1F, 0x10, 0x17, 0x17, 0x14 }, // 0xC8 206 | { 0x00, 0x00, 0xFC, 0xFC, 0x04, 0xF4, 0xF4, 0x14 }, // 0xC9 207 | { 0x14, 0x14, 0x17, 0x17, 0x10, 0x17, 0x17, 0x14 }, // 0xCA 208 | { 0x14, 0x14, 0xF4, 0xF4, 0x04, 0xF4, 0xF4, 0x14 }, // 0xCB 209 | { 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xF7, 0xF7, 0x14 }, // 0xCC 210 | { 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14 }, // 0xCD 211 | { 0x14, 0x14, 0xF7, 0xF7, 0x00, 0xF7, 0xF7, 0x14 }, // 0xCE 212 | { 0x14, 0x14, 0x14, 0x17, 0x17, 0x14, 0x14, 0x14 }, // 0xCF 213 | { 0x10, 0x10, 0x1F, 0x1F, 0x10, 0x1F, 0x1F, 0x10 }, // 0xD0 214 | { 0x14, 0x14, 0x14, 0xF4, 0xF4, 0x14, 0x14, 0x14 }, // 0xD1 215 | { 0x10, 0x10, 0xF0, 0xF0, 0x10, 0xF0, 0xF0, 0x10 }, // 0xD2 216 | { 0x00, 0x00, 0x1F, 0x1F, 0x10, 0x1F, 0x1F, 0x10 }, // 0xD3 217 | { 0x00, 0x00, 0x00, 0x1F, 0x1F, 0x14, 0x14, 0x14 }, // 0xD4 218 | { 0x00, 0x00, 0x00, 0xFC, 0xFC, 0x14, 0x14, 0x14 }, // 0xD5 219 | { 0x00, 0x00, 0xF0, 0xF0, 0x10, 0xF0, 0xF0, 0x10 }, // 0xD6 220 | { 0x10, 0x10, 0xFF, 0xFF, 0x10, 0xFF, 0xFF, 0x10 }, // 0xD7 221 | { 0x14, 0x14, 0x14, 0xFF, 0xFF, 0x14, 0x14, 0x14 }, // 0xD8 222 | { 0x10, 0x10, 0x10, 0x1F, 0x1F, 0x00, 0x00, 0x00 }, // 0xD9 223 | { 0x00, 0x00, 0x00, 0xF0, 0xF0, 0x10, 0x10, 0x10 }, // 0xDA 224 | { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, // 0xDB 225 | { 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0 }, // 0xDC 226 | { 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00 }, // 0xDD 227 | { 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF }, // 0xDE 228 | { 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F }, // 0xDF 229 | { 0x38, 0x7C, 0x44, 0x6C, 0x38, 0x6C, 0x44, 0x00 }, // 0xE0 230 | { 0xFC, 0xFE, 0x2A, 0x2A, 0x3E, 0x14, 0x00, 0x00 }, // 0xE1 231 | { 0x7E, 0x7E, 0x02, 0x02, 0x06, 0x06, 0x00, 0x00 }, // 0xE2 232 | { 0x02, 0x7E, 0x7E, 0x02, 0x7E, 0x7E, 0x02, 0x00 }, // 0xE3 233 | { 0x63, 0x77, 0x5D, 0x49, 0x63, 0x63, 0x00, 0x00 }, // 0xE4 234 | { 0x38, 0x7C, 0x44, 0x7C, 0x3C, 0x04, 0x04, 0x00 }, // 0xE5 235 | { 0x80, 0xFE, 0x7E, 0x20, 0x20, 0x3E, 0x1E, 0x00 }, // 0xE6 236 | { 0x04, 0x06, 0x02, 0x7E, 0x7C, 0x06, 0x02, 0x00 }, // 0xE7 237 | { 0x99, 0xBD, 0xE7, 0xE7, 0xBD, 0x99, 0x00, 0x00 }, // 0xE8 238 | { 0x1C, 0x3E, 0x6B, 0x49, 0x6B, 0x3E, 0x1C, 0x00 }, // 0xE9 239 | { 0x4C, 0x7E, 0x73, 0x01, 0x73, 0x7E, 0x4C, 0x00 }, // 0xEA 240 | { 0x30, 0x78, 0x4A, 0x4F, 0x7D, 0x39, 0x00, 0x00 }, // 0xEB 241 | { 0x18, 0x3C, 0x24, 0x3C, 0x3C, 0x24, 0x3C, 0x18 }, // 0xEC 242 | { 0x98, 0xFC, 0x64, 0x3C, 0x3E, 0x27, 0x3D, 0x18 }, // 0xED 243 | { 0x1C, 0x3E, 0x6B, 0x49, 0x49, 0x00, 0x00, 0x00 }, // 0xEE 244 | { 0x7E, 0x7F, 0x01, 0x01, 0x7F, 0x7E, 0x00, 0x00 }, // 0xEF 245 | { 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x00, 0x00 }, // 0xF0 246 | { 0x44, 0x44, 0x5F, 0x5F, 0x44, 0x44, 0x00, 0x00 }, // 0xF1 247 | { 0x40, 0x51, 0x5B, 0x4E, 0x44, 0x40, 0x00, 0x00 }, // 0xF2 248 | { 0x40, 0x44, 0x4E, 0x5B, 0x51, 0x40, 0x00, 0x00 }, // 0xF3 249 | { 0x00, 0x00, 0x00, 0xFE, 0xFF, 0x01, 0x07, 0x06 }, // 0xF4 250 | { 0x60, 0xE0, 0x80, 0xFF, 0x7F, 0x00, 0x00, 0x00 }, // 0xF5 251 | { 0x08, 0x08, 0x6B, 0x6B, 0x08, 0x08, 0x00, 0x00 }, // 0xF6 252 | { 0x24, 0x36, 0x12, 0x36, 0x24, 0x36, 0x12, 0x00 }, // 0xF7 253 | { 0x00, 0x06, 0x0F, 0x09, 0x0F, 0x06, 0x00, 0x00 }, // 0xF8 254 | { 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00 }, // 0xF9 255 | { 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00 }, // 0xFA 256 | { 0x10, 0x30, 0x70, 0xC0, 0xFF, 0xFF, 0x01, 0x01 }, // 0xFB 257 | { 0x00, 0x1F, 0x1F, 0x01, 0x1F, 0x1E, 0x00, 0x00 }, // 0xFC 258 | { 0x00, 0x19, 0x1D, 0x17, 0x12, 0x00, 0x00, 0x00 }, // 0xFD 259 | { 0x00, 0x00, 0x3C, 0x3C, 0x3C, 0x3C, 0x00, 0x00 }, // 0xFE 260 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // 0xFF 261 | }; // end of MAX7219_Dot_Matrix_font 262 | --------------------------------------------------------------------------------