Revision 0:bb60966d6de1, committed 2011-10-11

Comitter:

Fenwiz

Date:

Tue Oct 11 01:14:45 2011 +0000

Commit message:

Revision 1.00. initial release. stable and fairly robust

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/N_5110_Display.cpp	Tue Oct 11 01:14:45 2011 +0000
@@ -0,0 +1,420 @@
+#include "mbed.h"
+#include "N_5110_Display.h"
+#include "N_5110_Font.h"
+
+
+N_5110_Display::N_5110_Display(  PinName _mosi, PinName _miso, PinName _sclk, PinName _dc, PinName _reset, PinName _cs): 
+                        spi( _mosi, _miso, _sclk ), dc( _dc ), rst( _reset ), cs( _cs )
+{
+    initDisplay();
+}
+
+//----------------------------------------------------------------------
+
+void N_5110_Display::initDisplay()
+{
+    rst=0;                  //display reset
+    cs=1;                   //Chip Disabled
+    
+    wait(0.5);              //allow chip to settle for half second
+        
+    spi.format(8,3);        //set the SPI interface perameters for the Display
+    spi.frequency(1000000); //1 MHz clock speed
+    PixX = 0;               //zero the x, y variables
+    CharX = 0;
+    CharY = 0;
+    
+    rst=1;                  //display reset done
+    
+    dc=0;                   //select Control mode
+    cs=0;                   //Chip Enabled
+        
+    spi.write(0x21);        //Function Set (Extenden Instructions)
+    spi.write(0x04);        //set 'Temp Coef' value
+    spi.write(0x13);        //set 'Bias' value
+    spi.write(0xBF);        //set 'V_op' value
+    spi.write(0x22);        //Function Set (Basic Instructions)
+    spi.write(0x0C);        //Display Control
+        
+    clrDisp();              //Clear the Display
+}
+
+//----------------------------------------------------------------------
+
+void N_5110_Display::clrDisp()
+{
+    long x;
+
+    dc=1;                   //select Data mode
+    cs=0;                   //Chip Enabled
+    
+    for (x=0; x<504; x++)   //Clear the display memory
+    {
+        spi.write( 0 );
+    }
+    
+    cs=1;                   //Chip Disabled
+}
+
+//----------------------------------------------------------------------
+
+void N_5110_Display::setDispPos(int DispX, int DispY)
+{
+    unsigned char Xtemp, Ytemp;
+
+    Xtemp = DispX | 0x80;       //add in the column select BIT
+    Ytemp = (DispY & 0x07) | 0x40;
+    
+    dc=0;                       //select Control mode
+    cs=0;                       //Chip Enabled
+        
+    spi.write(Xtemp);           //Set the column value
+    spi.write(Ytemp);           //set the row value
+    
+    cs=1;                       //Chip Disabled
+}
+
+//----------------------------------------------------------------------
+
+int N_5110_Display::setCharPos(int x, int y)
+//x is the character column number 0 to 13. y is the character row number 0 to 5.
+//The column is multiplied by 6 to get the display column value, as each 5 x 8 char occupies a 6 x 8 space
+{
+    unsigned char Xacc;
+
+    if (x>13 || y>5) return -1; //check magnitude of co-ordinates and store
+    
+    Xacc = x<<2;                //multiply the char column (x) by 6 to get the Display column
+    Xacc = Xacc + (x<<1);
+
+    PixX = Xacc;
+    CharX = x;
+    CharY = y;
+
+    setDispPos(PixX, CharY);
+    
+    return 0;
+}
+
+//----------------------------------------------------------------------
+
+void N_5110_Display::clrMagArray( unsigned char Xmag, unsigned char Ymag, bool FullWidth )
+{
+    unsigned char magDataX, magDataY, width;
+
+    width = FullWidth?6:5;
+    
+    for (magDataX=0; magDataX<Xmag*width; magDataX++)   //clear the magnification array
+    {
+        for (magDataY=0; magDataY<Ymag; magDataY++)
+        {
+            magData[magDataX][magDataY] = 0;
+        }
+    }
+}
+
+//----------------------------------------------------------------------
+
+void N_5110_Display::smoothEdges( unsigned char Xmag, unsigned char Ymag )
+//Quick and dirty character smoothing but only if there is magnification in both X and Y directions. Intended to improve readability
+//at higher magnifications but doesn't realy smooth very well.
+//I'm sure that someone can come up with a better solution than this, but I didn't have time to code an Interpolation algorithm or
+//creata vectored drawing system.
+{
+    unsigned char Xpos, Ypos, tempByte1, tempByte2, tempByte3, and1, and2, totaland, repeater;
+    
+    if (Xmag<2 || Ymag<2) return;                               //check for enough magnification to work with
+    
+    for (repeater=0; repeater<(Xmag*Ymag)/(Xmag+Ymag); repeater++)  //calc sensible number of itterations
+    {
+    
+        for (Ypos=0; Ypos<Ymag; Ypos++)
+        {
+            for (Xpos=0; Xpos<Xmag*6-1; Xpos++)                     //scan left to right
+            {
+                tempByte1 = magData[Xpos+1][Ypos];                  //get the following byte
+                tempByte2 = magData[Xpos][Ypos];                    //get the current byte
+                tempByte3 = tempByte1 ^ tempByte2;                  //check for a change
+            
+                if (tempByte3 != 0)
+                {
+                    tempByte2 >>= 1;                                //shift up (Right towards LSB)
+                
+                    if (Ypos+1 <= Ymag)
+                    {
+                        tempByte3 = magData[Xpos][Ypos+1];          //get missing BIT from byte below
+                        tempByte3 <<= 7;
+                        tempByte2 |= tempByte3;
+                    }
+                
+                    and1 = tempByte1 & tempByte2;
+                        
+                    tempByte2 = magData[Xpos][Ypos];                //re-load the current byte
+                    tempByte2 <<= 1;                                //shift down (Left towards the MSB)
+           
+                    if (Ypos > 0)
+                    {
+                        tempByte3 = magData[Xpos][Ypos-1];          //get missing BIT from byte above
+                        tempByte3 >>= 7;
+                        tempByte2 |= tempByte3;
+                    }
+                
+                    and2 = tempByte1 & tempByte2;
+            
+                    totaland = (and1 | and2);
+                    magData[Xpos][Ypos] |= totaland;                //incorpoate the extra bits into the magData                }
+                }
+            }
+        
+            for (Xpos=Xmag*6; Xpos>0; Xpos--)                       //scan right to left
+            {
+                tempByte1 = magData[Xpos-2][Ypos];                  //get following byte
+                tempByte2 = magData[Xpos-1][Ypos];                  //get the current byte
+                tempByte3 = tempByte1 ^ tempByte2;                  //check for change
+                
+                if (tempByte3 != 0)
+                {
+                    tempByte2 >>= 1;                                //shift up (Right towards the LSB)
+
+                    if (Ypos+1 <= Ymag)
+                    {
+                        tempByte3 = magData[Xpos-1][Ypos+1];        //get missing BIT from byte below
+                        tempByte3 <<= 7;
+                        tempByte2 |= tempByte3;
+                    }
+                
+                    and1 = tempByte1 & tempByte2;
+            
+                    tempByte2 = magData[Xpos-1][Ypos];              //re-load the current byte
+                    tempByte2 <<= 1;                                //shift down (Left towards the MSB)
+                
+                    if (Ypos > 0)
+                    {
+                        tempByte3 = magData[Xpos-1][Ypos-1];        //get missing Bits from byte above
+                        tempByte3 >>= 7;
+                        tempByte2 |= tempByte3;
+                    }
+                    and2 = tempByte1 & tempByte2;
+            
+                    totaland = (and1 | and2);
+                    magData[Xpos - 1][Ypos] |= totaland;
+                }
+            }
+        }
+    }
+}
+
+//----------------------------------------------------------------------
+
+void N_5110_Display::magChar( unsigned char c, unsigned char Xmag, unsigned char Ymag )
+//Expand the basic 5 x 8 char def to the required X and y magnification using an buffer Array
+{
+    unsigned char tempPat, count, Idx, Xexp, Yexp, bitCounter, bitAcc, srcBit, magDataX, magDataY;
+    
+    clrMagArray( Xmag, Ymag, false );
+    
+    Idx = c - 32;                               //shift the ASCII code so it starts from zero
+    
+    magDataX = 0;
+    
+    for (count=0; count<5; count++)             //5 bytes per char def
+    {
+        bitCounter = Ymag/2;                    //offset the image Y position by half the Y magnification factor
+        bitAcc = 0;
+        magDataY = 0;
+        tempPat = font_data[Idx][count];        //get column Bit pattern to expand in the y direction by bit replication
+                                                //LSB is top Bit position
+        
+        for (srcBit=0; srcBit<8; srcBit++)      //process each of the 8 bits in the source byte
+        {
+            for (Yexp=0; Yexp<Ymag; Yexp++)     //each Bit in each def byte is duplicated Ymag times in the Y direction
+            {
+                bitAcc >>= 1;                   //shift the accumulator 1 bit to the left
+                
+                if ((tempPat & 1) > 0)
+                {
+                    bitAcc |= 0x80;             //set msb
+                } else {
+                    bitAcc &= 0x7F;             //clear msb
+                }
+                
+                bitCounter++;
+                
+                if (bitCounter > 7)             //if the bit accumulator is full then store it and clear it to continue
+                {
+                    for (Xexp=0; Xexp<Xmag; Xexp++) //do the X magnification while storingthe Bit Accumulator
+                    {
+                        magData[magDataX + Xexp][magDataY] = bitAcc;
+                    }
+                    
+                    bitAcc = 0;
+                    magDataY++;
+                    bitCounter = 0;
+                }
+            }
+            tempPat>>=1;
+        }
+        magDataX += Xmag;
+    }
+    smoothEdges( Xmag, Ymag );
+}
+
+//----------------------------------------------------------------------
+
+int N_5110_Display::outputMagData (unsigned char Xmag, unsigned char Ymag, bool FullWidth )
+{
+    unsigned char XpixTemp, mx, my, width;
+    
+    XpixTemp = PixX;
+    width = FullWidth?6:5;
+    
+    if (FullWidth == false)
+    {
+        for (mx=0; mx<Xmag/2; mx++)
+        {
+            dc=1;                       //select Data mode
+            cs=0;                       //Chip Enabled
+    
+            for (my=0; my<Ymag; my++)
+            {
+                spi.write( 0 );
+            }
+        
+            cs=1;                       //Chip Disabled
+    
+            XpixTemp += 1;
+            setDispPos(XpixTemp, CharY);
+        }
+    }
+    
+    for (mx=0; mx<Xmag*width; mx++)
+    {
+        dc=1;                       //select Data mode
+        cs=0;                       //Chip Enabled
+        
+        for (my=0; my<Ymag; my++)
+        {
+            spi.write( magData[mx][my] );
+        }
+        
+        cs=1;                       //Chip Disabled
+        
+        XpixTemp += 1;
+        setDispPos( XpixTemp, CharY );
+    }
+    
+    if (FullWidth == false)
+    {
+        for (mx=0; mx<(Xmag+1)/2; mx++)
+        {
+            dc=1;                       //select Data mode
+            cs=0;                       //Chip Enabled
+    
+            for (my=0; my<Ymag; my++)
+            {
+                spi.write( 0 );
+            }
+        
+            cs=1;                       //Chip Disabled
+    
+            XpixTemp += 1;
+            setDispPos(XpixTemp, CharY);
+        }
+    }
+    
+    PixX = XpixTemp;
+    CharX += Xmag;
+    
+    return 0;
+}
+
+//----------------------------------------------------------------------
+
+int N_5110_Display::print1char(unsigned char c, unsigned char Xmag, unsigned char Ymag)
+{    
+    if (c<32 | c>127) return -1;    //Exit if char is out of range
+    
+    if (Xmag<1) Xmag=1;             //Clamp the magnification values
+    if (Ymag<1) Ymag=1;
+    if (Xmag>6) Xmag=6;
+    if (Ymag>6) Ymag=6;
+        
+    magChar( c, Xmag, Ymag );
+
+    outputMagData( Xmag, Ymag, false );
+    
+    return 0;
+}
+
+//----------------------------------------------------------------------
+
+void N_5110_Display::printString( char * str2prt, unsigned char Xmag, unsigned char Ymag)
+{
+    unsigned char c;
+    
+    for (c=0; c<strlen(str2prt); c++)
+    {
+        print1char( str2prt[c], Xmag, Ymag );
+    }
+}
+
+//----------------------------------------------------------------------
+
+void N_5110_Display::VertBarGraph( int Percentage, unsigned char Xmag, unsigned char Ymag )
+{
+    unsigned char Xidx, Yidx, activeHeight, wholeBytes, pixRemaining, mask, count, dither;
+    
+    if (Xmag<1) Xmag=1;                                     //Clamp the magnification values
+    if (Ymag<1) Ymag=1;
+    if (Xmag>6) Xmag=6;
+    if (Ymag>6) Ymag=6;
+    
+    clrMagArray( Xmag, Ymag, true );
+    
+    activeHeight = 8 * Ymag * Percentage /100;              //Calc the magnitude of the Bar
+    wholeBytes = activeHeight / 8;
+    pixRemaining = activeHeight % 8;
+    
+    mask = 0xFF;
+    for(count=0; count<8-pixRemaining; count++)             //creat the mask for pixRemaining
+    {
+        mask <<= 1;
+    }
+    
+    for (Xidx=0; Xidx<6*Xmag-1; Xidx++)                     //step along the pixel columns
+    {
+        dither = Xidx&1?0x55:0xAA;                          //Dither value alternates for each odd, ecen pixel column
+    
+        for (Yidx=0; Yidx<Ymag; Yidx++)                     //step through each row
+        {
+            if (Yidx == Ymag - wholeBytes - 1)              //do the remainder
+            {
+                magData[Xidx][Yidx] |= dither;
+                magData[Xidx][Yidx] &= mask;
+            }
+            else if (Yidx >= Ymag-wholeBytes)                //else do the whole bytes
+            {
+                magData[Xidx][Yidx] |= dither;
+            }
+                                                            //now add the border
+            if (Xidx==0 || Xidx==6*Xmag-2)                  //Left & Right
+            {
+                magData[Xidx][Yidx] |= 0xFF;
+            }
+            
+            if (Yidx==0)                                    //Top
+            {
+                magData[Xidx][Yidx] |= 0x01;
+            }
+            
+            if (Yidx==Ymag-1)                               //Bottom
+            {
+                magData[Xidx][Yidx] |= 0x40;
+                magData[Xidx][Yidx] &= 0x7F;
+            }
+        }
+    }
+    
+    outputMagData( Xmag, Ymag, true );
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/N_5110_Display.h	Tue Oct 11 01:14:45 2011 +0000
@@ -0,0 +1,70 @@
+#ifndef N_5110_Display_H
+#define N_5110_Display_H
+
+#include "mbed.h"
+
+/*
+ * This library is designed to make it easy for anyone to get the Nokia 5110 display 3.3V module up and running without delay
+ * It provides a convenient interface for printing single characters or strings of characters and vertical bar graphs, all at various magnifications.
+ * It is free to use and modify. I accept NO liability for malfunctions or damage caused by this software
+ * I hope it is useful to the community and am open to suggestions for improvement.
+ *
+ *
+ * ---Example code---
+ * 
+ * #include "mbed.h"
+ * #include "N_5110_Display.h"
+ *
+ * N_5110_Display Display( p5, p6, p7, p8, p9, p10 );
+ *
+ * int main()
+ * {
+ *     Display.setCharPos( 0, 0 );              //x pos = 0, y pos = 0
+ *     Display.printString( 'Bar', 2, 3 );      //output string with char width 2, char height 3
+ *
+ *     Display.setCharPos( 0, 3 );              //x pos = 0, y pos = 3
+ *     Display.printString( 'Graph', 2, 3 );    //output string with char width 2, char height 3
+ *
+ *     Display.setCharPos( 11, 0 );             //x pos = 11, y pos = 0 .... X pos is 11 to allow for a bar graph with width 3
+ *     Display.VertBarGraph( 40, 3, 6 );        //generate a vertical bar graph 40% full with width = 3 char, height = 6 char
+ *
+ *     while (1)
+ *     {
+ *
+ *     }
+ * }
+ *
+ *
+ * ---End of example code
+*/
+class N_5110_Display {
+
+    public:
+
+        //mosi, miso, sclk, Data/Command, Reset, ChipSelect
+        N_5110_Display(  PinName _mosi, PinName _miso, PinName _sclk, PinName _dc, PinName _reset, PinName _cs);
+        int print1char( unsigned char c, unsigned char Xmag, unsigned char Ymag );
+        void printString( char * str2prt, unsigned char Xmag, unsigned char Ymag);
+        void VertBarGraph( int Percentage, unsigned char Xmag, unsigned char Ymag );
+        void initDisplay( void );
+        void clrDisp( void );
+        int setCharPos( int x, int y );                                             //x axis position (0 to 13) y axis position (0 to 5)
+        
+    private:
+    
+        void clrMagArray( unsigned char Xmag, unsigned char Ymag, bool FullWidth );
+        void magChar( unsigned char c, unsigned char Xmag, unsigned char Ymag );
+        void smoothEdges( unsigned char Xmag, unsigned char Ymag );
+        void setDispPos( int DispX, int DispY );                                    //DispX axis (0 to 84) DispY axis (0 to 5)
+        int outputMagData (unsigned char Xmag, unsigned char Ymag, bool FulWidth);
+
+        DigitalOut dc;
+        DigitalOut rst;
+        DigitalOut cs;
+        SPI spi;
+        unsigned char PixX, CharX, CharY;
+        unsigned char magData[36][6];
+};
+
+
+#endif
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/N_5110_Font.h	Tue Oct 11 01:14:45 2011 +0000
@@ -0,0 +1,102 @@
+#ifndef N_5110_Font_H
+#define N_5110_Font_H
+
+unsigned char font_data[100][5] = {
+         {0x00, 0x00, 0x00, 0x00, 0x00} // 20  
+        ,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
+        ,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
+        ,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
+        ,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
+        ,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
+        ,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
+        ,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
+        ,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
+        ,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
+        ,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
+        ,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
+        ,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
+        ,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
+        ,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
+        ,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
+        ,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
+        ,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
+        ,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
+        ,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
+        ,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
+        ,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
+        ,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
+        ,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
+        ,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
+        ,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
+        ,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
+        ,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
+        ,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
+        ,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
+        ,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
+        ,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
+        ,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
+        ,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
+        ,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
+        ,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
+        ,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
+        ,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
+        ,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
+        ,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
+        ,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
+        ,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
+        ,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
+        ,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
+        ,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
+        ,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
+        ,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
+        ,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
+        ,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
+        ,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
+        ,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
+        ,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
+        ,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
+        ,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
+        ,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
+        ,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
+        ,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
+        ,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
+        ,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
+        ,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
+        ,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c &#65533;
+        ,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
+        ,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
+        ,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
+        ,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
+        ,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
+        ,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
+        ,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
+        ,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
+        ,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
+        ,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
+        ,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
+        ,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
+        ,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
+        ,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j 
+        ,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
+        ,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
+        ,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
+        ,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
+        ,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
+        ,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
+        ,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
+        ,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
+        ,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
+        ,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
+        ,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
+        ,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
+        ,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
+        ,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
+        ,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
+        ,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
+        ,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
+        ,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
+        ,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
+        ,{0x00, 0x06, 0x09, 0x09, 0x06} // 7e ~ (I've changed these last two to a degrees synbol
+        ,{0x7F, 0x7F, 0x7F, 0x7F, 0x7F} // 7f  and a Square block
+        };
+#endif
\ No newline at end of file