display.c

基于MMA7260QR2的跌落检查程序

}

/******************************************************************************
* This function sets/ clears the pixel from (XStartCoord, YStartCoord)
*
* Interface assumptions:
*
*
* Return value:
* None
*
*
******************************************************************************/
void LCD_WritePixel(uint8_t xStartCoord, uint8_t yStartCoord, bool_t mode)
{
  uint8_t page;
  uint8_t read;

  if (xStartCoord>=gLCDMaxColumns_c || yStartCoord>=gLCDMaxLines_c)
  {
    return; /* if pixel out of screen exit */
  }

  page = yStartCoord >> 3;
  yStartCoord %= 8;

  LCD_WriteCommand(gLCDDisplayStartLineDefaultCommand_c);
  LCD_WriteCommand(gLCDPageAddressDefaultCommand_c + page);
  LCD_WriteCommand(gLCDNibble0ColumnAddressDefaultCommand_c | ((xStartCoord & 0xF0)>>4));
  LCD_WriteCommand(gLCDNibble1ColumnAddressDefaultCommand_c | (xStartCoord & 0x0F));       

  read = ReadData(); // Dummy read
  read = ReadData();

  LCD_WriteCommand(gLCDDisplayStartLineDefaultCommand_c);
  LCD_WriteCommand(gLCDPageAddressDefaultCommand_c + page);
  LCD_WriteCommand(gLCDNibble0ColumnAddressDefaultCommand_c | ((xStartCoord & 0xF0)>>4));
  LCD_WriteCommand(gLCDNibble1ColumnAddressDefaultCommand_c | (xStartCoord & 0x0F));

  if( TRUE == mode )
  {
    LCD_WriteData((read | (1 << yStartCoord)));
  }
  else
  {  
    LCD_WriteData((read & ~(1 << yStartCoord)));  
  }
}

/******************************************************************************
* This function displays a character starting with xCoord and yCoord
*
* Interface assumptions:
*  yCoord is a multiple of 8
*
*
* Return value:
* None
*
*
******************************************************************************/
void LCD_WriteCharacter(uint8_t symbol, uint8_t xCoord, uint8_t yCoord)
{
  uint16_t arrayLocation=0; 
  uint8_t i, maxLength;
 
  /* if pixel out of screen, exit */
  if((xCoord >= gLCDMaxColumns_c) && (yCoord >= gLCDMaxLines_c))
  {
    return;
  }
    
  arrayLocation = symbol - mFontOffset_c;
  maxLength = aLCDFont[mDisplayParams.currentFontType].fontHeight;
  /* each character has: 
  *  (aLCDFont[mDisplayParams.currentFontType].pFontIndex[arrayLocation+1] - 
  *   aLCDFont[mDisplayParams.currentFontType].pFontIndex[arrayLocation]) pixels as width 
  *  (aLCDFont[mDisplayParams.currentFontType].fontHeight * 8) pixels as height 
  */
  while(maxLength > 0)
  {
    maxLength--;      
    InitDisplayWrite(xCoord,yCoord);        
    /* mark line as written */
    mDisplayParams.writtenLines |= (1<<(yCoord>>3));   
    for(i = 0;
        i < ((aLCDFont[mDisplayParams.currentFontType].pFontIndexTable[arrayLocation+1] - 
              aLCDFont[mDisplayParams.currentFontType].pFontIndexTable[arrayLocation]) *
              aLCDFont[mDisplayParams.currentFontType].fontHeight);
        i += aLCDFont[mDisplayParams.currentFontType].fontHeight)        
    {
      /* in case the character is representd on multiple lines,
       * (aLCDFont[mDisplayParams.currentFontType].fontHeight > 1),
       * display first the upper part of the character and after the lower part 
       */
      LCD_WriteData(aLCDFont[mDisplayParams.currentFontType].pFontCharTable[aLCDFont[mDisplayParams.currentFontType].pFontIndexTable[arrayLocation]*aLCDFont[mDisplayParams.currentFontType].fontHeight + i + maxLength]);
    }
    yCoord += 8;
  }    
}

