URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [CORTEX_LM3Sxxxx_Eclipse/] [RTOSDemo/] [formike128x128x16.c] - Rev 604
Go to most recent revision | Compare with Previous | Blame | View Log
//***************************************************************************** // // formike128x128x16.c - Display driver for the Formike Electronic // KWH015C04-F01 CSTN panel with an ST7637 controller. // // Copyright (c) 2008 Luminary Micro, Inc. All rights reserved. // // Software License Agreement // // Luminary Micro, Inc. (LMI) is supplying this software for use solely and // exclusively on LMI's microcontroller products. // // The software is owned by LMI and/or its suppliers, and is protected under // applicable copyright laws. All rights are reserved. You may not combine // this software with "viral" open-source software in order to form a larger // program. Any use in violation of the foregoing restrictions may subject // the user to criminal sanctions under applicable laws, as well as to civil // liability for the breach of the terms and conditions of this license. // // THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED // OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. // LMI SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR // CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. // // This is part of revision 2523 of the Stellaris Peripheral Driver Library. // //***************************************************************************** //***************************************************************************** // //! \addtogroup ek_lm3s3748_api //! @{ // //***************************************************************************** #include "hw_gpio.h" #include "hw_memmap.h" #include "hw_types.h" #include "gpio.h" #include "sysctl.h" #include "rom.h" #include "grlib.h" #include "formike128x128x16.h" #include <string.h> //***************************************************************************** // // Defines for the pins that are used to communicate with the ST7637. // //***************************************************************************** #define LCD_A0_BASE GPIO_PORTB_BASE #define LCD_A0_PIN GPIO_PIN_2 #define LCD_WR_BASE GPIO_PORTC_BASE #define LCD_WR_PIN GPIO_PIN_4 #define LCD_RD_BASE GPIO_PORTC_BASE #define LCD_RD_PIN GPIO_PIN_5 #define LCD_BL_BASE GPIO_PORTF_BASE #define LCD_BL_PIN GPIO_PIN_1 #define LCD_DATA_BASE GPIO_PORTG_BASE //***************************************************************************** // // Translates a 24-bit RGB color to a display driver-specific color. // // \param c is the 24-bit RGB color. The least-significant byte is the blue // channel, the next byte is the green channel, and the third byte is the red // channel. // // This macro translates a 24-bit RGB color into a value that can be written // into the display's frame buffer in order to reproduce that color, or the // closest possible approximation of that color. // // \return Returns the display-driver specific color. // //***************************************************************************** #define DPYCOLORTRANSLATE(c) ((((c) & 0x00ff0000) >> 19) | \ ((((c) & 0x0000ff00) >> 5) & 0x000007e0) | \ ((((c) & 0x000000ff) << 8) & 0x0000f800)) //***************************************************************************** // // Writes a data word to the ST7637. // //***************************************************************************** static void WriteData(unsigned char ucData) { // // Write the data to the data bus. // HWREG(LCD_DATA_BASE + GPIO_O_DATA + (0xff << 2)) = ucData; // // Assert the write enable signal. // HWREG(LCD_WR_BASE + GPIO_O_DATA + (LCD_WR_PIN << 2)) = 0; // // Deassert the write enable signal. // HWREG(LCD_WR_BASE + GPIO_O_DATA + (LCD_WR_PIN << 2)) = LCD_WR_PIN; } //***************************************************************************** // // Writes a command to the ST7637. // //***************************************************************************** static void WriteCommand(unsigned char ucData) { // // Write the command to the data bus. // HWREG(LCD_DATA_BASE + GPIO_O_DATA + (0xff << 2)) = ucData; // // Set the A0 signal low, indicating a command. // HWREG(LCD_A0_BASE + GPIO_O_DATA + (LCD_A0_PIN << 2)) = 0; // // Assert the write enable signal. // HWREG(LCD_WR_BASE + GPIO_O_DATA + (LCD_WR_PIN << 2)) = 0; // // Deassert the write enable signal. // HWREG(LCD_WR_BASE + GPIO_O_DATA + (LCD_WR_PIN << 2)) = LCD_WR_PIN; // // Set the A0 signal high, indicating that following writes are data. // HWREG(LCD_A0_BASE + GPIO_O_DATA + (LCD_A0_PIN << 2)) = LCD_A0_PIN; } //***************************************************************************** // //! Initializes the display driver. //! //! This function initializes the ST7637 display controller on the panel, //! preparing it to display data. //! //! \return None. // //***************************************************************************** void Formike128x128x16Init(void) { unsigned long ulClockMS, ulCount; // // Get the value to pass to SysCtlDelay() in order to delay for 1 ms. // ulClockMS = SysCtlClockGet() / (3 * 1000); // // Enable the GPIO peripherals used to interface to the ST7637. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); // // Configure the pins that connect to the LCD as GPIO outputs. // GPIOPinTypeGPIOOutput(LCD_A0_BASE, LCD_A0_PIN); GPIOPinTypeGPIOOutput(LCD_WR_BASE, LCD_WR_PIN); GPIOPinTypeGPIOOutput(LCD_RD_BASE, LCD_RD_PIN); GPIOPinTypeGPIOOutput(LCD_BL_BASE, LCD_BL_PIN); GPIOPinTypeGPIOOutput(LCD_DATA_BASE, 0xff); // // Set the LCD control pins to their default values. // GPIOPinWrite(LCD_A0_BASE, LCD_A0_PIN, LCD_A0_PIN); GPIOPinWrite(LCD_WR_BASE, LCD_WR_PIN | LCD_RD_PIN, LCD_WR_PIN | LCD_RD_PIN); GPIOPinWrite(LCD_BL_BASE, LCD_BL_PIN, 0); GPIOPinWrite(LCD_DATA_BASE, 0xff, 0x00); // // Perform a software reset of the ST7637. // WriteCommand(0x01); // // Delay for 120ms. // SysCtlDelay(ulClockMS * 120); // // Disable auto-load of mask rom data. // WriteCommand(0xD7); WriteData(0xBF); // // Set the OTP control mode to read. // WriteCommand(0xE0); WriteData(0x00); // // Delay for 10ms. // SysCtlDelay(ulClockMS * 10); // // Start the OTP read. // WriteCommand(0xE3); // // Delay for 20ms. // SysCtlDelay(ulClockMS * 20); // // Cancel the OTP read (it should have finished by now). // WriteCommand(0xE1); // // Turn off the display. // WriteCommand(0x28); // // Exit sleep mode. // WriteCommand(0x11); // // Delay for 50ms. // SysCtlDelay(ulClockMS * 50); // // Program the LCD supply voltage V0 to 14V. // WriteCommand(0xC0); WriteData(0x04); WriteData(0x01); // // Select an LCD bias voltage ratio of 1/12. // WriteCommand(0xC3); WriteData(0x00); // // Enable the x8 booster circuit. // WriteCommand(0xC4); WriteData(0x07); // // Invert the column scan direction for the panel. // WriteCommand(0xB7); WriteData(0xC0); // // Select 16bpp, 5-6-5 data input mode. // WriteCommand(0x3A); WriteData(0x05); // // Select the memory scanning direction. The scanning mode does not matter // for this driver since the row/column selects will constrain the writes // to the desired area of the display. // WriteCommand(0x36); WriteData(0x00); // // Turn on the display. // WriteCommand(0x29); // // Clear the contents of the display buffer. // WriteCommand(0x2A); WriteData(0x00); WriteData(0x7F); WriteCommand(0x2B); WriteData(0x01); WriteData(0x80); WriteCommand(0x2c); for(ulCount = 0; ulCount < (128 * 128); ulCount++) { WriteData(0x00); WriteData(0x00); } // // Enable normal operation of the LCD. // WriteCommand(0x13); } //***************************************************************************** // //! Turns on the backlight. //! //! This function turns on the backlight on the display. //! //! \return None. // //***************************************************************************** void Formike128x128x16BacklightOn(void) { // // Assert the signal that turns on the backlight. // HWREG(LCD_BL_BASE + GPIO_O_DATA + (LCD_BL_PIN << 2)) = LCD_BL_PIN; } //***************************************************************************** // //! Turns off the backlight. //! //! This function turns off the backlight on the display. //! //! \return None. // //***************************************************************************** void Formike128x128x16BacklightOff(void) { // // Deassert the signal that turns on the backlight. // HWREG(LCD_BL_BASE + GPIO_O_DATA + (LCD_BL_PIN << 2)) = 0; } //***************************************************************************** // //! Draws a pixel on the screen. //! //! \param pvDisplayData is a pointer to the driver-specific data for this //! display driver. //! \param lX is the X coordinate of the pixel. //! \param lY is the Y coordinate of the pixel. //! \param ulValue is the color of the pixel. //! //! This function sets the given pixel to a particular color. The coordinates //! of the pixel are assumed to be within the extents of the display. //! //! \return None. // //***************************************************************************** static void Formike128x128x16PixelDraw(void *pvDisplayData, long lX, long lY, unsigned long ulValue) { // // Set the X address of the display cursor. // WriteCommand(0x2a); WriteData(lX); WriteData(lX); // // Set the Y address of the display cursor. // WriteCommand(0x2b); WriteData(lY + 1); WriteData(lY + 1); // // Write the pixel value. // WriteCommand(0x2c); WriteData(ulValue >> 8); WriteData(ulValue); } //***************************************************************************** // //! Draws a horizontal sequence of pixels on the screen. //! //! \param pvDisplayData is a pointer to the driver-specific data for this //! display driver. //! \param lX is the X coordinate of the first pixel. //! \param lY is the Y coordinate of the first pixel. //! \param lX0 is sub-pixel offset within the pixel data, which is valid for 1 //! or 4 bit per pixel formats. //! \param lCount is the number of pixels to draw. //! \param lBPP is the number of bits per pixel; must be 1, 4, or 8. //! \param pucData is a pointer to the pixel data. For 1 and 4 bit per pixel //! formats, the most significant bit(s) represent the left-most pixel. //! \param pucPalette is a pointer to the palette used to draw the pixels. //! //! This function draws a horizontal sequence of pixels on the screen, using //! the supplied palette. For 1 bit per pixel format, the palette contains //! pre-translated colors; for 4 and 8 bit per pixel formats, the palette //! contains 24-bit RGB values that must be translated before being written to //! the display. //! //! \return None. // //***************************************************************************** static void Formike128x128x16PixelDrawMultiple(void *pvDisplayData, long lX, long lY, long lX0, long lCount, long lBPP, const unsigned char *pucData, const unsigned char *pucPalette) { unsigned long ulByte; // // Set the extent of the line along the X axis. // WriteCommand(0x2a); WriteData(lX); WriteData(lX + lCount - 1); // // Set the Y address of the display cursor. // WriteCommand(0x2b); WriteData(lY + 1); WriteData(lY + 1); // // Write the data RAM write command. // WriteCommand(0x2c); // // Determine how to interpret the pixel data based on the number of bits // per pixel. // switch(lBPP) { // // The pixel data is in 1 bit per pixel format. // case 1: { // // Loop while there are more pixels to draw. // while(lCount) { // // Get the next byte of image data. // ulByte = *pucData++; // // Loop through the pixels in this byte of image data. // for(; (lX0 < 8) && lCount; lX0++, lCount--) { // // Draw this pixel in the appropriate color. // lBPP = ((unsigned long *)pucPalette)[(ulByte >> (7 - lX0)) & 1]; WriteData(lBPP >> 8); WriteData(lBPP); } // // Start at the beginning of the next byte of image data. // lX0 = 0; } // // The image data has been drawn. // break; } // // The pixel data is in 4 bit per pixel format. // case 4: { // // Loop while there are more pixels to draw. "Duff's device" is // used to jump into the middle of the loop if the first nibble of // the pixel data should not be used. Duff's device makes use of // the fact that a case statement is legal anywhere within a // sub-block of a switch statement. See // http://en.wikipedia.org/wiki/Duff's_device for detailed // information about Duff's device. // switch(lX0 & 1) { case 0: while(lCount) { // // Get the upper nibble of the next byte of pixel data // and extract the corresponding entry from the // palette. // ulByte = (*pucData >> 4) * 3; ulByte = (*(unsigned long *)(pucPalette + ulByte) & 0x00ffffff); // // Translate this palette entry and write it to the // screen. // ulByte = DPYCOLORTRANSLATE(ulByte); WriteData(ulByte >> 8); WriteData(ulByte); // // Decrement the count of pixels to draw. // lCount--; // // See if there is another pixel to draw. // if(lCount) { case 1: // // Get the lower nibble of the next byte of pixel // data and extract the corresponding entry from // the palette. // ulByte = (*pucData++ & 15) * 3; ulByte = (*(unsigned long *)(pucPalette + ulByte) & 0x00ffffff); // // Translate this palette entry and write it to the // screen. // ulByte = DPYCOLORTRANSLATE(ulByte); WriteData(ulByte >> 8); WriteData(ulByte); // // Decrement the count of pixels to draw. // lCount--; } } } // // The image data has been drawn. // break; } // // The pixel data is in 8 bit per pixel format. // case 8: { // // Loop while there are more pixels to draw. // while(lCount--) { // // Get the next byte of pixel data and extract the // corresponding entry from the palette. // ulByte = *pucData++ * 3; ulByte = *(unsigned long *)(pucPalette + ulByte) & 0x00ffffff; // // Translate this palette entry and write it to the screen. // ulByte = DPYCOLORTRANSLATE(ulByte); WriteData(ulByte >> 8); WriteData(ulByte); } // // The image data has been drawn. // break; } } } //***************************************************************************** // //! Flushes any cached drawing operations. //! //! \param pvDisplayData is a pointer to the driver-specific data for this //! display driver. //! //! This functions flushes any cached drawing operations to the display. This //! is useful when a local frame buffer is used for drawing operations, and the //! flush would copy the local frame buffer to the display. For the ST7637 //! driver, the flush is a no operation. //! //! \return None. // //***************************************************************************** static void Formike128x128x16Flush(void *pvDisplayData) { // // There is nothing to be done. // } //***************************************************************************** // //! Draws a horizontal line. //! //! \param pvDisplayData is a pointer to the driver-specific data for this //! display driver. //! \param lX1 is the X coordinate of the start of the line. //! \param lX2 is the X coordinate of the end of the line. //! \param lY is the Y coordinate of the line. //! \param ulValue is the color of the line. //! //! This function draws a horizontal line on the display. The coordinates of //! the line are assumed to be within the extents of the display. //! //! \return None. // //***************************************************************************** static void Formike128x128x16LineDrawH(void *pvDisplayData, long lX1, long lX2, long lY, unsigned long ulValue) { // // Set the extent of the line along the X axis. // WriteCommand(0x2a); WriteData(lX1); WriteData(lX2); // // Set the Y address of the display cursor. // WriteCommand(0x2b); WriteData(lY + 1); WriteData(lY + 1); // // Write the data RAM write command. // WriteCommand(0x2c); // // Loop through the pixels of this horizontal line. // while(lX1++ <= lX2) { // // Write the pixel value. // WriteData(ulValue >> 8); WriteData(ulValue); } } //***************************************************************************** // //! Draws a vertical line. //! //! \param pvDisplayData is a pointer to the driver-specific data for this //! display driver. //! \param lX is the X coordinate of the line. //! \param lY1 is the Y coordinate of the start of the line. //! \param lY2 is the Y coordinate of the end of the line. //! \param ulValue is the color of the line. //! //! This function draws a vertical line on the display. The coordinates of the //! line are assumed to be within the extents of the display. //! //! \return None. // //***************************************************************************** static void Formike128x128x16LineDrawV(void *pvDisplayData, long lX, long lY1, long lY2, unsigned long ulValue) { // // Set the X address of the display cursor. // WriteCommand(0x2a); WriteData(lX); WriteData(lX); // // Set the extent of the line along the Y axis. // WriteCommand(0x2b); WriteData(lY1 + 1); WriteData(lY2 + 1); // // Write the data RAM write command. // WriteCommand(0x2c); // // Loop through the pixels of this vertical line. // while(lY1++ <= lY2) { // // Write the pixel value. // WriteData(ulValue >> 8); WriteData(ulValue); } } //***************************************************************************** // //! Fills a rectangle. //! //! \param pvDisplayData is a pointer to the driver-specific data for this //! display driver. //! \param pRect is a pointer to the structure describing the rectangle. //! \param ulValue is the color of the rectangle. //! //! This function fills a rectangle on the display. The coordinates of the //! rectangle are assumed to be within the extents of the display, and the //! rectangle specification is fully inclusive (i.e. both sXMin and sXMax are //! drawn, along with sYMin and sYMax). //! //! \return None. // //***************************************************************************** static void Formike128x128x16RectFill(void *pvDisplayData, const tRectangle *pRect, unsigned long ulValue) { long lCount; // // Set the extent of the rectangle along the X axis. // WriteCommand(0x2a); WriteData(pRect->sXMin); WriteData(pRect->sXMax); // // Set the extent of the rectangle along the Y axis. // WriteCommand(0x2b); WriteData(pRect->sYMin + 1); WriteData(pRect->sYMax + 1); // // Write the data RAM write command. // WriteCommand(0x2c); // // Loop through the pixels in this rectangle. // for(lCount = ((pRect->sXMax - pRect->sXMin + 1) * (pRect->sYMax - pRect->sYMin + 1)); lCount > 0; lCount--) { // // Write the pixel value. // WriteData(ulValue >> 8); WriteData(ulValue); } } //***************************************************************************** // //! Translates a 24-bit RGB color to a display driver-specific color. //! //! \param pvDisplayData is a pointer to the driver-specific data for this //! display driver. //! \param ulValue is the 24-bit RGB color. The least-significant byte is the //! blue channel, the next byte is the green channel, and the third byte is the //! red channel. //! //! This function translates a 24-bit RGB color into a value that can be //! written into the display's frame buffer in order to reproduce that color, //! or the closest possible approximation of that color. //! //! \return Returns the display-driver specific color. // //***************************************************************************** static unsigned long Formike128x128x16ColorTranslate(void *pvDisplayData, unsigned long ulValue) { // // Translate from a 24-bit RGB color to a 5-6-5 RGB color. // return(DPYCOLORTRANSLATE(ulValue)); } //***************************************************************************** // //! The display structure that describes the driver for the Formike Electronic //! KWH015C04-F01 CSTN panel with an ST7637 controller. // //***************************************************************************** const tDisplay g_sFormike128x128x16 = { sizeof(tDisplay), 0, 128, 128, Formike128x128x16PixelDraw, Formike128x128x16PixelDrawMultiple, Formike128x128x16LineDrawH, Formike128x128x16LineDrawV, Formike128x128x16RectFill, Formike128x128x16ColorTranslate, Formike128x128x16Flush }; //***************************************************************************** // // Close the Doxygen group. //! @} // //***************************************************************************** /* FreeRTOS.org demo wrappers. These are required so the prototypes for the functions are the same as for the display drivers used by other evaluation kits. */ static tContext sContext; void vFormike128x128x16Clear( void ) { const tRectangle xRectangle = { 0, 0, 127, 127 }; GrContextForegroundSet( &sContext, ClrBlack ); GrRectFill( &sContext, &xRectangle ); GrContextForegroundSet(&sContext, ClrWhite); } /*-----------------------------------------------------------*/ void vFormike128x128x16StringDraw( const char *pcString, unsigned long lX, unsigned long lY, unsigned char ucColor ) { GrContextForegroundSet(&sContext, ClrWhite); GrStringDraw( &sContext, pcString, strlen( pcString ), lX, lY, false ); } /*-----------------------------------------------------------*/ void vFormike128x128x16Init( unsigned long ul ) { tRectangle rectScreen; const unsigned char *pcAppName = "www.FreeRTOS.org"; ( void ) ul; Formike128x128x16Init(); Formike128x128x16BacklightOn(); GrContextInit(&sContext, &g_sFormike128x128x16); GrContextFontSet(&sContext, &g_sFontCmss12); rectScreen.sXMin = 0; /* Fill the screen with a black rectangle. */ rectScreen.sYMin = 0; rectScreen.sXMax = g_sFormike128x128x16.usWidth - 1; rectScreen.sYMax = g_sFormike128x128x16.usHeight - 1; GrContextForegroundSet(&sContext, ClrBlack); GrRectFill(&sContext, &rectScreen); } /*-----------------------------------------------------------*/ void vFormike128x128x16ImageDraw( const unsigned char *pucImage, unsigned long ulX, unsigned long ulY, unsigned long ulWidth, unsigned long ulHeight ) { GrImageDraw( &sContext, pucImage, ( long ) ulX, ( long ) ulY); }
Go to most recent revision | Compare with Previous | Blame | View Log