stk504_lcd.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
// Include files.
#include "stk504_lcd.h" // Contains Prototypes, Segment Definitions, and __flash lookup tables
#include "defines.h"            // Contains General Defines
#include <iom3290.h>            // Contains device specific definitions
#include <inavr.h>      // Included to be able to use intrinsic functions e.g. __delay_cycles();


volatile union _LCD_status LCD_status = {0x01};      
unsigned char LCD_timer = LCD_TIMER_SEED;       
unsigned char LCD_displayData[LCD_REGISTER_COUNT];   

__flash unsigned int LCD_character_table[] =
{
        0x0000,         // '*' (?)
        0x0000,         // '+'
        0x0000,         // ',' (Not defined)
        0x0000,         // '-'
        0x0000,         // '.' (Not defined)
        0x0000,         // '/' (Not defined)
        0x93C5,         // '0'
        0x80C0,         // '1'
        0x1994,         // '2'
        0x9894,         // '3'
        0x8891,         // '4'
        0x9815,         // '5'
        0x9915,         // '6'
        0x8084,         // '7'
        0x9995,         // '8'
        0x9895,         // '9'
        0x0000,         // ':' (Not defined)
        0x0000,         // ';' (Not defined)
        0x0000,         // '<' (Not defined)
        0x0000,         // '=' (Not defined)
        0x0000,         // '>' (Not defined)
        0x0000,         // '?' (Not defined)
        0x0000,         // '@' (Not defined)
        0x8995,         // 'A' (+ 'a')
        0xB8A4,         // 'B' (+ 'b')
        0x1105,         // 'C' (+ 'c')
        0xB0A4,         // 'D' (+ 'd')
        0x1915,         // 'E' (+ 'e')
        0x0915,         // 'F' (+ 'f')
        0x9905,         // 'G' (+ 'g')
        0x8991,         // 'H' (+ 'h')
        0x2020,         // 'I' (+ 'i')
        0x9180,         // 'J' (+ 'j')
        0x0551,         // 'K' (+ 'k')
        0x1101,         // 'L' (+ 'l')
        0x81C3,         // 'M' (+ 'm')
        0x8583,         // 'N' (+ 'n')
        0x9185,         // 'O' (+ 'o')
        0x0995,         // 'P' (+ 'p')
        0x9585,         // 'Q' (+ 'q')
        0x0D95,         // 'R' (+ 'r')
        0x1406,         // 'S' (+ 's')
        0x2024,         // 'T' (+ 't')
        0x9181,         // 'U' (+ 'u')
        0x0341,         // 'V' (+ 'v')
        0x8781,         // 'W' (+ 'w')
        0x0642,         // 'X' (+ 'x')
        0x2042,         // 'Y' (+ 'y')
        0x1244,         // 'Z' (+ 'z')
        0x0000,         // '[' (Not defined)
        0x0000,         // '\' (Not defined)
        0x0000,         // ']' (Not defined)
        0x0000,         // '^' (Not defined)
        0x0000          // '_' (Not defined)
};

__flash unsigned char LCD_digit_table[] =
{
        0xF0,           // '*' (Degree symbol)
        0x00,           // '+' (Not defined)
        0x00,           // ',' (Not defined)
        0x10,           // '-'
        0x00,           // '.' (Not defined)
        0x00,           // '/' (Not defined)
        0xEE,           // '0'
        0x44,           // '1'
        0xDA,           // '2'
        0xD6,           // '3'
        0x74,           // '4'
        0xB6,           // '5'
        0xBE,           // '6'
        0xC4,           // '7'
        0xFE,           // '8'
        0xF6,           // '9'
        0x00,           // ':' (Not defined)
        0x00,           // ';' (Not defined)
        0x00,           // '<' (Not defined)
        0x00,           // '=' (Not defined)
        0x00,           // '>' (Not defined)
        0x00,           // '?' (Not defined)
        0x00,           // '@' (Not defined)
        0xFC,           // 'A'
        0x3E,           // 'B'
        0xAA,           // 'C'
        0x5E,           // 'D'
        0xBA,           // 'E'
        0xB8,           // 'F'
};      