/****************************************************************************************
* This function clears the pixels between startXCoord and endXCoord within a single page
* (page located at yCoord)
*
* Interface assumptions:
*
*
* Return value:
* None
*
*
******************************************************************************/
void LCD_ClearPage(uint8_t startXCoord, uint8_t endXCoord, uint8_t yCoord)
{
  uint8_t i;
  
  InitDisplayWrite(startXCoord, yCoord);
  for(i = startXCoord; i < endXCoord; i++)
  {
    LCD_WriteData(OFF);    
  }    
}

/****************************************************************************************
* This function clears an entire LCD line
*
* Interface assumptions:
*     char line = 0..7
*
*
* Return value:
*     TRUE if the line was cleared
*     FALSE if the line is not cleared yet
*     0xFF  if the line parameter is not valid
* None
*
*
******************************************************************************/
uint8_t LCD_ClearLine(uint8_t line)
{
  static pageParams_t pageToDelete;
  static bool_t isPageDeleted = TRUE;
  
  if(line < gLCDMaxRamDataPages_c)
  {
    /* save the page coordinates */
    if(isPageDeleted)
    {
      pageToDelete.xStartCoord = mLineParams[line].xCoord;
      pageToDelete.xEndCoord   = gLCDMaxColumns_c;
      pageToDelete.yCoord      = mLineParams[line].yCoord;
      pageToDelete.line        = line; 
    }
    
    /* delete only mMaxDeleteColumns_c columns once because of time constraints */
    if(((pageToDelete.xEndCoord - pageToDelete.xStartCoord) >= mMaxDeleteColumns_c))
    {
      /* the page will be deleted with (gLCDMaxColumns_c/mMaxDeleteColumns_c) consecutive operations */
      isPageDeleted            = FALSE;
      LCD_ClearPage(pageToDelete.xStartCoord, 
                    pageToDelete.xStartCoord + mMaxDeleteColumns_c, 
                    pageToDelete.yCoord); 
      /* compute the new xStartCoord for the current page */
      pageToDelete.xStartCoord = pageToDelete.xStartCoord + mMaxDeleteColumns_c;        
      return FALSE;  
    }
    else
    {    
      LCD_ClearPage(pageToDelete.xStartCoord, 
                    pageToDelete.xEndCoord, 
                    pageToDelete.yCoord);
      isPageDeleted            = TRUE;
      return TRUE;  
    } 
  }
  else
  {
    return 0xFF;
  }
}

/******************************************************************************
* This function process an LCD operation (clear, write string).
*
* Interface assumptions:
*
*
* Return value:
* None
*
*
******************************************************************************/


/******************************************************************************
* This function sets a certain value to the LCD DATA pins
*
* Interface assumptions:
*
*
* Return value:
* None
*
*
******************************************************************************/
static void SendData(uint8_t data)
{
#if gLCDGpioPinMode_c
    /* bit |7|6|5|4|3|2|1|0| */
    (void)Gpio_SetPinData(LCD_D0, (data & 0x01)? gGpioPinStateHigh_c : gGpioPinStateLow_c);
    (void)Gpio_SetPinData(LCD_D1, (data & 0x02)? gGpioPinStateHigh_c : gGpioPinStateLow_c);
    (void)Gpio_SetPinData(LCD_D2, (data & 0x04)? gGpioPinStateHigh_c : gGpioPinStateLow_c);
    (void)Gpio_SetPinData(LCD_D3, (data & 0x08)? gGpioPinStateHigh_c : gGpioPinStateLow_c);
    (void)Gpio_SetPinData(LCD_D4, (data & 0x10)? gGpioPinStateHigh_c : gGpioPinStateLow_c);
    (void)Gpio_SetPinData(LCD_D5, (data & 0x20)? gGpioPinStateHigh_c : gGpioPinStateLow_c);
    (void)Gpio_SetPinData(LCD_D6, (data & 0x40)? gGpioPinStateHigh_c : gGpioPinStateLow_c);
    (void)Gpio_SetPinData(LCD_D7, (data & 0x80)? gGpioPinStateHigh_c : gGpioPinStateLow_c);
#else /* gLCDGpioPinMode_c */    
    Gpio_SetPortData(LCD_DATA_LO_PORT, LCD_DATA_LO_WRITE(data), LCD_DATA_LO_MASK); 
    Gpio_SetPortData(LCD_DATA_HI_PORT, LCD_DATA_HI_WRITE(data), LCD_DATA_HI_MASK);
    
#endif /* gLCDGpioPinMode_c */     
}

