//*****************************************************************************
//
//! Clears the OLED display.
//!
//! This function will clear the display. All pixels in the display will be
//! turned off.
//!
//! \return None.
//
//*****************************************************************************
void
Display96x16x1Clear(void)
{
unsigned long ulIdx;
//
// Move the display cursor to the first column of the first row.
//
Display96x16x1WriteFirst(0x80);
Display96x16x1WriteArray(g_pucRow1, SIZE_CURSOR_ROW_COMMAND);
//
// Fill this row with zeros.
//
for(ulIdx = 0; ulIdx < 95; ulIdx++)
{
Display96x16x1WriteByte(0x00);
}
Display96x16x1WriteFinal(0x00);
//
// Move the display cursor to the first column of the second row.
//
Display96x16x1WriteFirst(0x80);
Display96x16x1WriteArray(g_pucRow2, SIZE_CURSOR_ROW_COMMAND);
//
// Fill this row with zeros.
//
for(ulIdx = 0; ulIdx < 95; ulIdx++)
{
Display96x16x1WriteByte(0x00);
}
Display96x16x1WriteFinal(0x00);
}
//*****************************************************************************
//
//! Turns off the OLED display.
//!
//! This function will turn off the OLED display. This will stop the scanning
//! of the panel and turn off the on-chip DC-DC converter, preventing damage to
//! the panel due to burn-in (it has similar characters to a CRT in this
//! respect).
//!
//! \return None.
//
//*****************************************************************************
void
Display96x16x1DisplayOff(void)
{
//
// Turn off the DC-DC converter and the display.
//
Display96x16x1WriteFirst(0x80);
Display96x16x1WriteByte(0xae);
Display96x16x1WriteByte(0x80);
Display96x16x1WriteByte(0xad);
Display96x16x1WriteByte(0x80);
Display96x16x1WriteFinal(0x8a);
}
//*****************************************************************************
//
//! Displays an image on the OLED display.
//!
//! \param pucImage is a pointer to the image data.
//! \param ulX is the horizontal position to display this image, specified in
//! columns from the left edge of the display.
//! \param ulY is the vertical position to display this image, specified in
//! eight scan line blocks from the top of the display (that is, only 0 and 1
//! are valid).
//! \param ulWidth is the width of the image, specified in columns.
//! \param ulHeight is the height of the image, specified in eight row blocks
//! (that is, only 1 and 2 are valid).
//!
//! This function will display a bitmap graphic on the display. The image to
//! be displayed must be a multiple of eight scan lines high (that is, one row)
//! and will be drawn at a vertical position that is a multiple of eight scan
//! lines (that is, scan line zero or scan line eight, corresponding to row
//! zero or row one).
//!
//! The image data is organized with the first row of image data appearing left
//! to right, followed immediately by the second row of image data. Each byte
//! contains the data for the eight scan lines of the column, with the top scan
//! line being in the least significant bit of the byte and the bottom scan
//! line being in the most significant bit of the byte.
//!
//! For example, an image four columns wide and sixteen scan lines tall would
//! be arranged as follows (showing how the eight bytes of the image would
//! appear on the display):
//!
//! \verbatim
//! +-------+ +-------+ +-------+ +-------+
//! | | 0 | | | 0 | | | 0 | | | 0 |
//! | B | 1 | | B | 1 | | B | 1 | | B | 1 |
//! | y | 2 | | y | 2 | | y | 2 | | y | 2 |
//! | t | 3 | | t | 3 | | t | 3 | | t | 3 |
//! | e | 4 | | e | 4 | | e | 4 | | e | 4 |
//! | | 5 | | | 5 | | | 5 | | | 5 |
//! | 0 | 6 | | 1 | 6 | | 2 | 6 | | 3 | 6 |
//! | | 7 | | | 7 | | | 7 | | | 7 |
//! +-------+ +-------+ +-------+ +-------+
//!
//! +-------+ +-------+ +-------+ +-------+
//! | | 0 | | | 0 | | | 0 | | | 0 |
//! | B | 1 | | B | 1 | | B | 1 | | B | 1 |
//! | y | 2 | | y | 2 | | y | 2 | | y | 2 |
//! | t | 3 | | t | 3 | | t | 3 | | t | 3 |
//! | e | 4 | | e | 4 | | e | 4 | | e | 4 |
//! | | 5 | | | 5 | | | 5 | | | 5 |
//! | 4 | 6 | | 5 | 6 | | 6 | 6 | | 7 | 6 |
//! | | 7 | | | 7 | | | 7 | | | 7 |
//! +-------+ +-------+ +-------+ +-------+
//! \endverbatim
//!
//! \return None.
//
//*****************************************************************************
void
Display96x16x1ImageDraw(const unsigned char *pucImage, unsigned long ulX,
unsigned long ulY, unsigned long ulWidth,
unsigned long ulHeight)
{
//
// Check the arguments.
//
ASSERT(ulX < 96);
ASSERT(ulY < 2);
ASSERT((ulX + ulWidth) <= 96);
ASSERT((ulY + ulHeight) <= 2);
//
// The first few columns of the LCD buffer are not displayed, so increment
// the X coorddinate by this amount to account for the non-displayed frame
// buffer memory.
//
ulX += g_ucColumnAdjust;
//
// Loop while there are more rows to display.
//
while(ulHeight--)
{
//
// Write the starting address within this row.
//
Display96x16x1WriteFirst(0x80);
Display96x16x1WriteByte((ulY == 0) ? 0xb0 : 0xb1);
Display96x16x1WriteByte(0x80);
Display96x16x1WriteByte(ulX & 0x0f);
Display96x16x1WriteByte(0x80);
Display96x16x1WriteByte(0x10 | ((ulX >> 4) & 0x0f));
Display96x16x1WriteByte(0x40);
//
// Write this row of image data.
//
Display96x16x1WriteArray(pucImage, ulWidth - 1);
Display96x16x1WriteFinal(pucImage[ulWidth - 1]);
//
// Advance to the next row of the image.
//
pucImage += ulWidth;
ulY++;
}
}
//*****************************************************************************
//
//! Clears a single line on the OLED display.
//!
//! \param ulY is the display line to be cleared, 0 or 1.
//!
//! This function will clear one text line of the display.
//!
//! \return None.
//
//*****************************************************************************
void
Display96x16x1ClearLine(unsigned long ulY)
{
unsigned long ulIdx;
//
// Move the display cursor to the first column of the specified row.
//
Display96x16x1WriteFirst(0x80);
Display96x16x1WriteArray(ulY ? g_pucRITRow2 : g_pucRITRow1,
sizeof(g_pucRITRow1));
//
// Fill this row with zeros.
//
for(ulIdx = 0; ulIdx < 95; ulIdx++)
{
Display96x16x1WriteByte(0x00);
}
Display96x16x1WriteFinal(0x00);
}
//*****************************************************************************
//
//! Displays a string on the OLED display.
//!
//! \param pcStr is a pointer to the string to display.
//! \param ulX is the horizontal position to display the string, specified in
//! columns from the left edge of the display.
//! \param ulY is the vertical position to display the string, specified in
//! eight scan line blocks from the top of the display (that is, only 0 and 1
//! are valid).
//!
//! This function will draw a string on the display. Only the ASCII characters
//! between 32 (space) and 126 (tilde) are supported; other characters will
//! result in random data being draw on the display (based on whatever appears
//! before/after the font in memory). The font is mono-spaced, so characters
//! such as ``i'' and ``l'' have more white space around them than characters
//! such as ``m'' or ``w''.
//!
//! If the drawing of the string reaches the right edge of the display, no more
//! characters will be drawn. Therefore, special care is not required to avoid
//! supplying a string that is ``too long'' to display.
//!
//! \return None.
//
//*****************************************************************************
void
Display96x16x1StringDraw(const char *pcStr, unsigned long ulX, unsigned long ulY)
{
//
// Check the arguments.
//
ASSERT(ulX < 96);
ASSERT(ulY < 2);
//
// Move the display cursor to the requested position on the display.
//
Display96x16x1WriteFirst(0x80);
Display96x16x1WriteByte((ulY == 0) ? 0xb0 : 0xb1);
Display96x16x1WriteByte(0x80);
Display96x16x1WriteByte((ulX + g_ucColumnAdjust) & 0x0f);
Display96x16x1WriteByte(0x80);
Display96x16x1WriteByte(0x10 | (((ulX + g_ucColumnAdjust) >> 4) & 0x0f));
Display96x16x1WriteByte(0x40);
//
// Loop while there are more characters in the string.
//
while(*pcStr != 0)
{
//
// See if there is enough space on the display for this entire
// character.
//
if(ulX <= 90)
{
//
// Write the contents of this character to the display.
//
Display96x16x1WriteArray(g_pucFont[*pcStr - ' '], 5);
//
// See if this is the last character to display (either because the
// right edge has been reached or because there are no more
// characters).
//
if((ulX == 90) || (pcStr[1] == 0))
{
//
// Write the final column of the display.
//
Display96x16x1WriteFinal(0x00);
//
// The string has been displayed.
//
return;
}
//
// Write the inter-character padding column.
//
Display96x16x1WriteByte(0x00);
}
else
{
//
// Write the portion of the character that will fit onto the
// display.
//
Display96x16x1WriteArray(g_pucFont[*pcStr - ' '], 95 - ulX);
Display96x16x1WriteFinal(g_pucFont[*pcStr - ' '][95 - ulX]);
//
// The string has been displayed.
//
return;
}
//
// Advance to the next character.
//
pcStr++;
//
// Increment the X coordinate by the six columns that were just
// written.
//
ulX += 6;
}
}
