lcd.c

Go to the documentation of this file.

#include <includes.h>

// *******************************************************************************
// LCD Instructions
// *******************************************************************************
#define LCD_CLEAR 0x01   
#define LCD_HOME 0x02    
#define LCD_ENTRY_MODE 0x06   
#define LCD_FUNCTION_SET 0x38  
#define LCD_DISPLAY_ON 0x0C  
#define LCD_DISPLAY_OFF 0x08   
#define LCD_CURSOR_SHIFT_R 0x14  
#define LCD_CURSOR_SHIFT_L 0x10  
#define LCD_DISPLAY_SHIFT_R 0x1C  
#define LCD_DISPLAY_SHIFT_L 0x18  
#define LCD_BOTTOM_LINE 0xA0 
#define LCD_TOP_LINE 0x80 
#define LCD_LENGTH (100) 
#define QUAD_NUM (4) 
LCD_CHAR lcd_ring[QUAD_NUM][LCD_LENGTH]; 
unsigned int lcd_head[QUAD_NUM] = {0,0,0,0}; 
unsigned int lcd_tail[QUAD_NUM] = {0,0,0,0};
unsigned int lcd_period;
unsigned int lcd_quad = 0; 
VOID_VOID_F lcd_overflowfunc = voidvoid; 
//Annoying state stuff...
int lcd_wait = 0; //time to execute the next function
LCD_CHAR lcd_target_char;
LCD_STATE lcd_state = LCD_IDLE;

void lcd_write_instruction(unsigned char instruction)
{
  int i;
  // ****** WRITE INSTRUCTION ******
  FIO0CLR = (1<<15); // RS = 0 instruction
  FIO0CLR = (1<<10); // R/~W = 0 write
  FIO0SET = (1<<11); // EN = 1   
//  FIO0PIN0 = instruction;
  for (i = 0; i < 8; i++){
    lcd_write_bit(i, instruction & (1<<i));
  }
  FIO0CLR = (1<<11); // EN = 0, falling edge
  
  if (instruction == LCD_HOME || instruction == LCD_CLEAR){
    lcd_wait = 2000;
  } else {
    lcd_wait = 50; //in ms; time to wait before executing the next function
    //lcd_wait = lcd_period;
  }
}

void lcd_write_bit(unsigned int db, unsigned int bit)
{
  if (bit == 0){
    FIO0CLR = (1<<db);
  } else {
    FIO0SET = (1<<db);
  }
}

void lcd_write_data(unsigned char data)
{
  int i;
  // ****** WRITE BYTE ******
  FIO0SET = (1<<15); // RS = 1 data
  FIO0CLR = (1<<10); // R/~W = 0 write
  FIO0SET = (1<<11); // EN = 1
//  FIO0PIN0 = data;
  for (i = 0; i < 8; i++){
    lcd_write_bit(i, data & (1<<i));
  }
  FIO0CLR = (1<<11); // EN = 0, falling edge
  lcd_wait = lcd_period;
}

void lcd_print(char* string, unsigned int length, unsigned int start_pos)
{
  int i;
  for (i = 0; i < length; i++){
    lcd_print_char(string[i], start_pos + i);
  }
}

void lcd_print_char(char ch, unsigned int pos)
{    
  LCD_CHAR next_char;
  next_char.data = (unsigned char)ch;
  next_char.pos = pos % 16; //only acceptable positions are 0-15
  next_char.quad_num = pos/4;
  lcd_push(&next_char);
}

int lcd_push(LCD_CHAR* c)
{
  if ((lcd_head[(*c).quad_num] % LCD_LENGTH) != (lcd_tail[(*c).quad_num] % LCD_LENGTH) //ring not full
    || lcd_head[(*c).quad_num] == lcd_tail[(*c).quad_num]){ //or empty
    lcd_ring[(*c).quad_num][lcd_head[(*c).quad_num] % LCD_LENGTH] = *c;
    
    
    lcd_head[(*c).quad_num]++;
    return 1;
  } else { //buffer full, ignore new data
    error_occurred(ERROR_LCD_STR_OF);
    return 0;
  }
}