/******************************************************************************************
*
*       Function name : LCD_PutChar( unsigned char c, unsigned char digit )
*
******************************************************************************************/
void LCD_PutChar( unsigned char c, unsigned char digit )
{
        unsigned int seg, segMask;
        unsigned char i;
        unsigned char mask, nibble, nibbleMask;
        unsigned char *ptr;

   if ( digit == 0 || digit >=8)
   {
      return; //digit is out og range.
   }

        //Lookup character table for segment data.
        if ( (c >= '*') && (c <= 'z') )
        {
                if ( c >= 'a' ) c &= ~0x20; // c is in character_table. Convert to upper if necessarry.
                c -= '*';
                if ( c > 0x35 )
                {
                   return;     // c points outside array.
                }
                else
                {
                  seg = LCD_character_table[c];
                }       
        }
        else
        {
          return;               //ASCII code out of range.
        }

        // Adjust mask according to digit
        segMask = 0x4008;  // masking out two bits not part of the segment.

        i = digit-1;            //i used as pointer offset.
        if ( i >= 8 )           //Test if LCD digit is out of range.
                return;
        i >>= 1;
        ptr = LCD_displayData + i;      // Point to the first relevant LCDDR; i = {0,0,1,1,2,2}

        i = 4;                  //i used as loop counter.
        do
        {
          nibble = seg & 0x000F;
          nibbleMask = segMask & 0x000F;
                
          seg >>= 4;
          segMask >>= 4;
        
          if ( digit & 0x01 )
          {
            mask = 0xF0 | nibbleMask;
          }
          else
          {
            nibble <<= 4;
            mask = 0x0F | ( nibbleMask <<4 );
          }
          *ptr = (*ptr & mask) | nibble;  //Write new bit values.
          ptr += 5;
        } while ( --i );
}


/******************************************************************************************
*
*       Function name : LCD_PutDigit( unsigned char c, unsigned char digit )
*
******************************************************************************************/
void LCD_PutDigit( unsigned char c, unsigned char digit )
{
  unsigned char i, j, seg;
  unsigned char mask, lastnibblemask, lookupdata;
  unsigned char *ptr;

//special case for digit = 0
  if (digit == 0)
  {
      LCD_SetSeg( G8, 0 );
      LCD_SetSeg( BC8, 0 );
      if ( c == '-' )
      {
         LCD_SetSeg( G8, 1 );
      }
      else
      {
         if ( c == '1' )
         {
            LCD_SetSeg ( BC8, 1 );
         }
      }
      return;
   }

    if ( (c >= '*') && (c <= 'F') && (digit <= 4))
    {
      c -= '*';                                         
      lookupdata = LCD_digit_table[c];    // c is in character_table.
    }
    else
    {
      return;                             // ASCII code out of range.
    }

    ptr = LCD_displayData + 19;           // Point to the first relevant LCDDR; 19, 14, 9, 4

    for (j=0; j<4 ;j++)                   // Read out the 4 half-nibbles from lookupdata.
    {
      mask = 0xC0;
      lastnibblemask = 0x40;
      seg = ( lookupdata & mask );        // Variable lookupdata contains:
                                          //   msb| A | B | F | G | E | C | D |   |lsb (7seg)

      //Shift half-nibble and masks into correct location.
      for (i = digit-1; i>0; i--)
      {
         seg >>= 2;
         mask >>= 2;
         lastnibblemask >>= 2;
      }
      if (j == 3) //need special mask for the last half nibble since it contains only one valid bit.
      {
         mask = mask & ~lastnibblemask;
      }

      *ptr = (*ptr & ~mask) | seg;  //Write new bit values.
                ptr -= 5;
      lookupdata <<= 2;             //Prepare for next two bits.
   }
}


/******************************************************************************************
*
*       Function name : LCD_AllSegments( unsigned char input )
*
******************************************************************************************/
void LCD_AllSegments( unsigned char input )
{
        unsigned char i;
        unsigned char *ptr;

        if( input )               // If input == TRUE
                input = 0xFF;     // set segments to 0xFF.
                                  // (else set segments to 0x00)
        ptr = LCD_displayData;
        i = 20;
        do                        // Fill the display buffer.
        {
                *ptr++ = input;   // Set/clear the bits in all LCD registers.
        } while ( --i );
}



