//***************************************************************************** // //! 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; } }