int lcd_pop(LCD_CHAR* c)
{
  //int i;
  //for(i = 0; i < 4; i++){ //check all buffers
    if (lcd_tail[0] != lcd_head[0]){ //buffer not empty
      *c = lcd_ring[0][lcd_tail[0] % LCD_LENGTH];
      lcd_tail[0]++;
      return 1;
    } 
  //}
    if (lcd_tail[1] != lcd_head[1]){ //buffer not empty
      *c = lcd_ring[1][lcd_tail[1] % LCD_LENGTH];
      lcd_tail[1]++;
      return 1;
    }
    if (lcd_tail[2] != lcd_head[2]){ //buffer not empty
      *c = lcd_ring[2][lcd_tail[2] % LCD_LENGTH];
      lcd_tail[2]++;
      return 1;
    }
    if (lcd_tail[3] != lcd_head[3]){ //buffer not empty
      *c = lcd_ring[3][lcd_tail[3] % LCD_LENGTH];
      lcd_tail[3]++;
      return 1;
    }
  return 0; //empty
}

void lcd_us_delay(long unsigned int delay_time_us)
{
  long unsigned int ii;
  for (ii = 0; ii < (delay_time_us*2)/5; ii++){}
}

void lcd_set_quad1(char c1, char c2, char c3, char c4)
{
  int i = 0;
  lcd_print_char(c1, i++);
  lcd_print_char(c2, i++);  
  lcd_print_char(c3, i++);
  lcd_print_char(c4, i++);
}

void lcd_set_quad2(char c1, char c2, char c3, char c4)
{
  int i = 4;
  lcd_print_char(c1, i++);
  lcd_print_char(c2, i++);  
  lcd_print_char(c3, i++);
  lcd_print_char(c4, i++);
}

void lcd_set_quad3(char c1, char c2, char c3, char c4)
{
  int i = 8;
  lcd_print_char(c1, i++);
  lcd_print_char(c2, i++);  
  lcd_print_char(c3, i++);
  lcd_print_char(c4, i++);
}

void lcd_set_quad4(char c1, char c2, char c3, char c4)
{
  int i = 12;
  lcd_print_char(c1, i++);
  lcd_print_char(c2, i++);  
  lcd_print_char(c3, i++);
  lcd_print_char(c4, i++);
}

void lcd_isr(void) __irq
{
  //executed every lcd_period ms, so decrement msec wait counter by that much
  lcd_wait -= lcd_period;
  
  // ****** EXECUTE IF ALLOWED ******
  if (lcd_wait <= 0){
    // ****** ACT ACCORDING TO STATE ******
    switch (lcd_state){
      case LCD_MOVE: 
        lcd_write_instruction(0x80 | ((lcd_target_char.pos/8)*0x40)+(lcd_target_char.pos%8));
        lcd_state = LCD_DISPLAY;
        break;
      case LCD_DISPLAY: 
        lcd_write_data(lcd_target_char.data);
        
        
        if (lcd_pop(&lcd_target_char)){
//          lcd_target_char = lcd_pop();
          lcd_state = LCD_MOVE;
        } else {
          lcd_state = LCD_IDLE;
        }
          break;
        case LCD_IDLE: 
        if (lcd_pop(&lcd_target_char)){
//          lcd_target_char = lcd_pop();
          lcd_state = LCD_MOVE;
        }
        break;
    }
  }

  lcd_overflowfunc();
  
  T1IR = 0xFFFFFFFF;  // Clear ALL Timer1 interrupt flags.
  VICVectAddr = 0;
}

void lcd_init(VOID_VOID_F overflowfunc)
{
  lcd_period = 60000000 / ((T1MR0 + 1) * 1000); //in ms 
  lcd_overflowfunc = overflowfunc;
  lcd_write_instruction(LCD_FUNCTION_SET);
  lcd_us_delay(200);     
  lcd_write_instruction(LCD_DISPLAY_ON);
  lcd_us_delay(200);
  lcd_write_instruction(LCD_ENTRY_MODE);
  lcd_us_delay(200);
  lcd_write_instruction(LCD_CLEAR);
  lcd_us_delay(3000);  
  lcd_write_instruction(LCD_HOME);
  lcd_us_delay(3000);
}