/***************************************************************************//** * @file ST7579.c * @brief Implementation of ST7579 Driver. * @author DBogdan (dragos.bogdan@analog.com) ******************************************************************************** * Copyright 2012(c) Analog Devices, Inc. * * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * - Neither the name of Analog Devices, Inc. nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * - The use of this software may or may not infringe the patent rights * of one or more patent holders. This license does not release you * from the requirement that you obtain separate licenses from these * patent holders to use this software. * - Use of the software either in source or binary form, must be run * on or directly connected to an Analog Devices Inc. component. * * THIS SOFTWARE IS PROVIDED BY ANALOG DEVICES "AS IS" AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, NON-INFRINGEMENT, * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL ANALOG DEVICES BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, INTELLECTUAL PROPERTY RIGHTS, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ******************************************************************************** * SVN Revision: $WCREV$ *******************************************************************************/ /******************************************************************************/ /***************************** Include Files **********************************/ /******************************************************************************/ #include "ST7579.h" // ST7579 definitions #include "RDKRL78G14.h" // YRDKRL78G14 definitions #include "Communication.h" // Communication definitions /******************************************************************************/ /************************* Variables Definitions ******************************/ /******************************************************************************/ const unsigned char st7579Font[95][5] = { {0x00, 0x00, 0x00, 0x00, 0x00}, // sp {0x00, 0x00, 0x2f, 0x00, 0x00}, // ! {0x00, 0x07, 0x00, 0x07, 0x00}, // " {0x14, 0x7f, 0x14, 0x7f, 0x14}, // # {0x24, 0x2a, 0x7f, 0x2a, 0x12}, // $ {0xc4, 0xc8, 0x10, 0x26, 0x46}, // % {0x36, 0x49, 0x55, 0x22, 0x50}, // & {0x00, 0x05, 0x03, 0x00, 0x00}, // ' {0x00, 0x1c, 0x22, 0x41, 0x00}, // ( {0x00, 0x41, 0x22, 0x1c, 0x00}, // ) {0x14, 0x08, 0x3E, 0x08, 0x14}, // * {0x08, 0x08, 0x3E, 0x08, 0x08}, // + {0x00, 0x00, 0x50, 0x30, 0x00}, // , {0x10, 0x10, 0x10, 0x10, 0x10}, // - {0x00, 0x60, 0x60, 0x00, 0x00}, // . {0x20, 0x10, 0x08, 0x04, 0x02}, // / {0x3E, 0x51, 0x49, 0x45, 0x3E}, // 0 {0x00, 0x42, 0x7F, 0x40, 0x00}, // 1 {0x42, 0x61, 0x51, 0x49, 0x46}, // 2 {0x21, 0x41, 0x45, 0x4B, 0x31}, // 3 {0x18, 0x14, 0x12, 0x7F, 0x10}, // 4 {0x27, 0x45, 0x45, 0x45, 0x39}, // 5 {0x3C, 0x4A, 0x49, 0x49, 0x30}, // 6 {0x01, 0x71, 0x09, 0x05, 0x03}, // 7 {0x36, 0x49, 0x49, 0x49, 0x36}, // 8 {0x06, 0x49, 0x49, 0x29, 0x1E}, // 9 {0x00, 0x36, 0x36, 0x00, 0x00}, // : {0x00, 0x56, 0x36, 0x00, 0x00}, // ; {0x08, 0x14, 0x22, 0x41, 0x00}, // < {0x14, 0x14, 0x14, 0x14, 0x14}, // = {0x00, 0x41, 0x22, 0x14, 0x08}, // > {0x02, 0x01, 0x51, 0x09, 0x06}, // ? {0x32, 0x49, 0x59, 0x51, 0x3E}, // @ {0x7E, 0x11, 0x11, 0x11, 0x7E}, // A {0x7F, 0x49, 0x49, 0x49, 0x36}, // B {0x3E, 0x41, 0x41, 0x41, 0x22}, // C {0x7F, 0x41, 0x41, 0x22, 0x1C}, // D {0x7F, 0x49, 0x49, 0x49, 0x41}, // E {0x7F, 0x09, 0x09, 0x09, 0x01}, // F {0x3E, 0x41, 0x49, 0x49, 0x7A}, // G {0x7F, 0x08, 0x08, 0x08, 0x7F}, // H {0x00, 0x41, 0x7F, 0x41, 0x00}, // I {0x20, 0x40, 0x41, 0x3F, 0x01}, // J {0x7F, 0x08, 0x14, 0x22, 0x41}, // K {0x7F, 0x40, 0x40, 0x40, 0x40}, // L {0x7F, 0x02, 0x0C, 0x02, 0x7F}, // M {0x7F, 0x04, 0x08, 0x10, 0x7F}, // N {0x3E, 0x41, 0x41, 0x41, 0x3E}, // O {0x7F, 0x09, 0x09, 0x09, 0x06}, // P {0x3E, 0x41, 0x51, 0x21, 0x5E}, // Q {0x7F, 0x09, 0x19, 0x29, 0x46}, // R {0x46, 0x49, 0x49, 0x49, 0x31}, // S {0x01, 0x01, 0x7F, 0x01, 0x01}, // T {0x3F, 0x40, 0x40, 0x40, 0x3F}, // U {0x1F, 0x20, 0x40, 0x20, 0x1F}, // V {0x3F, 0x40, 0x38, 0x40, 0x3F}, // W {0x63, 0x14, 0x08, 0x14, 0x63}, // X {0x07, 0x08, 0x70, 0x08, 0x07}, // Y {0x61, 0x51, 0x49, 0x45, 0x43}, // Z {0x00, 0x7F, 0x41, 0x41, 0x00}, // [ {0x55, 0x2A, 0x55, 0x2A, 0x55}, // / {0x00, 0x41, 0x41, 0x7F, 0x00}, // ] {0x04, 0x02, 0x01, 0x02, 0x04}, // ^ {0x40, 0x40, 0x40, 0x40, 0x40}, // _ {0x00, 0x01, 0x02, 0x04, 0x00}, // ' {0x20, 0x54, 0x54, 0x54, 0x78}, // a {0x7F, 0x48, 0x44, 0x44, 0x38}, // b {0x38, 0x44, 0x44, 0x44, 0x20}, // c {0x38, 0x44, 0x44, 0x48, 0x7F}, // d {0x38, 0x54, 0x54, 0x54, 0x18}, // e {0x08, 0x7E, 0x09, 0x01, 0x02}, // f {0x0C, 0x52, 0x52, 0x52, 0x3E}, // g {0x7F, 0x08, 0x04, 0x04, 0x78}, // h {0x00, 0x44, 0x7D, 0x40, 0x00}, // i {0x20, 0x40, 0x44, 0x3D, 0x00}, // j {0x7F, 0x10, 0x28, 0x44, 0x00}, // k {0x00, 0x41, 0x7F, 0x40, 0x00}, // l {0x7C, 0x04, 0x18, 0x04, 0x78}, // m {0x7C, 0x08, 0x04, 0x04, 0x78}, // n {0x38, 0x44, 0x44, 0x44, 0x38}, // o {0x7C, 0x14, 0x14, 0x14, 0x08}, // p {0x08, 0x14, 0x14, 0x18, 0x7C}, // q {0x7C, 0x08, 0x04, 0x04, 0x08}, // r {0x48, 0x54, 0x54, 0x54, 0x20}, // s {0x04, 0x3F, 0x44, 0x40, 0x20}, // t {0x3C, 0x40, 0x40, 0x20, 0x7C}, // u {0x1C, 0x20, 0x40, 0x20, 0x1C}, // v {0x3C, 0x40, 0x30, 0x40, 0x3C}, // w {0x44, 0x28, 0x10, 0x28, 0x44}, // x {0x0C, 0x50, 0x50, 0x50, 0x3C}, // y {0x44, 0x64, 0x54, 0x4C, 0x44}, // z {0x08, 0x3e, 0x41, 0x41, 0x00}, // { {0x00, 0x00, 0x77, 0x00, 0x00}, // | {0x00, 0x41, 0x41, 0x3e, 0x08}, // } {0x02, 0x01, 0x02, 0x01, 0x00} // ~ }; /******************************************************************************/ /************************ Functions Definitions *******************************/ /******************************************************************************/ /***************************************************************************//** * @brief Transmits 8 bits to ST7579 controller. * * @param data - Data to transmit. * * @return None. *******************************************************************************/ void ST7579_WriteByte(unsigned char data) { SPI_Write(3, // The ID of the selected slave device. &data, // Write buffer. 1); // Number of bytes to write. } /***************************************************************************//** * @brief Sets X and Y adress of RAM. * * @param yPosition - Y address of RAM. * @param xPosition - X address of RAM. * * @return None. *******************************************************************************/ void ST7579_GoTo(unsigned char yPosition, unsigned char xPosition) { ST7579_RS_LOW; /* Set X address of RAM. */ ST7579_WriteByte(0x28); ST7579_WriteByte(0x80 + xPosition); /* Set Y address of RAM. */ ST7579_WriteByte(0x28); ST7579_WriteByte(0x40 + yPosition); ST7579_RS_HIGH; } /***************************************************************************//** * @brief Clears ST7579 RAM. * * @return None. *******************************************************************************/ void ST7579_Clear(void) { unsigned short clearPosition = 0; unsigned char yPosition = 0; for(clearPosition = 0; clearPosition < (8 * 96); clearPosition++) { if(!(clearPosition % 96)) { /* Set the X and Y address of RAM. */ ST7579_GoTo(yPosition, 0); yPosition++; } ST7579_WriteByte(0x00); } } /***************************************************************************//** * @brief Initializes the ST7579 controller. * * @return status - Result of the initialization procedure. * Example: 1 - if initialization was successful; * 0 - if initialization was unsuccessful. *******************************************************************************/ unsigned char ST7579_Init(void) { unsigned char status = 0; unsigned short delay = 0; status = SPI_Init(0, // Transfer format. 1000000, // SPI clock frequency. 0, // SPI clock polarity. 1); // SPI clock edge. if(status != 1) { return status; } ST7579_RS_OUT; ST7579_RS_LOW; /* Select LCD bias ratio of the voltage required for driving the LCD. */ ST7579_WriteByte(0x21); ST7579_WriteByte(0x16); /* Select Booster efficiency and Booster stage. */ ST7579_WriteByte(0x23); ST7579_WriteByte(0x99); /* Set V0 Range. */ ST7579_WriteByte(0x20); ST7579_WriteByte(0x04); /* 50 ms delay is recommended. */ for(delay = 0; delay < 1000; delay++) { asm("NOP"); } /* Set the frame frequency */ ST7579_WriteByte(0x23); ST7579_WriteByte(0x0C); /* Set V0. */ ST7579_WriteByte(0x21); ST7579_WriteByte(0xE7); /* Select the display mode */ ST7579_WriteByte(0x20); ST7579_WriteByte(0x0C); ST7579_RS_HIGH; /* Clear RAM. */ ST7579_Clear(); return status; } /***************************************************************************//** * @brief Sends a character to ST7579 controller. * * @param yPosition - Y address of RAM. * @param xPosition - X address of RAM. * @param character - The character. * @param bigFont - Big font selection. * * @return None. *******************************************************************************/ void ST7579_Char(unsigned char yPosition, unsigned char xPosition, unsigned char character, unsigned char bigFont) { unsigned char column = 0; unsigned char data = 0; if(bigFont) { /* Set the X and Y address of RAM. */ ST7579_GoTo(yPosition, xPosition); /* Send character data. */ for(column = 0; column < 5; column++) { data = st7579Font[character - 32][column]; data = ((data & 0x01) ? 0x03 : 0) | ((data & 0x02) ? 0x0C : 0) | ((data & 0x04) ? 0x30 : 0) | ((data & 0x08) ? 0xC0 : 0); ST7579_WriteByte(data); ST7579_WriteByte(data); ST7579_WriteByte(data); } ST7579_WriteByte(0); ST7579_WriteByte(0); ST7579_WriteByte(0); yPosition++; /* Set the X and Y address of RAM. */ ST7579_GoTo(yPosition, xPosition); /* Send character data. */ for(column = 0; column < 5; column++) { data = st7579Font[character - 32][column]; data = ((data & 0x10) ? 0x03 : 0) | ((data & 0x20) ? 0x0C : 0) | ((data & 0x40) ? 0x30 : 0) | ((data & 0x80) ? 0xC0 : 0); ST7579_WriteByte(data); ST7579_WriteByte(data); ST7579_WriteByte(data); } ST7579_WriteByte(0); ST7579_WriteByte(0); ST7579_WriteByte(0); } else { /* Set the X and Y address of RAM. */ ST7579_GoTo(yPosition, xPosition); /* Send character data. */ for(column = 0; column < 5; column++) { ST7579_WriteByte(st7579Font[character - 32][column] << 1); } ST7579_WriteByte(0x00); } } /***************************************************************************//** * @brief Sends a string to ST7579 controller. * * @param yPosition - Y address of RAM. * @param xPosition - X address of RAM. * @param string - The string. * @param bigFont - Big font selection. * * @return None. *******************************************************************************/ void ST7579_String(unsigned char yPosition, unsigned char xPosition, unsigned char* string, unsigned char bigFont) { while(*string) { /* Send each character of the string. */ ST7579_Char(yPosition, xPosition, *string++, bigFont); xPosition += 6 + (bigFont * 12); } } /***************************************************************************//** * @brief Sends an integer number to ST7579 controller. * * @param yPosition - Y address of RAM. * @param xPosition - X address of RAM. * @param number - The number. * @param bigFont - Big font selection. * * @return None. *******************************************************************************/ void ST7579_Number(unsigned char yPosition, unsigned char xPosition, long number, unsigned char bigFont) { unsigned long mask = 1000000000; unsigned char chNumber = 10; unsigned char chIndex = 0; //bigFont = 0; if(number < 0) { ST7579_Char(yPosition, xPosition, '-', bigFont); xPosition += 6 + (bigFont * 12); number *= -1; } else { if(number == 0) { ST7579_String(yPosition, xPosition, " 0", bigFont); } else { ST7579_Char(yPosition, xPosition, '+', bigFont); xPosition += 6 + (bigFont * 12); } } while(mask > number) { mask /= 10; chNumber--; } for(chIndex = 0; chIndex < chNumber; chIndex++) { ST7579_Char(yPosition, xPosition, ((number / mask) % 10) + 0x30, bigFont); mask /= 10; xPosition += 6 + (bigFont * 12); } } /***************************************************************************//** * @brief Sends a float number to ST7579 controller. * * @param yPosition - Y address of RAM. * @param xPosition - X address of RAM. * @param number - The number. * @param resolution - Float resolution. * @param bigFont - Big font selection. * * @return None. *******************************************************************************/ void ST7579_FloatNumber(unsigned char yPosition, unsigned char xPosition, float number, unsigned char resolution, unsigned char bigFont) { unsigned long mask = 1000000000; unsigned char chNumber = 10; unsigned char index = 0; long display = 1; long multiplication = 1; for(index = 0; index < resolution; index++) { multiplication *= 10; } display = (long)(number * multiplication); if(display < 0) { ST7579_Char(yPosition, xPosition, '-', bigFont); xPosition += 6 + (bigFont * 12); number *= -1; } else { if(display == 0) { xPosition += 6 + (bigFont * 12); ST7579_Char(yPosition, xPosition, '0', bigFont); xPosition += 6 + (bigFont * 12); if(resolution) { ST7579_Char(yPosition, xPosition, '.', bigFont); xPosition += 6 + (bigFont * 12); } for(index = 0; index < resolution; index++) { ST7579_Char(yPosition, xPosition, '0', bigFont); xPosition += 6 + (bigFont * 12); } } else { ST7579_Char(yPosition, xPosition, '+', bigFont); xPosition += 6 + (bigFont * 12); } } while(mask > display) { mask /= 10; chNumber--; } if((display > 0) && (display < multiplication)) { ST7579_String(yPosition, xPosition, "0.", bigFont); xPosition += 12 + (bigFont * 24); } for(index = 0; index < chNumber; index++) { ST7579_Char(yPosition, xPosition, ((display / mask) % 10) + 0x30, bigFont); mask /= 10; xPosition += 6 + (bigFont * 12); if((multiplication != 1) && (mask == (multiplication / 10))) { ST7579_Char(yPosition, xPosition, '.', bigFont); xPosition += 6 + (bigFont * 12); } } } /***************************************************************************//** * @brief Sends an integer number in Hexa format to ST7579 controller. * * @param yPosition - Y address of RAM. * @param xPosition - X address of RAM. * @param number - The number. * @param bigFont - Big font selection. * * @return None. *******************************************************************************/ void ST7579_HexNumber(unsigned char yPosition, unsigned char xPosition, long number, unsigned char bigFont) { unsigned long long mask = 268435456; unsigned char chNumber = 8; unsigned char chIndex = 0; unsigned char display = 0; ST7579_String(yPosition, xPosition, "0x", bigFont); xPosition += (6 + (bigFont * 12)) * 2; if(number == 0) { ST7579_Char(yPosition, xPosition, '0', bigFont); } while(mask > number) { mask /= 16; chNumber--; } for(chIndex = 0; chIndex < chNumber; chIndex++) { display = (number / mask) % 16; mask /= 16; if(display <= 9) { display += 0x30; } else { display += 0x37; } ST7579_Char(yPosition, xPosition, display, bigFont); xPosition += 6 + (bigFont * 12); } } /***************************************************************************//** * @brief Sends an image array to ST7579 controller. * * @param yPosition - Y address of RAM. * @param xPosition - X address of RAM. * @param image - The image array. * @param width - The width of the image (pixels). * @param height - The height of the image (pixels). * * @return None. *******************************************************************************/ void ST7579_Image(unsigned char yPosition, unsigned char xPosition, const unsigned char image[], unsigned char width, unsigned char height) { unsigned short index = 0; for(index = 0; index < (width * height / 8); index++) { if(!(index % width)) { /* Set the X and Y address of RAM. */ ST7579_GoTo(yPosition, xPosition); yPosition ++; } ST7579_WriteByte(image[index]); } }