/******************************************************************************
* This function sets the LCD DATA pins as inputs
*
* Interface assumptions:
*
*
* Return value:
* None
*
*
******************************************************************************/
static void SetHiZ(void)
{
    /* change data pins direction back to input */
#if gLCDGpioPinMode_c
    (void)Gpio_SetPinDir(LCD_D0,      gGpioDirIn_c);
    (void)Gpio_SetPinDir(LCD_D1,      gGpioDirIn_c);
    (void)Gpio_SetPinDir(LCD_D2,      gGpioDirIn_c);
    (void)Gpio_SetPinDir(LCD_D3,      gGpioDirIn_c);
    (void)Gpio_SetPinDir(LCD_D4,      gGpioDirIn_c);
    (void)Gpio_SetPinDir(LCD_D5,      gGpioDirIn_c);
    (void)Gpio_SetPinDir(LCD_D6,      gGpioDirIn_c);
    (void)Gpio_SetPinDir(LCD_D7,      gGpioDirIn_c);
#else /* gLCDGpioPinMode_c */ 
    Gpio_SetPortDir(LCD_DATA_LO_PORT, ~LCD_DATA_LO_MASK, LCD_DATA_LO_MASK); 
    Gpio_SetPortDir(LCD_DATA_HI_PORT, ~LCD_DATA_HI_MASK, LCD_DATA_HI_MASK); 
    
#endif /* gLCDGpioPinMode_c */

}

/******************************************************************************
* This function sets the LCD DATA pins as outputs
*
* Interface assumptions:
*
*
* Return value:
* None
*
*
******************************************************************************/
static void SetOutput(void)
{
  /* change data pins direction to output */
#if gLCDGpioPinMode_c
  (void)Gpio_SetPinDir(LCD_D0,      gGpioDirOut_c);
  (void)Gpio_SetPinDir(LCD_D1,      gGpioDirOut_c);
  (void)Gpio_SetPinDir(LCD_D2,      gGpioDirOut_c);
  (void)Gpio_SetPinDir(LCD_D3,      gGpioDirOut_c);
  (void)Gpio_SetPinDir(LCD_D4,      gGpioDirOut_c);
  (void)Gpio_SetPinDir(LCD_D5,      gGpioDirOut_c);
  (void)Gpio_SetPinDir(LCD_D6,      gGpioDirOut_c);
  (void)Gpio_SetPinDir(LCD_D7,      gGpioDirOut_c);
#else /* gLCDGpioPinMode_c */
   
    Gpio_SetPortDir(LCD_DATA_LO_PORT, LCD_DATA_LO_MASK, LCD_DATA_LO_MASK);      
    Gpio_SetPortDir(LCD_DATA_HI_PORT, LCD_DATA_HI_MASK, LCD_DATA_HI_MASK);         
    
#endif /* gLCDGpioPinMode_c */

}

/******************************************************************************
* This function initilizes the display for a data write (line, page, column)
*
* Interface assumptions:
*
*
* Return value:
* None
*
*
******************************************************************************/
static void InitDisplayWrite(uint8_t xStartCoord, uint8_t yStartCoord)
{

  uint8_t page;  
  
  page = yStartCoord >> 3;

  LCD_WriteCommand(gLCDDisplayStartLineDefaultCommand_c);
  LCD_WriteCommand(gLCDPageAddressDefaultCommand_c + page);
  LCD_WriteCommand(gLCDNibble0ColumnAddressDefaultCommand_c | ((xStartCoord & 0xF0)>>4));
  LCD_WriteCommand(gLCDNibble1ColumnAddressDefaultCommand_c | (xStartCoord & 0x0F));         
}

/******************************************************************************
* This function reads the current location from display data RAM
*
* Interface assumptions:
*
*
* Return value:
* None
*
*
******************************************************************************/
static uint8_t ReadData(void)
{
  uint8_t ReturnValue;
  Gpio_SetPinData(LCD_A0, LCD_A0_DATA);
  Gpio_SetPinData(LCD_CS, LCD_CS_ACTIVE);
  DelayUs(1);
  Gpio_SetPinData(LCD_RD, LCD_RD_ACTIVE);
  DelayUs(1);
  ReturnValue = GetData();
  Gpio_SetPinData(LCD_RD, LCD_RD_INACTIVE);
  Gpio_SetPinData(LCD_CS, LCD_CS_INACTIVE);
  DelayUs(1);
  return ReturnValue;
}

