void vParTestSetLED( unsigned portBASE_TYPE uxLED, signed portBASE_TYPE xValue )
{
unsigned char ucBit = ( unsigned char ) 1;
vTaskSuspendAll();
{
if( uxLED < partstMAX_OUTPUT_LED )
{
ucBit = ( ( unsigned char ) 1 ) << uxLED;
if( xValue == pdFALSE )
{
ucBit ^= ( unsigned char ) 0xff;
ucOutputValue &= ucBit;
}
else
{
ucOutputValue |= ucBit;
}
PDCWrite( PDC_LED, ucOutputValue );
}
}
xTaskResumeAll();
}
static void prvPDCWrite( char cAddress, char cData )
{
vTaskSuspendAll();
{
PDCWrite( cAddress, cData );
}
xTaskResumeAll();
}
static void prvPDCWrite( portCHAR cAddress, portCHAR cData )
{
vTaskSuspendAll();
{
PDCWrite( cAddress, cData );
}
xTaskResumeAll();
}
//*****************************************************************************
//
//! Write a character pattern to the LCD.
//!
//! \param ucChar is the character index to create. Valid values are zero
//! through seven.
//! \param pucData is the data for the character pattern. It contains eight
//! bytes, with the first byte being the top row of the pattern. In each byte,
//! the LSB is the right pixel of the pattern.
//!
//! This function will write a character pattern into the LCD for use as a
//! character to be displayed. After writing the pattern, it can be used on
//! the LCD by writing the corresponding character index to the display.
//!
//! This function is contained in <tt>utils/pdc.c</tt>, with
//! <tt>utils/pdc.h</tt> containing the API definition for use by applications.
//!
//! \return None.
//
//*****************************************************************************
void
PDCLCDCreateChar(unsigned char ucChar, unsigned char *pucData)
{
//
// Check the arguments.
//
ASSERT(ucChar < 8);
//
// Wait until the LCD has finished executing any previous command.
//
while((PDCRead(PDC_LCD_CSR) & LCD_B_BUSY))
{
}
//
// Write the character pattern memory address.
//
PDCWrite(PDC_LCD_CSR, LCD_CGADDR + (ucChar * 8));
//
// Write the pattern to chacter pattern memory.
//
for(ucChar = 0; ucChar < 8; ucChar++)
{
//
// Wait until the LCD has finished executing any previous command.
//
while((PDCRead(PDC_LCD_CSR) & LCD_B_BUSY))
{
}
//
// Write this row of the pattern.
//
PDCWrite(PDC_LCD_RAM, *pucData++);
}
}
//*****************************************************************************
//
//! Write a GPIO data register.
//!
//! \param ucIdx is the index of the GPIO data register to write; valid values
//! are 0, 1, and 2.
//! \param ucValue is the value to write to the GPIO data register.
//!
//! This function writes one of the GPIO direction registers in the PDC. The
//! written to a pin is driven out for output pins and ignored for input pins.
//!
//! This function is contained in <tt>utils/pdc.c</tt>, with
//! <tt>utils/pdc.h</tt> containing the API definition for use by applications.
//!
//! \return None.
//
//*****************************************************************************
void
PDCGPIOWrite(unsigned char ucIdx, unsigned char ucValue)
{
//
// Check the arguments.
//
ASSERT((ucIdx == 0) || (ucIdx == 1) || (ucIdx == 2));
//
// Write the requested data register.
//
if(ucIdx == 0)
{
PDCWrite(PDC_GPXDAT, ucValue);
}
else if(ucIdx == 1)
{
PDCWrite(PDC_GPYDAT, ucValue);
}
else
{
PDCWrite(PDC_GPZDAT, ucValue);
}
}
//*****************************************************************************
//
//! Clear the screen.
//!
//! This function clears the contents of the LCD screen. The cursor will be
//! returned to the upper left corner.
//!
//! This function is contained in <tt>utils/pdc.c</tt>, with
//! <tt>utils/pdc.h</tt> containing the API definition for use by applications.
//!
//! \return None.
//
//*****************************************************************************
void
PDCLCDClear(void)
{
//
// Wait until the LCD has finished executing any previous command.
//
while((PDCRead(PDC_LCD_CSR) & LCD_B_BUSY))
{
}
//
// Write the clear display command.
//
PDCWrite(PDC_LCD_CSR, LCD_CLEAR);
}
void vParTestToggleLED( unsigned portBASE_TYPE uxLED )
{
unsigned char ucBit;
vTaskSuspendAll();
{
if( uxLED < partstMAX_OUTPUT_LED ) {
ucBit = ( ( unsigned char ) 1 ) << uxLED;
if( ucOutputValue & ucBit ) {
ucOutputValue &= ~ucBit;
} else {
ucOutputValue |= ucBit;
}
PDCWrite( PDC_LED, ucOutputValue );
}
}
xTaskResumeAll();
}
//*****************************************************************************
//
//! Writes a string to the LCD display.
//!
//! \param pcStr pointer to the string to be displayed.
//! \param ulCount is the number of characters to be displayed.
//!
//! This function will display a string on the LCD at the current cursor
//! position. It is the caller's responsibility to position the cursor to the
//! place where the string should be displayed (either explicitly via
//! PDCLCDSetPos() or implicitly from where the cursor was left after a
//! previous call to PDCLCDWrite()), and to properly account for the LCD
//! boundary (line wrapping is not automatically performed). Null characters
//! are not treated special and are written to the LCD, which interprets it as
//! a special programmable character glyph (see PDCLCDCreateChar()).
//!
//! This function is contained in <tt>utils/pdc.c</tt>, with
//! <tt>utils/pdc.h</tt> containing the API definition for use by applications.
//!
//! \return None.
//
//*****************************************************************************
void
PDCLCDWrite(const char *pcStr, unsigned long ulCount)
{
//
// Write the string to the LCD.
//
while(ulCount--)
{
//
// Wait until the LCD has finished executing any previous command.
//
while((PDCRead(PDC_LCD_CSR) & LCD_B_BUSY))
{
}
//
// Write this character to the LCD.
//
PDCWrite(PDC_LCD_RAM, *pcStr++);
}
}
//*****************************************************************************
//
//! Set the position of the cursor.
//!
//! \param ucX is the horizontal position. Valid values are zero through
//! fifteen.
//! \param ucY is the vertical position.. Valid values are zero and one.
//!
//! This function will move the cursor to the specified position. All
//! characters written to the LCD are placed at the current cursor position,
//! which is automatically advanced.
//!
//! This function is contained in <tt>utils/pdc.c</tt>, with
//! <tt>utils/pdc.h</tt> containing the API definition for use by applications.
//!
//! \return None.
//
//*****************************************************************************
void
PDCLCDSetPos(unsigned char ucX, unsigned char ucY)
{
//
// Check the arguments.
//
ASSERT(ucX < 16);
ASSERT(ucY < 2);
//
// Wait until the LCD has finished executing any previous command.
//
while((PDCRead(PDC_LCD_CSR) & LCD_B_BUSY))
{
}
//
// Set the cursor position.
//
PDCWrite(PDC_LCD_CSR, LCD_DDADDR | (0x40 * ucY) + ucX);
}
void vParTestInitialise( void )
{
PDCInit();
PDCWrite( PDC_LED, ucOutputValue );
}
//*****************************************************************************
//
//! Turn off the backlight.
//!
//! This function turns off the backlight on the LCD.
//!
//! This function is contained in <tt>utils/pdc.c</tt>, with
//! <tt>utils/pdc.h</tt> containing the API definition for use by applications.
//!
//! \return None.
//
//*****************************************************************************
void
PDCLCDBacklightOff(void)
{
PDCWrite(PDC_CSR, 0x00);
}
//*****************************************************************************
//
//! Turns on the backlight.
//!
//! This function turns on the backlight on the LCD.
//!
//! This function is contained in <tt>utils/pdc.c</tt>, with
//! <tt>utils/pdc.h</tt> containing the API definition for use by applications.
//!
//! \return None.
//
//*****************************************************************************
void
PDCLCDBacklightOn(void)
{
PDCWrite(PDC_CSR, 0x01);
}
//*****************************************************************************
//
//! Initializes the LCD display.
//!
//! This function will set up the LCD display for writing. It will set the
//! data bus to 8 bits, set the number of lines to 2, and the font size to
//! 5x10. It will also turn the display off, clear the display, turn the
//! display back on, and enable the backlight.
//!
//! This function is contained in <tt>utils/pdc.c</tt>, with
//! <tt>utils/pdc.h</tt> containing the API definition for use by applications.
//!
//! \note The PDC must be initialized via the PDCInit() function before this
//! function can be called. Also, it may be necessary to adjust the contrast
//! potentiometer in order to discern any output on the LCD display.
//!
//! \return None.
//
//*****************************************************************************
void
PDCLCDInit(void)
{
unsigned char pucCfg[] =
{
0x3C, // Number of lines = 2 / font = 5x10
0x08, // Display off
0x01, // Display clear
0x06, // Entry mode [cursor dir][shift]
0x0C, // Display on [display on][curson on][blinking on]
};
unsigned long ulIdx;
//
// Set the data bus width to eight bits.
//
PDCWrite(PDC_LCD_CSR, 0x30);
//
// Wait for 4.1ms by reading the PDC version register enough times to
// guarantee that amount of time has passed.
//
for(ulIdx = 0; ulIdx < 257; ulIdx++)
{
PDCRead(PDC_VER);
}
//
// Set the data bus width to eight bits.
//
PDCWrite(PDC_LCD_CSR, 0x30);
//
// Wait for 100us by reading the PDC version register enough times to
// guarantee that amount of time has passed. This works out to 112us plus
// overhead.
//
for(ulIdx = 0; ulIdx < 7; ulIdx++)
{
PDCRead(PDC_VER);
}
//
// Set the data bus width to eight bits.
//
PDCWrite(PDC_LCD_CSR, 0x30);
//
// Configure the LCD.
//
for(ulIdx = 0; ulIdx < (sizeof(pucCfg) / sizeof(pucCfg[0])); ulIdx++)
{
//
// Wait until the LCD has finished executing any previous command.
//
while((PDCRead(PDC_LCD_CSR) & LCD_B_BUSY))
{
}
//
// Write the next configuration byte.
//
PDCWrite(PDC_LCD_CSR, pucCfg[ulIdx]);
}
}
//*****************************************************************************
//
//! Write to the PDC LEDs.
//!
//! \param ucLED value to write to the LEDs.
//!
//! This function set the state of the LEDs connected to the PDC on the
//! Stellaris development board.
//!
//! This function is contained in <tt>utils/pdc.c</tt>, with
//! <tt>utils/pdc.h</tt> containing the API definition for use by applications.
//!
//! \return None.
//
//*****************************************************************************
void
PDCLEDWrite(unsigned char ucLED)
{
PDCWrite(PDC_LED, ucLED);
}
