N5110.h

00001 #ifndef N5110_H
00002 #define N5110_H
00003 
00004 #include <vector>
00005 #include <cmath>
00006 #include "math.h" 
00007 #include "Utils.h"
00008 #include "Vector.h"
00009 #include "mbed.h"
00010 
00011 // number of pixels on display
00012 #define WIDTH 84
00013 #define HEIGHT 48
00014 #define BANKS 6
00015 
00016 /// Fill types for 2D shapes
00017 enum FillType {
00018      FILL_TRANSPARENT, ///< Transparent with outline
00019      FILL_BLACK,       ///< Filled black
00020      FILL_WHITE,       ///< Filled white (no outline)
00021 };
00022 
00023 const static int TYPE_SOLID = 0;
00024 const static int TYPE_DOTTED = 1;
00025 
00026 /** N5110 Class
00027 @brief Library for interfacing with Nokia 5110 LCD display (https://www.sparkfun.com/products/10168) using the hardware SPI on the mbed.
00028 @brief The display is powered from a GPIO pin meaning it can be controlled via software.  The LED backlight is also software-controllable (via PWM pin).
00029 @brief Can print characters and strings to the display using the included 5x7 font.
00030 @brief The library also implements a screen buffer so that individual pixels on the display (84 x 48) can be set, cleared and read.
00031 @brief The library can print primitive shapes (lines, circles, rectangles)
00032 @brief Acknowledgements to Chris Yan's Nokia_5110 Library.
00033 
00034 @brief Revision 1.3
00035 
00036 @author Craig A. Evans
00037 @date   7th February 2017
00038 
00039 @code
00040 
00041 #include "mbed.h"
00042 #include "N5110.h"
00043 
00044 //      rows,cols
00045 int sprite[8][5] =   {
00046     { 0,0,1,0,0 },
00047     { 0,1,1,1,0 },
00048     { 0,0,1,0,0 },
00049     { 0,1,1,1,0 },
00050     { 1,1,1,1,1 },
00051     { 1,1,1,1,1 },
00052     { 1,1,0,1,1 },
00053     { 1,1,0,1,1 },
00054 };
00055 
00056 //    VCC,SCE,RST,D/C,MOSI,SCLK,LED
00057 //N5110 lcd(p7,p8,p9,p10,p11,p13,p21);  // LPC1768 - pwr from GPIO
00058 N5110 lcd(p8,p9,p10,p11,p13,p21);  // LPC1768 - powered from +3V3 - JP1 in 2/3 position
00059 //N5110 lcd(PTC9,PTC0,PTC7,PTD2,PTD1,PTC11);  // K64F - pwr from 3V3
00060 
00061 int main()
00062 {
00063     // first need to initialise display
00064     lcd.init();
00065     
00066     // change set contrast in range 0.0 to 1.0
00067     // 0.4 appears to be a good starting point
00068     lcd.setContrast(0.4);
00069 
00070     while(1) {
00071 
00072         // these are default settings so not strictly needed
00073         lcd.normalMode();      // normal colour mode
00074 
00075         lcd.clear();
00076         // x origin, y origin, rows, cols, sprite
00077         lcd.drawSprite(20,6,8,5,(int *)sprite);
00078         lcd.refresh();
00079         wait(5.0);
00080 
00081         lcd.clear(); // clear buffer at start of every loop
00082         // can directly print strings at specified co-ordinates (must be less than 84 pixels to fit on display)
00083         lcd.printString("Hello, World!",0,0);
00084 
00085         char buffer[14];  // each character is 6 pixels wide, screen is 84 pixels (84/6 = 14)
00086         // so can display a string of a maximum 14 characters in length
00087         // or create formatted strings - ensure they aren't more than 14 characters long
00088         int temperature = 27;
00089         int length = sprintf(buffer,"T = %2d C",temperature); // print formatted data to buffer
00090         // it is important the format specifier ensures the length will fit in the buffer
00091         if (length <= 14)  // if string will fit on display (assuming printing at x=0)
00092             lcd.printString(buffer,0,1);           // display on screen
00093 
00094         float pressure = 1012.3;  // same idea with floats
00095         length = sprintf(buffer,"P = %.2f mb",pressure);
00096         if (length <= 14)
00097             lcd.printString(buffer,0,2);
00098 
00099         // can also print individual characters at specified place
00100         lcd.printChar('X',5,3);
00101 
00102         // draw a line across the display at y = 40 pixels (origin top-left)
00103         for (int i = 0; i < WIDTH; i++) {
00104             lcd.setPixel(i,40,true);
00105         }
00106         // need to refresh display after setting pixels or writing strings
00107         lcd.refresh();
00108         wait(5.0);
00109 
00110         // can check status of pixel using getPixel(x,y);
00111         lcd.clear();  // clear buffer
00112         lcd.setPixel(2,2,true);  // set random pixel in buffer
00113         lcd.refresh();
00114         wait(1.0);
00115 
00116         int pixel_to_test = lcd.getPixel(2,2);
00117 
00118         if ( pixel_to_test ) {
00119             lcd.printString("2,2 is set",0,4);
00120         }
00121 
00122         // this one shouldn't be set
00123         lcd.setPixel(3,3,false);  // clear random pixel in buffer
00124         lcd.refresh();
00125         pixel_to_test = lcd.getPixel(3,3);
00126 
00127         if ( pixel_to_test == 0 ) {
00128             lcd.printString("3,3 is clear",0,5);
00129         }
00130 
00131         lcd.refresh();
00132         wait(4.0);
00133 
00134         lcd.clear();            // clear buffer
00135         lcd.inverseMode();      // invert colours
00136         lcd.setBrightness(1.0); // put LED backlight on full
00137 
00138         float array[84];
00139 
00140         for (int i = 0; i < 84; i++) {
00141             array[i] = 0.5 + 0.5*sin(i*2*3.14/84);
00142         }
00143 
00144         // can also plot graphs - 84 elements only
00145         // values must be in range 0.0 - 1.0
00146         lcd.plotArray(array);
00147         lcd.refresh();
00148         wait(5.0);
00149 
00150         lcd.clear();
00151         lcd.normalMode();      // normal colour mode back
00152         lcd.setBrightness(0.5); // put LED backlight on 50%
00153 
00154         // example of drawing lines
00155         for (int x = 0; x < WIDTH ; x+=10) {
00156             // x0,y0,x1,y1,type 0-white,1-black,2-dotted
00157             lcd.drawLine(0,0,x,HEIGHT,2);
00158         }
00159         lcd.refresh();  // refresh after drawing shapes
00160         wait(5.0);
00161 
00162 
00163         lcd.clear();
00164         // example of how to draw circles
00165         lcd.drawCircle(WIDTH/2,HEIGHT/2,20,FILL_BLACK);  // x,y,radius,black fill
00166         lcd.drawCircle(WIDTH/2,HEIGHT/2,10,FILL_WHITE);  // x,y,radius,white fill
00167         lcd.drawCircle(WIDTH/2,HEIGHT/2,30,FILL_TRANSPARENT);  // x,y,radius,transparent with outline
00168         lcd.refresh();  // refresh after drawing shapes
00169         wait(5.0);
00170 
00171         lcd.clear();
00172         // example of how to draw rectangles
00173         //          origin x,y,width,height,type
00174         lcd.drawRect(10,10,50,30,FILL_BLACK);  // filled black rectangle
00175         lcd.drawRect(15,15,20,10,FILL_WHITE);  // filled white rectange (no outline)
00176         lcd.drawRect(2,2,70,40,FILL_TRANSPARENT);    // transparent, just outline
00177         lcd.refresh();  // refresh after drawing shapes
00178         wait(5.0);
00179 
00180     }
00181 }
00182 
00183 
00184 @endcode
00185 */
00186 class N5110
00187 {
00188 private:
00189 // objects
00190     SPI         *_spi;
00191     DigitalOut  *_led;
00192     DigitalOut  *_pwr;
00193     DigitalOut  *_sce;
00194     DigitalOut  *_rst;
00195     DigitalOut  *_dc;
00196 
00197 // variables
00198     unsigned char buffer[84][6];  // screen buffer - the 6 is for the banks - each one is 8 bits;
00199 
00200 public:
00201     /** Create a N5110 object connected to the specified pins
00202     *
00203     * @param pwr  Pin connected to Vcc on the LCD display (pin 1)
00204     * @param sce  Pin connected to chip enable (pin 3)
00205     * @param rst  Pin connected to reset (pin 4)
00206     * @param dc   Pin connected to data/command select (pin 5)
00207     * @param mosi Pin connected to data input (MOSI) (pin 6)
00208     * @param sclk Pin connected to serial clock (SCLK) (pin 7)
00209     * @param led  Pin connected to LED backlight (must be PWM) (pin 8)
00210     *
00211     */
00212     N5110(PinName const pwrPin,
00213           PinName const scePin,
00214           PinName const rstPin,
00215           PinName const dcPin,
00216           PinName const mosiPin,
00217           PinName const sclkPin,
00218           PinName const ledPin);
00219 
00220     /** Create a N5110 object connected to the specified pins (Vcc to +3V3)
00221     *
00222     * @param sce  Pin connected to chip enable (pin 3)
00223     * @param rst  Pin connected to reset (pin 4)
00224     * @param dc   Pin connected to data/command select (pin 5)
00225     * @param mosi Pin connected to data input (MOSI) (pin 6)
00226     * @param sclk Pin connected to serial clock (SCLK) (pin 7)
00227     * @param led  Pin connected to LED backlight (must be PWM) (pin 8)
00228     *
00229     */
00230     N5110(PinName const scePin,
00231           PinName const rstPin,
00232           PinName const dcPin,
00233           PinName const mosiPin,
00234           PinName const sclkPin,
00235           PinName const ledPin);
00236 
00237     /**
00238      * Free allocated memory when object goes out of scope
00239      */
00240     ~N5110();
00241 
00242     /** Initialise display
00243     *
00244     *   Powers up the display and turns on backlight (50% brightness default).
00245     *   Sets the display up in horizontal addressing mode and with normal video mode.
00246     */
00247     void init();
00248 
00249     /** Turn off
00250     *
00251     *   Powers down the display and turns of the backlight.
00252     *   Needs to be reinitialised before being re-used.
00253     */
00254     void turnOff();
00255 
00256     /** Clear
00257     *
00258     *   Clears the screen buffer.
00259     */
00260     void clear();
00261 
00262     /** Set screen constrast
00263     *   @param constrast - float in range 0.0 to 1.0 (0.40 to 0.60 is usually a good value)
00264     */
00265     void setContrast(float contrast);
00266     
00267     /** Turn on normal video mode (default)
00268     *  Black on white
00269     */
00270     void normalMode();
00271 
00272     /** Turn on inverse video mode (default)
00273     *  White on black
00274     */
00275     void inverseMode();
00276 
00277     /** Backlight On
00278     *
00279     *   Turns backlight on
00280     */
00281     void backLightOn();
00282 
00283     /** Set Brightness
00284     *
00285     * Turns backlight off
00286     */
00287     void backLightOff();
00288 
00289     /** Print String
00290     *
00291     *   Prints a string of characters to the screen buffer. String is cut-off after the 83rd pixel.
00292     *   @param x - the column number (0 to 83)
00293     *   @param y - the row number (0 to 5) - the display is split into 6 banks - each bank can be considered a row
00294     */
00295     void printString(char const         *str,
00296                      unsigned int const  x,
00297                      unsigned int const  y);
00298 
00299     /** Print Character
00300     *
00301     *   Sends a character to the screen buffer.  Printed at the specified location. Character is cut-off after the 83rd pixel.
00302     *   @param  c - the character to print. Can print ASCII as so printChar('C').
00303     *   @param x - the column number (0 to 83)
00304     *   @param y - the row number (0 to 5) - the display is split into 6 banks - each bank can be considered a row
00305     */
00306     void printChar(char const         c,
00307                    unsigned int const x,
00308                    unsigned int const y);
00309 
00310     /**
00311     * @brief Set a Pixel
00312     *
00313     * @param x     The x co-ordinate of the pixel (0 to 83)
00314     * @param y     The y co-ordinate of the pixel (0 to 47)
00315     * @param state The state of the pixel [true=black (default), false=white]
00316     *
00317     * @details This function sets the state of a pixel in the screen buffer.
00318     *          The third parameter can be omitted,
00319     */
00320     void setPixel(unsigned int const x,
00321                   unsigned int const y,
00322                   bool const         state = true);
00323 
00324     /**
00325     *  @brief Clear a Pixel
00326     *
00327     *   @param  x - the x co-ordinate of the pixel (0 to 83)
00328     *   @param  y - the y co-ordinate of the pixel (0 to 47)
00329     *
00330     *   @details This function clears pixel in the screen buffer
00331     *
00332     *   @deprecated Use setPixel(x, y, false) instead
00333     */
00334     void clearPixel(unsigned int const x,
00335                     unsigned int const y)
00336     __attribute__((deprecated("Use setPixel(x,y,false) instead")));
00337 
00338     /** Get a Pixel
00339     *
00340     *   This function gets the status of a pixel in the screen buffer.
00341     *   @param  x - the x co-ordinate of the pixel (0 to 83)
00342     *   @param  y - the y co-ordinate of the pixel (0 to 47)
00343     *   @returns
00344     *       0           - pixel is clear
00345     *       1    - pixel is set
00346     */
00347     int getPixel(unsigned int const x,
00348                  unsigned int const y) const;
00349 
00350     /** Refresh display
00351     *
00352     *   This functions sends the screen buffer to the display.
00353     */
00354     void refresh();
00355 
00356     /** Randomise buffer
00357     *
00358     *   This function fills the buffer with random data.  Can be used to test the display.
00359     *   A call to refresh() must be made to update the display to reflect the change in pixels.
00360     *   The seed is not set and so the generated pattern will probably be the same each time.
00361     *   TODO: Randomise the seed - maybe using the noise on the AnalogIn pins.
00362     */
00363     void randomiseBuffer();
00364 
00365     /** Plot Array
00366     *
00367     *   This function plots a one-dimensional array in the buffer.
00368     *   @param array[] - y values of the plot. Values should be normalised in the range 0.0 to 1.0. First 84 plotted.
00369     */
00370     void plotArray(float const array[]);
00371 
00372     /** Draw Circle
00373     *
00374     *   This function draws a circle at the specified origin with specified radius in the screen buffer
00375     *   Uses the midpoint circle algorithm.
00376     *   @see http://en.wikipedia.org/wiki/Midpoint_circle_algorithm
00377     *   @param  x0     - x-coordinate of centre
00378     *   @param  y0     - y-coordinate of centre
00379     *   @param  radius - radius of circle in pixels
00380     *   @param  fill   - fill-type for the shape
00381     */
00382     void drawCircle(unsigned int const x0,
00383                     unsigned int const y0,
00384                     unsigned int const radius,
00385                     FillType const     fill);
00386         
00387     /** Draw Ellipse
00388     *   @param  xc      - x-coordinate of centre
00389     *   @param  yc      - y-coordinate of centre
00390     *   @param  rx      - radius of the minor axis
00391     *   @param  ry      - radius of the major axis
00392     */
00393     void drawEllipse(unsigned int const xc,
00394                      unsigned int const yc,
00395                      unsigned int const rx,
00396                      unsigned int const ry);
00397               
00398     /** Draw Curve
00399     *   @param  curve_points    - all points that compose the curve
00400     *   @param  offset          - parameter for movememt illusion
00401     *   @param  dash_line       - lenght of the lines that compose the curve
00402     *   @param  type            - 0 white, 1 black
00403     */
00404     void drawCurve(std::vector<Vector2Df> curve_points, 
00405                    float offset, 
00406                    int dash_len, 
00407                    int type);
00408 
00409     /** Draw Line
00410     *
00411     *   This function draws a line between the specified points using linear interpolation.
00412     *   @param  x0      - x-coordinate of first point
00413     *   @param  y0      - y-coordinate of first point
00414     *   @param  x1      - x-coordinate of last point
00415     *   @param  y1      - y-coordinate of last point
00416     *   @param  offset  - moved from position 
00417     *   @param  step    - 0 white, 1 black, >= 2 dotted
00418     */
00419     void drawLine(unsigned int const x0,
00420                   unsigned int const y0,
00421                   unsigned int const x1,
00422                   unsigned int const y1,
00423                   unsigned int const offset,
00424                   unsigned int const step);
00425 
00426     /** Draw Rectangle
00427     *
00428     *   This function draws a rectangle.
00429     *   @param  x0 - x-coordinate of origin (top-left)
00430     *   @param  y0 - y-coordinate of origin (top-left)
00431     *   @param  width - width of rectangle
00432     *   @param  height - height of rectangle
00433     *   @param  fill   - fill-type for the shape
00434     */
00435     void drawRect(unsigned int const x0,
00436                   unsigned int const y0,
00437                   unsigned int const width,
00438                   unsigned int const height,
00439                   FillType const     fill);
00440 
00441     /** Draw Sprite
00442     *
00443     *   This function draws a sprite as defined in a 2D array
00444     *   @param  x0 - x-coordinate of origin (top-left)
00445     *   @param  y0 - y-coordinate of origin (top-left)
00446     *   @param  nrows - number of rows in sprite
00447     *   @param  ncols - number of columns in sprite
00448     *   @param  sprite - 2D array representing the sprite
00449     */
00450     void drawSprite(int x0,
00451                     int y0,
00452                     int nrows,
00453                     int ncols,
00454                     int *sprite);
00455 
00456 
00457 private:
00458 // methods
00459     void setXYAddress(unsigned int const x,
00460                       unsigned int const y);
00461     void initSPI();
00462     void turnOn();
00463     void reset();
00464     void clearRAM();
00465     void sendCommand(unsigned char command);
00466     void sendData(unsigned char data);
00467     void setTempCoefficient(char tc);  // 0 to 3
00468     void setBias(char bias);  // 0 to 7
00469 };
00470 
00471 const unsigned char font5x7[480] = {
00472     0x00, 0x00, 0x00, 0x00, 0x00,// (space)
00473     0x00, 0x00, 0x5F, 0x00, 0x00,// !
00474     0x00, 0x07, 0x00, 0x07, 0x00,// "
00475     0x14, 0x7F, 0x14, 0x7F, 0x14,// #
00476     0x24, 0x2A, 0x7F, 0x2A, 0x12,// $
00477     0x23, 0x13, 0x08, 0x64, 0x62,// %
00478     0x36, 0x49, 0x55, 0x22, 0x50,// &
00479     0x00, 0x05, 0x03, 0x00, 0x00,// '
00480     0x00, 0x1C, 0x22, 0x41, 0x00,// (
00481     0x00, 0x41, 0x22, 0x1C, 0x00,// )
00482     0x08, 0x2A, 0x1C, 0x2A, 0x08,// *
00483     0x08, 0x08, 0x3E, 0x08, 0x08,// +
00484     0x00, 0x50, 0x30, 0x00, 0x00,// ,
00485     0x08, 0x08, 0x08, 0x08, 0x08,// -
00486     0x00, 0x60, 0x60, 0x00, 0x00,// .
00487     0x20, 0x10, 0x08, 0x04, 0x02,// /
00488     0x3E, 0x51, 0x49, 0x45, 0x3E,// 0
00489     0x00, 0x42, 0x7F, 0x40, 0x00,// 1
00490     0x42, 0x61, 0x51, 0x49, 0x46,// 2
00491     0x21, 0x41, 0x45, 0x4B, 0x31,// 3
00492     0x18, 0x14, 0x12, 0x7F, 0x10,// 4
00493     0x27, 0x45, 0x45, 0x45, 0x39,// 5
00494     0x3C, 0x4A, 0x49, 0x49, 0x30,// 6
00495     0x01, 0x71, 0x09, 0x05, 0x03,// 7
00496     0x36, 0x49, 0x49, 0x49, 0x36,// 8
00497     0x06, 0x49, 0x49, 0x29, 0x1E,// 9
00498     0x00, 0x36, 0x36, 0x00, 0x00,// :
00499     0x00, 0x56, 0x36, 0x00, 0x00,// ;
00500     0x00, 0x08, 0x14, 0x22, 0x41,// <
00501     0x14, 0x14, 0x14, 0x14, 0x14,// =
00502     0x41, 0x22, 0x14, 0x08, 0x00,// >
00503     0x02, 0x01, 0x51, 0x09, 0x06,// ?
00504     0x32, 0x49, 0x79, 0x41, 0x3E,// @
00505     0x7E, 0x11, 0x11, 0x11, 0x7E,// A
00506     0x7F, 0x49, 0x49, 0x49, 0x36,// B
00507     0x3E, 0x41, 0x41, 0x41, 0x22,// C
00508     0x7F, 0x41, 0x41, 0x22, 0x1C,// D
00509     0x7F, 0x49, 0x49, 0x49, 0x41,// E
00510     0x7F, 0x09, 0x09, 0x01, 0x01,// F
00511     0x3E, 0x41, 0x41, 0x51, 0x32,// G
00512     0x7F, 0x08, 0x08, 0x08, 0x7F,// H
00513     0x00, 0x41, 0x7F, 0x41, 0x00,// I
00514     0x20, 0x40, 0x41, 0x3F, 0x01,// J
00515     0x7F, 0x08, 0x14, 0x22, 0x41,// K
00516     0x7F, 0x40, 0x40, 0x40, 0x40,// L
00517     0x7F, 0x02, 0x04, 0x02, 0x7F,// M
00518     0x7F, 0x04, 0x08, 0x10, 0x7F,// N
00519     0x3E, 0x41, 0x41, 0x41, 0x3E,// O
00520     0x7F, 0x09, 0x09, 0x09, 0x06,// P
00521     0x3E, 0x41, 0x51, 0x21, 0x5E,// Q
00522     0x7F, 0x09, 0x19, 0x29, 0x46,// R
00523     0x46, 0x49, 0x49, 0x49, 0x31,// S
00524     0x01, 0x01, 0x7F, 0x01, 0x01,// T
00525     0x3F, 0x40, 0x40, 0x40, 0x3F,// U
00526     0x1F, 0x20, 0x40, 0x20, 0x1F,// V
00527     0x7F, 0x20, 0x18, 0x20, 0x7F,// W
00528     0x63, 0x14, 0x08, 0x14, 0x63,// X
00529     0x03, 0x04, 0x78, 0x04, 0x03,// Y
00530     0x61, 0x51, 0x49, 0x45, 0x43,// Z
00531     0x00, 0x00, 0x7F, 0x41, 0x41,// [
00532     0x02, 0x04, 0x08, 0x10, 0x20,// "\"
00533     0x41, 0x41, 0x7F, 0x00, 0x00,// ]
00534     0x04, 0x02, 0x01, 0x02, 0x04,// ^
00535     0x40, 0x40, 0x40, 0x40, 0x40,// _
00536     0x00, 0x01, 0x02, 0x04, 0x00,// `
00537     0x20, 0x54, 0x54, 0x54, 0x78,// a
00538     0x7F, 0x48, 0x44, 0x44, 0x38,// b
00539     0x38, 0x44, 0x44, 0x44, 0x20,// c
00540     0x38, 0x44, 0x44, 0x48, 0x7F,// d
00541     0x38, 0x54, 0x54, 0x54, 0x18,// e
00542     0x08, 0x7E, 0x09, 0x01, 0x02,// f
00543     0x08, 0x14, 0x54, 0x54, 0x3C,// g
00544     0x7F, 0x08, 0x04, 0x04, 0x78,// h
00545     0x00, 0x44, 0x7D, 0x40, 0x00,// i
00546     0x20, 0x40, 0x44, 0x3D, 0x00,// j
00547     0x00, 0x7F, 0x10, 0x28, 0x44,// k
00548     0x00, 0x41, 0x7F, 0x40, 0x00,// l
00549     0x7C, 0x04, 0x18, 0x04, 0x78,// m
00550     0x7C, 0x08, 0x04, 0x04, 0x78,// n
00551     0x38, 0x44, 0x44, 0x44, 0x38,// o
00552     0x7C, 0x14, 0x14, 0x14, 0x08,// p
00553     0x08, 0x14, 0x14, 0x18, 0x7C,// q
00554     0x7C, 0x08, 0x04, 0x04, 0x08,// r
00555     0x48, 0x54, 0x54, 0x54, 0x20,// s
00556     0x04, 0x3F, 0x44, 0x40, 0x20,// t
00557     0x3C, 0x40, 0x40, 0x20, 0x7C,// u
00558     0x1C, 0x20, 0x40, 0x20, 0x1C,// v
00559     0x3C, 0x40, 0x30, 0x40, 0x3C,// w
00560     0x44, 0x28, 0x10, 0x28, 0x44,// x
00561     0x0C, 0x50, 0x50, 0x50, 0x3C,// y
00562     0x44, 0x64, 0x54, 0x4C, 0x44,// z
00563     0x00, 0x08, 0x36, 0x41, 0x00,// {
00564     0x00, 0x00, 0x7F, 0x00, 0x00,// |
00565     0x00, 0x41, 0x36, 0x08, 0x00,// }
00566     0x08, 0x08, 0x2A, 0x1C, 0x08,// ->
00567     0x08, 0x1C, 0x2A, 0x08, 0x08 // <-
00568 };
00569 
00570 #endif