/******************************************************************************
* This function sets the data from the current RAM display location
* to LCD DATA pins
*
* Interface assumptions:
*
*
* Return value:
* unsigned 8 bit
*
*
******************************************************************************/
static uint8_t GetData(void)
{
    uint8_t        ReturnValue = 0;
#if gLCDGpioPinMode_c
    GpioPinState_t Bitdata;
    /* bit |7|6|5|4|3|2|1|0| */
    Gpio_GetPinData(LCD_D7, &Bitdata);
    ReturnValue = (Bitdata)? (1<<7) : 0;
    Gpio_GetPinData(LCD_D6, &Bitdata);
    ReturnValue |= (Bitdata)? (1<<6) : 0;
    Gpio_GetPinData(LCD_D5, &Bitdata);
    ReturnValue |= (Bitdata)? (1<<5) : 0;
    Gpio_GetPinData(LCD_D4, &Bitdata);
    ReturnValue |= (Bitdata)? (1<<4) : 0;
    Gpio_GetPinData(LCD_D3, &Bitdata);
    ReturnValue |= (Bitdata)? (1<<3) : 0;
    Gpio_GetPinData(LCD_D2, &Bitdata);
    ReturnValue |= (Bitdata)? (1<<2) : 0;
    Gpio_GetPinData(LCD_D1, &Bitdata);
    ReturnValue |= (Bitdata)? (1<<1) : 0;
    Gpio_GetPinData(LCD_D0, &Bitdata);
    ReturnValue |= (Bitdata)? (1<<0) : 0;
    
#else /* gLCDGpioPinMode_c */
    uint32_t temp;
    Gpio_GetPortData(LCD_DATA_LO_PORT, &temp);
    ReturnValue = LCD_DATA_LO_READ(LCD_DATA_LO_MASK & temp);
    Gpio_GetPortData(LCD_DATA_HI_PORT, &temp);
    ReturnValue |= LCD_DATA_HI_READ(LCD_DATA_HI_MASK & temp);

#endif /* gLCDGpioPinMode_c */
    
    return ReturnValue;
}

/******************************************************************************
* This function gets the length of a string and return the length
*
* Interface assumptions:
*
*
* Return value:
* char
*
*
******************************************************************************/
static uint8_t GetStrlen
  (
  const uint8_t *pString /* IN: Pointer to text string */
  )
{
  int8_t count=0, length=0;

  while (*pString != '\0' && count <gMAX_LCD_CHARS_c ) {
    count++;
    length++;
    pString++;
  }

  /* Check boundries */
  if ( length > gMAX_LCD_CHARS_c ) {
    length = gMAX_LCD_CHARS_c;
  }

  return length;
}

/******************************************************************************
* This function draws a 24x24 pixels Icon
*
* Interface assumptions:
*
*
* Return value:
* char
*
*
******************************************************************************/
void LCD_DrawIcon(uint8_t u8XCoord, uint8_t u8YPage, uint8_t * pu8Icon)
{
  uint8_t u8i;
  uint8_t u8j;
  
  if (u8XCoord >= gLCDMaxColumns_c || u8YPage >= gLCDMaxRamDataPages_c)
  {
    return; /* if pixel out of screen exit */
  }

  for(u8i = 0; u8i < 3; u8i++)
  {
    LCD_WriteCommand(gLCDDisplayStartLineDefaultCommand_c);
    LCD_WriteCommand(gLCDPageAddressDefaultCommand_c + u8YPage++);
    LCD_WriteCommand(gLCDNibble0ColumnAddressDefaultCommand_c | ((u8XCoord & 0xF0)>>4));
    LCD_WriteCommand(gLCDNibble1ColumnAddressDefaultCommand_c | (u8XCoord & 0x0F));
    for(u8j = 0; u8j < 24; u8j++)
    {
      LCD_WriteData(*pu8Icon); 
      pu8Icon++;
    }
  }
  
}

#endif /* (gLCDSupported_d == 1) */