/******************************************************************************************
*
*       Function name : LCD_SetSeg(unsigned char symbol, unsigned char input)
*
******************************************************************************************/
void LCD_SetSeg(unsigned char symbol, unsigned char input)
{
  unsigned char offset;                 
  unsigned char setbit;
  unsigned char *ptr;

  // Symbol format = bbbnnnnn where b is bit[0..7] and n is offset[0..19]
  // Valid symbols are defined in stk504_lcd.h
  setbit = (symbol >> 5);
  offset = (symbol & 0x1F);
  if ( offset >= 20 )
  {
   return;  //data out of range of the LCD registers
  }
  ptr = LCD_displayData + offset;       // Point to the relevant LCDDR
  if ( input )
  {
      *ptr = (*ptr) | ( 1 << setbit);   // Set bit
  }
  else
  {
      *ptr = (*ptr) & ~( 1 << setbit);  // Clear bit
  }
}


/******************************************************************************************
*
*       Function name : LCD_BarSeg ( unsigned char value )
*
******************************************************************************************/
void LCD_BarSeg ( unsigned char value )
{
  unsigned char mask, i, n, m;
  unsigned char *ptr;
  mask = 0x80;

  ptr = LCD_displayData + 18;   // Point to the first relevant LCDDR; i = {0,0,1,1,2,2}

  for(n=0; n<4 ; n++)
  {
    i=0;
    for(m=0; m<2; m++)
    {
      i |= ( value & mask );
      i >>= 1;
      value <<= 1;  // Shift next bits into position
    }
    // At this point high variable i high nibble contain  | 0 | sn | sn+1 | 0 | starting with LSBs
    *ptr = i | (*ptr & 0x9F);     // 0x9F is mask to erase old bit values in
    ptr -= 5;                     // next segment register.
  }
}


/******************************************************************************************
*
*       Function name : LCD_Update(void)
*
******************************************************************************************/
void LCD_Update(void)
{
   unsigned char *src, *dest;
   unsigned char i;

   i = 20;
   dest = &pLCDREG;
   src = LCD_displayData;
   do
   {
      *dest++ = *src++;
   } while ( --i );
}


/******************************************************************************************
*
*       Function name : LCD_init(void)
*
******************************************************************************************/
void LCD_init(void)
{

  LCD_AllSegments( FALSE );                     // Clear segment buffer.
  PRR &= ~(1<<PRLCD);            // Make sure LCD isn't disabled in power reduction register
  LCDCRA = (1<<LCDEN);                          // Enable LCD.

  LCD_CONTRAST_LEVEL(LCD_INITIAL_CONTRAST);     //Set the LCD contrast level.

// Select asynchronous clock source, enable all COM pins and enable all segment pins.
  LCDCRB = (1<<LCDCS) | (1<<LCDMUX1) | (1<<LCDMUX0) | (1<<LCDPM3)| (1<<LCDPM2) | (1<<LCDPM1)| (1<<LCDPM0);
  LCDFRR = (1<<LCDPS0);                         // Set LCD prescaler to CLK(lcd)/64 = 64Hz.

  LCDCRA |= (1<<LCDIE);                         //Enable LCD_Start_frame interrupt.

}


/******************************************************************************
*
*   LCD Interrupt Routine
*
*******************************************************************************/
#pragma vector = LCD_vect
__interrupt void LCD_vect_interrupt( void )
{
  unsigned char i;
  unsigned char *src, *dest;

  LCD_timer--;
  if( LCD_timer == 0 )
  {
    if( LCD_status.updateRequired == TRUE )
    {
//      PINB = 0x40;

      LCD_timer = LCD_TIMER_SEED;
      LCD_status.updateComplete = TRUE;   // Set the ucLCD_ScrollReady to true.
      LCD_status.updateRequired = FALSE;  // No furter update necessary until
                                          //  another function changes buffer contents.
      // Latch display data buffer to I/O segment registers.
      i = 20;
      dest = &pLCDREG;
      src = LCD_displayData;
      do
      {
        *dest++ = *src++;
      } while ( --i );
    }
    else
    {
      LCD_timer = 1;                      //If LCD timer allows update of the LCD, but update is blocked
                                          // by LCD_status.updateRequired == FALSE the LCD_timer is preloaded
                                          // with smallest timer seed to ensure fastest LCD update.
      LCD_status.updateComplete = FALSE;  //Block for further access to the LCD_displayData until
                                          // LCD update has been performed.
    }
  }
}

// END //

---