569 lines
19 KiB
C
569 lines
19 KiB
C
/***************************************************************************//**
|
|
* @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: 0 - if initialization was successful;
|
|
* -1 - if initialization was unsuccessful.
|
|
*******************************************************************************/
|
|
char ST7579_Init(void)
|
|
{
|
|
char status = -1;
|
|
unsigned short delay = 0;
|
|
|
|
status = SPI_Init(0, // Transfer format.
|
|
1000000, // SPI clock frequency.
|
|
0, // SPI clock polarity.
|
|
1); // SPI clock edge.
|
|
if(status != 0)
|
|
{
|
|
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;
|
|
|
|
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);
|
|
display *= -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);
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
ST7579_Char(yPosition, xPosition, '+', bigFont);
|
|
xPosition += 6 + (bigFont * 12);
|
|
}
|
|
}
|
|
while((mask > display) && (chNumber > resolution))
|
|
{
|
|
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]);
|
|
}
|
|
}
|