WebSVN – svnkaklik – Diff – /programy/C/avr/SFR08/lcd_io.c


 
/****************************************************************************
 Title  :   C  file for the HD44780U LCD library (lcd_io.c)
 Author:    Chris efstathiou hendrix@otenet.gr
 Date:      1/Jul/2002
 Software:  AVR-GCC with AVR-AS
 Target:    any AVR device
 Comments:  This software is FREE.
 
*****************************************************************************/
#ifndef _IO_REG_MACRO_MODE_
#define _IO_REG_MACRO_MODE_  1     /* In case you have the new assignment mode io headers */
#endif
 
#ifndef  _SFR_ASM_COMPAT
#define  _SFR_ASM_COMPAT     1     /* This is for GCC 3.2 */
#endif
 
#include <io.h>
#include <progmem.h>
#include <eeprom.h>
#include "lcd_io.h"
 
/* constants/macros */
#ifndef CONCAT1
#define CONCAT1(a, b) CONCAT2(a, b)
#endif
 
#ifndef CONCAT2
#define CONCAT2(a, b) a ## b
#endif
 
#define LCD_POWER_ON_DELAY ( (20000*(F_CPU/60000))/100 )    /* 20 milliseconds */
#define LCD_INIT_DELAY     ( (5000*(F_CPU/60000))/100 )     /* 5 milliseconds */
 
#define INIT_MODE   2
#define DATA_MODE   1
#define CMD_MODE    0
 
 
/* CONVERSION OF LCD_DELAY_TIME TO TRUE MICROSECONDS */
#if LCD_READ_REQUIRED == 0 || LCD_IO_MODE == 2 || LCD_IO_MODE == 7
#define LCD_DELAY_SHORT ( (LCD_DELAY_TIME*(F_CPU/60000))/100 )
#define LCD_DELAY_LONG  ( LCD_DELAY_SHORT*40 )
#endif
 
 
 
/*######################################################################################################*/
#if LCD_IO_MODE == 2
/*######################################################################################################*/
 
#define LCD_DATA_PORT_IS_IO   1
#define LCD_CLOCK_PORT_IS_IO  1
 
#define LCD_DATA_PORT         CONCAT1(PORT,LCD_DATA_SIGNAL_PORT)
#define LCD_DATA_DDR_REG      CONCAT1(DDR,LCD_DATA_SIGNAL_PORT)
 
#define LCD_CLOCK_PORT        CONCAT1(PORT,LCD_CLOCK_SIGNAL_PORT) 
#define LCD_CLOCK_DDR_REG     CONCAT1(DDR,LCD_CLOCK_SIGNAL_PORT) 
 
#define LCD_READ_REQUIRED 0
 
 
 
#if defined(__AVR_ATmega103__)
 
#if LCD_DATA_PORT == PORTC 
#undef  LCD_DATA_PORT_IS_IO
#undef  LCD_DATA_DDR_REG
#define LCD_DATA_PORT_IS_IO   0
#endif
 
#if LCD_CLOCK_PORT == PORTC 
#undef  LCD_CLOCK_PORT_IS_IO
#undef  LCD_CLOCK_DDR_REG
#define LCD_CLOCK_PORT_IS_IO  0
#endif
#endif /* #if defined(__AVR_ATmega103__) */
 
/*######################################################################################################*/
#elif LCD_IO_MODE == 6
/*######################################################################################################*/
#define lcd_toggle_e()   ({ cbi(LCD_E_PORT, LCD_E_PIN); delay(F_CPU/6000000); \
                            sbi(LCD_E_PORT, LCD_E_PIN);  })
 
#if LCD_READ_REQUIRED == 1  
#undef  LCD_MULTIPLEX_REQUIRED
#define LCD_MULTIPLEX_REQUIRED   0
#define BUSY_FLAG   0
#define DATA        1
#endif
 
#if LCD_LINES == 1 || LCD_LINES == 2 || LCD_LINES == 4
#else
#error THE LCD LINES MUST BE 1 OR 2 OR 4 !
#endif
 
#define LCD_D4_PORT_IS_IO     1   
#define LCD_D5_PORT_IS_IO     1   
#define LCD_D6_PORT_IS_IO     1 
#define LCD_D7_PORT_IS_IO     1
#define LCD_RS_PORT_IS_IO     1
#define LCD_RW_PORT_IS_IO     1
#define LCD_E_PORT_IS_IO      1
 
#define LCD_D4_PORT           CONCAT1(PORT, LCD_DATA4_PORT)
#define LCD_D5_PORT           CONCAT1(PORT, LCD_DATA5_PORT)
#define LCD_D6_PORT           CONCAT1(PORT, LCD_DATA6_PORT)
#define LCD_D7_PORT           CONCAT1(PORT, LCD_DATA7_PORT)
#define LCD_RS_PORT           CONCAT1(PORT, LCD_RS_SIGNAL_PORT)
#define LCD_RW_PORT           CONCAT1(PORT, LCD_RW_SIGNAL_PORT)
#define LCD_E_PORT            CONCAT1(PORT, LCD_E_SIGNAL_PORT)
 
#define LCD_D4_DDR_REG        CONCAT1(DDR, LCD_DATA4_PORT)
#define LCD_D5_DDR_REG        CONCAT1(DDR, LCD_DATA5_PORT)
#define LCD_D6_DDR_REG        CONCAT1(DDR, LCD_DATA6_PORT)
#define LCD_D7_DDR_REG        CONCAT1(DDR, LCD_DATA7_PORT)
#define LCD_RS_DDR_REG        CONCAT1(DDR, LCD_RS_SIGNAL_PORT)
#define LCD_RW_DDR_REG        CONCAT1(DDR, LCD_RW_SIGNAL_PORT)
#define LCD_E_DDR_REG         CONCAT1(DDR, LCD_E_SIGNAL_PORT)
 
 
 
#if   LCD_READ_REQUIRED == 1
 
#define LCD_D4_PIN_REG        CONCAT1(PIN, LCD_DATA4_PORT)
#define LCD_D5_PIN_REG        CONCAT1(PIN, LCD_DATA5_PORT)
#define LCD_D6_PIN_REG        CONCAT1(PIN, LCD_DATA6_PORT)
#define LCD_D7_PIN_REG        CONCAT1(PIN, LCD_DATA7_PORT)
 
#elif LCD_READ_REQUIRED == 0
 
#undef LCD_RW_PORT
#undef LCD_RW_DDR_REG
#undef LCD_RW_PORT_IS_IO
 
#endif
 
 
 
#if defined(__AVR_ATmega103__)
 
#if LCD_D4_PORT == PORTC 
#if LCD_READ_REQUIRED == 1
#error THE PORT FOR LCD_D4 IS OUTPUT ONLY!
#endif
#undef  LCD_D4_PORT_IS_IO
#undef  LCD_D4_DDR_REG 
#define LCD_D4_PORT_IS_IO   0
#endif
 
#if LCD_D5_PORT == PORTC 
#if LCD_READ_REQUIRED == 1
#error THE PORT FOR LCD_D5 IS OUTPUT ONLY!
#endif
#undef  LCD_D5_PORT_IS_IO
#undef  LCD_D5_DDR_REG 
#define LCD_D5_PORT_IS_IO   0
#endif
 
#if LCD_D6_PORT == PORTC 
#if LCD_READ_REQUIRED == 1
#error THE PORT FOR LCD_D6 IS OUTPUT ONLY!
#endif
#undef  LCD_D6_PORT_IS_IO
#undef  LCD_D6_DDR_REG 
#define LCD_D6_PORT_IS_IO   0
#endif
 
#if LCD_D7_PORT == PORTC 
#if LCD_READ_REQUIRED == 1
#error THE PORT FOR LCD_D7 IS OUTPUT ONLY!
#endif
#undef  LCD_D7_PORT_IS_IO
#undef  LCD_D7_DDR_REG 
#define LCD_D7_PORT_IS_IO   0
#endif
 
#if LCD_RS_PORT == PORTC 
#undef  LCD_RS_PORT_IS_IO
#undef  LCD_RS_DDR_REG 
#define LCD_RS_PORT_IS_IO   0
#endif
 
#if LCD_READ_REQUIRED == 1 
#if LCD_RW_PORT == PORTC 
#undef  LCD_RW_PORT_IS_IO
#undef  LCD_RW_DDR_REG 
#define LCD_RW_PORT_IS_IO   0
#endif 
#endif
 
#if LCD_E_PORT == PORTC 
#undef  LCD_E_PORT_IS_IO
#undef  LCD_E_DDR_REG 
#define LCD_E_PORT_IS_IO    0
#endif
 
#endif /* #if defined(__AVR_ATmega103__) */
 
/*######################################################################################################*/
#elif LCD_IO_MODE == 7
/*######################################################################################################*/
 
#define lcd_toggle_e()   ({ cbivar(lcd_E_port, lcd_E_pin); delay(F_CPU/6000000); \
                            sbivar(lcd_E_port, lcd_E_pin);  })
#if SREG > 0X3F
#define IO_TO_MEM_OFFSET  0
#else
#define IO_TO_MEM_OFFSET  0X20
#endif
 
#define LCD_READ_REQUIRED 0  
 
#if LCD_0_LINES == 1 || LCD_0_LINES == 2 || LCD_0_LINES == 4
#else
#error THE LCD LINES MUST BE 1 OR 2 OR 4 !
#endif
 
#if LCD_1_LINES == 1 || LCD_1_LINES == 2 || LCD_1_LINES == 4
#else
#error THE LCD LINES MUST BE 1 OR 2 OR 4 !
#endif
 
#if NUMBER_OF_LCD_UNITS >= 3
#if LCD_2_LINES == 1 || LCD_2_LINES == 2 || LCD_2_LINES == 4
#else
#error THE LCD LINES MUST BE 1 OR 2 OR 4 !
#endif
#endif
 
#define LCD_D4_PORT_IS_IO     1   
#define LCD_D5_PORT_IS_IO     1   
#define LCD_D6_PORT_IS_IO     1 
#define LCD_D7_PORT_IS_IO     1
#define LCD_RS_PORT_IS_IO     1
#define LCD_0_E_PORT_IS_IO    1
#define LCD_1_E_PORT_IS_IO    1
 
#if NUMBER_OF_LCD_UNITS >=3
#define LCD_2_E_PORT_IS_IO    1
#endif
 
#define LCD_D4_PORT           CONCAT1(PORT, LCD_DATA4_PORT)
#define LCD_D5_PORT           CONCAT1(PORT, LCD_DATA5_PORT)
#define LCD_D6_PORT           CONCAT1(PORT, LCD_DATA6_PORT)
#define LCD_D7_PORT           CONCAT1(PORT, LCD_DATA7_PORT)
#define LCD_RS_PORT           CONCAT1(PORT, LCD_RS_SIGNAL_PORT)
#define LCD_0_E_PORT          CONCAT1(PORT, LCD_0_E_SIGNAL_PORT)
#define LCD_1_E_PORT          CONCAT1(PORT, LCD_1_E_SIGNAL_PORT)
 
#if NUMBER_OF_LCD_UNITS >=3
#define LCD_2_E_PORT          CONCAT1(PORT, LCD_2_E_SIGNAL_PORT)
#endif
 
#define LCD_D4_DDR_REG        CONCAT1(DDR, LCD_DATA4_PORT)
#define LCD_D5_DDR_REG        CONCAT1(DDR, LCD_DATA5_PORT)
#define LCD_D6_DDR_REG        CONCAT1(DDR, LCD_DATA6_PORT)
#define LCD_D7_DDR_REG        CONCAT1(DDR, LCD_DATA7_PORT)
#define LCD_RS_DDR_REG        CONCAT1(DDR, LCD_RS_SIGNAL_PORT)
#define LCD_0_E_DDR_REG       CONCAT1(DDR, LCD_0_E_SIGNAL_PORT)
#define LCD_1_E_DDR_REG       CONCAT1(DDR, LCD_1_E_SIGNAL_PORT)
 
#if NUMBER_OF_LCD_UNITS >=3
#define LCD_2_E_DDR_REG       CONCAT1(DDR, LCD_2_E_SIGNAL_PORT)
#endif
 
 
#if defined(__AVR_ATmega103__)
 
#if LCD_D4_PORT == PORTC 
#undef  LCD_D4_PORT_IS_IO
#undef  LCD_D4_DDR_REG 
#define LCD_D4_PORT_IS_IO   0
#endif
 
#if LCD_D5_PORT == PORTC 
#undef  LCD_D5_PORT_IS_IO
#undef  LCD_D5_DDR_REG 
#define LCD_D5_PORT_IS_IO   0
#endif
 
#if LCD_D6_PORT == PORTC 
#undef  LCD_D6_PORT_IS_IO
#undef  LCD_D6_DDR_REG 
#define LCD_D6_PORT_IS_IO   0
#endif
 
#if LCD_D7_PORT == PORTC 
#undef  LCD_D7_PORT_IS_IO
#undef  LCD_D7_DDR_REG 
#define LCD_D7_PORT_IS_IO   0
#endif
 
#if LCD_RS_PORT == PORTC 
#undef  LCD_RS_PORT_IS_IO
#undef  LCD_RS_DDR_REG 
#define LCD_RS_PORT_IS_IO   0
#endif
 
#if LCD_0_E_PORT == PORTC 
#undef  LCD_0_E_PORT_IS_IO
#undef  LCD_0_E_DDR_REG 
#define LCD_0_E_PORT_IS_IO  0
#endif
 
#if LCD_1_E_PORT == PORTC 
#undef  LCD_1_E_PORT_IS_IO
#undef  LCD_1_E_DDR_REG 
#define LCD_1_E_PORT_IS_IO  0
#endif
 
#if NUMBER_OF_LCD_UNITS >=3
#if LCD_2_E_PORT == PORTC 
#undef  LCD_2_E_PORT_IS_IO
#undef  LCD_2_E_DDR_REG 
#define LCD_2_E_PORT_IS_IO  0
#endif
#endif  /*  #if NUMBER_OF_LCD_UNITS >=3  */
 
#endif  /*  #if defined(__AVR_ATmega103__)  */
 
#endif  /*  #elif LCD_IO_MODE == 7 */   
/*######################################################################################################*/
 
/* type definitions */
 
typedef unsigned char  u08;
typedef unsigned short u16;
 
/*######################################################################################################*/
/* FUNCTION PROTOTYPES                                                                                  */
/*######################################################################################################*/
 
#if LCD_IO_MODE == 7
static void sbivar(unsigned char port, unsigned char bit);
static void cbivar(unsigned char port, unsigned char bit);
#endif
 
#if  LCD_READ_REQUIRED == 1
static unsigned char lcd_read(unsigned char rs);
static inline unsigned char lcd_waitbusy(void);
#endif
 
static void delay(unsigned long int us);
 
/*######################################################################################################*/
/* GLOBAL variables                                                                                     */
/*######################################################################################################*/
 
static unsigned char x,y, putc_lock=0;
#if LCD_IO_MODE == 7
static unsigned char lcd_E_port=0, lcd_E_pin=0, lcd_chars_per_line=0, lcd_lines=0, current_lcd_unit=0;
static struct xy {
                   unsigned char x;
                   unsigned char y;
                 } xy_coordinates[NUMBER_OF_LCD_UNITS];
 
#endif
 
/*######################################################################################################*/
/* local functions */
/*######################################################################################################*/
 
static void delay(unsigned long int us)
/* delay for a minimum of <us> microseconds (with a 6 Mhz crystal, the resolution is 1 us) */
{
   while ( us ) { us--; }  /* 6 cpu cycles per loop */
} 
 
/*######################################################################################################*/
#if LCD_IO_MODE == 7   /* lcd_write() function for 6 bit i/o one lcd unit */
/*######################################################################################################*/
 
 
static void sbivar(unsigned char port, unsigned char bit)
{
register unsigned char temp=0;
 
    temp=*((unsigned char*)(port+IO_TO_MEM_OFFSET));
    temp|= (1<<bit);
    *((unsigned char*)(port+IO_TO_MEM_OFFSET))=temp;
 
return;
}
/*######################################################################################################*/
 
static void cbivar(unsigned char port, unsigned char bit)
{
register unsigned char temp=0;
 
    temp=*((unsigned char*)(port+IO_TO_MEM_OFFSET));
    temp &= ~(1<<bit);
    *((unsigned char*)(port+IO_TO_MEM_OFFSET))=temp;
 
return;
}
/*######################################################################################################*/
 
static void lcd_write(unsigned char data, unsigned char mode) 
{
register unsigned char rs=0; 
       
 
       if(mode==DATA_MODE) rs=1; else rs=0;          /* set the rs value */
       /* output high nibble first */ 
       if(data&0x10) sbi(LCD_D4_PORT, LCD_D4_PIN);   else cbi(LCD_D4_PORT, LCD_D4_PIN);
       if(data&0x20) sbi(LCD_D5_PORT, LCD_D5_PIN);   else cbi(LCD_D5_PORT, LCD_D5_PIN);
       if(data&0x40) sbi(LCD_D6_PORT, LCD_D6_PIN);   else cbi(LCD_D6_PORT, LCD_D6_PIN);
       if(data&0x80) sbi(LCD_D7_PORT, LCD_D7_PIN);   else cbi(LCD_D7_PORT, LCD_D7_PIN);
       if(rs) sbi(LCD_RS_PORT, LCD_RS_PIN);          else cbi(LCD_RS_PORT, LCD_RS_PIN);
       lcd_toggle_e();
       /* output low nibble */
       /* if INIT_MODE skip this section else execute it */
       if(mode!=INIT_MODE)
        {
          if(data&0x01) sbi(LCD_D4_PORT, LCD_D4_PIN);   else cbi(LCD_D4_PORT, LCD_D4_PIN);
          if(data&0x02) sbi(LCD_D5_PORT, LCD_D5_PIN);   else cbi(LCD_D5_PORT, LCD_D5_PIN);
          if(data&0x04) sbi(LCD_D6_PORT, LCD_D6_PIN);   else cbi(LCD_D6_PORT, LCD_D6_PIN);
          if(data&0x08) sbi(LCD_D7_PORT, LCD_D7_PIN);   else cbi(LCD_D7_PORT, LCD_D7_PIN);
          if(rs) sbi(LCD_RS_PORT, LCD_RS_PIN);          else cbi(LCD_RS_PORT, LCD_RS_PIN);
          lcd_toggle_e();
        }
 
 delay(LCD_DELAY_SHORT);
 
}
/*------------------------------------------------------------------------------------------------------*/
void  select_lcd(unsigned char lcd_unit)
{
/* Save the current lcd unit x,y coordinates */
   xy_coordinates[current_lcd_unit].x=x;
   xy_coordinates[current_lcd_unit].y=y;
 
   if(lcd_unit==0)
    {
       lcd_E_port= LCD_0_E_PORT;
       lcd_E_pin = LCD_0_E_PIN;
       lcd_chars_per_line = LCD_0_CHARS_PER_LINE;
       lcd_lines = LCD_0_LINES;
       current_lcd_unit=lcd_unit;     /* Make the requested lcd unit current (active) */
       x=xy_coordinates[lcd_unit].x;  /* Load the saved x,y coordinates of the specified lcd unit */
       y=xy_coordinates[lcd_unit].y;
    }
   else if(lcd_unit==1)
         {
            lcd_E_port= LCD_1_E_PORT;
            lcd_E_pin = LCD_1_E_PIN;
            lcd_chars_per_line = LCD_1_CHARS_PER_LINE;
            lcd_lines = LCD_1_LINES;
            current_lcd_unit=lcd_unit;
            x=xy_coordinates[lcd_unit].x;
            y=xy_coordinates[lcd_unit].y;
         }
#if NUMBER_OF_LCD_UNITS >=3
   else if(lcd_unit==2)
         {
            lcd_E_port= LCD_2_E_PORT;
            lcd_E_pin = LCD_2_E_PIN;
            lcd_chars_per_line = LCD_2_CHARS_PER_LINE;
            lcd_lines = LCD_2_LINES;
            current_lcd_unit=lcd_unit;
            x=xy_coordinates[lcd_unit].x;
            y=xy_coordinates[lcd_unit].y;
         }
#endif
return;
}
/*######################################################################################################*/
#elif LCD_IO_MODE == 6   /* lcd_write() function for 6 bit i/o  with multi lcd units */
/*######################################################################################################*/
 
#if LCD_READ_REQUIRED == 1 
 
#define LCD_READ_DELAY  ( (10*(F_CPU/60000))/100 )
 
static unsigned char lcd_read(unsigned char rs) 
{
register unsigned char data=0;
/* RS=1: read data, RS=0: read busy flag, RW=1  read mode */  
    if (rs) sbi(LCD_RS_PORT, LCD_RS_PIN); else cbi(LCD_RS_PORT, LCD_RS_PIN);    
 
    /* configure data pins as input */
    cbi(LCD_D4_DDR_REG, LCD_D4_PIN );
    cbi(LCD_D5_DDR_REG, LCD_D5_PIN );
    cbi(LCD_D6_DDR_REG, LCD_D6_PIN );
    cbi(LCD_D7_DDR_REG, LCD_D7_PIN );
 
    /* set R/W pin for reading from LCD */
    sbi(LCD_RW_PORT, LCD_RW_PIN); 
    delay(LCD_READ_DELAY);
 
    if(bit_is_set(LCD_D7_PIN_REG, LCD_D7_PIN)) { data+=1; }
    data=(data<<1);
    if(bit_is_set(LCD_D6_PIN_REG, LCD_D6_PIN)) { data+=1; }
    data=(data<<1);
    if(bit_is_set(LCD_D5_PIN_REG, LCD_D5_PIN)) { data+=1; }
    data=(data<<1);
    if(bit_is_set(LCD_D4_PIN_REG, LCD_D4_PIN)) { data+=1; }
    data=(data<<1);
 
    lcd_toggle_e();
    delay(LCD_READ_DELAY);
 
    if(bit_is_set(LCD_D7_PIN_REG, LCD_D7_PIN)) { data+=1; }
    data=(data<<1);
    if(bit_is_set(LCD_D6_PIN_REG, LCD_D6_PIN)) { data+=1; }
    data=(data<<1);
    if(bit_is_set(LCD_D5_PIN_REG, LCD_D5_PIN)) { data+=1; }
    data=(data<<1);
    if(bit_is_set(LCD_D4_PIN_REG, LCD_D4_PIN)) { data+=1; }
    
    lcd_toggle_e();
 
    /* clear R/W pin for writting to LCD */
    cbi(LCD_RW_PORT, LCD_RW_PIN);      
 
    /* configure data pins as outputs */
    sbi(LCD_D4_DDR_REG, LCD_D4_PIN );
    sbi(LCD_D5_DDR_REG, LCD_D5_PIN );
    sbi(LCD_D6_DDR_REG, LCD_D6_PIN );
    sbi(LCD_D7_DDR_REG, LCD_D7_PIN );
    
 
return (data);
}
/*######################################################################################################*/
static inline unsigned char lcd_waitbusy(void)
/* loops while lcd is busy, reads address counter */
{
register unsigned char c;
    
    while ( (c=lcd_read(BUSY_FLAG) & (1<<LCD_BUSY)) ); 
 
    return (c);  // return address counter
}
 
#endif  /* #if LCD_READ_REQUIRED == 1  */
/*######################################################################################################*/
 
static void lcd_write(unsigned char data, unsigned char mode) 
{
register unsigned char rs=0; 
 
 /* save and set DDR(X) register(s) in case another program altered those values */
#if LCD_MULTIPLEX_ENABLE == 1
 
#if LCD_D4_PORT_IS_IO==1
unsigned char d4_is_output=0;
if(inp(LCD_D4_DDR_REG)&(1<<LCD_D4_PIN)) { d4_is_output=1; }
sbi(LCD_D4_DDR_REG, LCD_D4_PIN );
#endif
#if LCD_D5_PORT_IS_IO==1
unsigned char d5_is_output=0;
if(inp(LCD_D5_DDR_REG)&(1<<LCD_D5_PIN)) { d5_is_output=1; }
sbi(LCD_D5_DDR_REG, LCD_D5_PIN );
#endif
#if LCD_D6_PORT_IS_IO==1
unsigned char d6_is_output=0;
if(inp(LCD_D6_DDR_REG)&(1<<LCD_D6_PIN)) { d6_is_output=1; }
sbi(LCD_D6_DDR_REG, LCD_D6_PIN );
#endif
#if LCD_D7_PORT_IS_IO==1
unsigned char d7_is_output=0;
if(inp(LCD_D7_DDR_REG)&(1<<LCD_D7_PIN)) { d7_is_output=1; }
sbi(LCD_D7_DDR_REG, LCD_D7_PIN );
#endif
#if LCD_RS_PORT_IS_IO==1
unsigned char rs_is_output=0;
if(inp(LCD_RS_DDR_REG)&(1<<LCD_RS_PIN)) { rs_is_output=1; }
sbi(LCD_RS_DDR_REG, LCD_RS_PIN );
#endif
 
#endif  /* LCD_MULTIPLEX_ENABLE == 1 */
 
       if(mode==DATA_MODE) rs=1; else rs=0;          /* set the rs value */
       /* output high nibble first */ 
       if(data&0x10) sbi(LCD_D4_PORT, LCD_D4_PIN);   else cbi(LCD_D4_PORT, LCD_D4_PIN);
       if(data&0x20) sbi(LCD_D5_PORT, LCD_D5_PIN);   else cbi(LCD_D5_PORT, LCD_D5_PIN);
       if(data&0x40) sbi(LCD_D6_PORT, LCD_D6_PIN);   else cbi(LCD_D6_PORT, LCD_D6_PIN);
       if(data&0x80) sbi(LCD_D7_PORT, LCD_D7_PIN);   else cbi(LCD_D7_PORT, LCD_D7_PIN);
       if(rs) sbi(LCD_RS_PORT, LCD_RS_PIN);          else cbi(LCD_RS_PORT, LCD_RS_PIN);
       lcd_toggle_e();
       /* output low nibble */
       /* if INIT_MODE skip this section else execute it */
       if(mode!=INIT_MODE)
        {
          if(data&0x01) sbi(LCD_D4_PORT, LCD_D4_PIN);   else cbi(LCD_D4_PORT, LCD_D4_PIN);
          if(data&0x02) sbi(LCD_D5_PORT, LCD_D5_PIN);   else cbi(LCD_D5_PORT, LCD_D5_PIN);
          if(data&0x04) sbi(LCD_D6_PORT, LCD_D6_PIN);   else cbi(LCD_D6_PORT, LCD_D6_PIN);
          if(data&0x08) sbi(LCD_D7_PORT, LCD_D7_PIN);   else cbi(LCD_D7_PORT, LCD_D7_PIN);
          if(rs) sbi(LCD_RS_PORT, LCD_RS_PIN);          else cbi(LCD_RS_PORT, LCD_RS_PIN);
          lcd_toggle_e();
        }
#if   LCD_READ_REQUIRED == 0
 delay(LCD_DELAY_SHORT);
#elif LCD_READ_REQUIRED == 1
 lcd_waitbusy();
#endif
 
/* Restore the DDR registers, if multiplexing wanted */     
#if LCD_MULTIPLEX_ENABLE == 1 
 
#if LCD_D4_PORT_IS_IO==1
if(!d4_is_output) { cbi(LCD_D4_DDR_REG, LCD_D4_PIN ); } 
#endif
#if LCD_D5_PORT_IS_IO==1
if(!d5_is_output) { cbi(LCD_D5_DDR_REG, LCD_D5_PIN ); }
#endif
#if LCD_D6_PORT_IS_IO==1
if(!d6_is_output) { cbi(LCD_D6_DDR_REG, LCD_D6_PIN ); }
#endif
#if LCD_D7_PORT_IS_IO==1
if(!d7_is_output) { cbi(LCD_D7_DDR_REG, LCD_D7_PIN ); }
#endif
#if LCD_RS_PORT_IS_IO==1
if(!rs_is_output) { cbi(LCD_RS_DDR_REG, LCD_RS_PIN ); }
#endif
 
#endif  /* LCD_MULTIPLEX_ENABLE == 1 */
}
/*######################################################################################################*/
#elif LCD_IO_MODE == 2  /* lcd_write() function for 2 bit i/o */
/*######################################################################################################*/
 
static void lcd_write(unsigned char lcd_data,unsigned char mode) 
{
#define toggle_clock() ({ sbi(LCD_CLOCK_PORT, LCD_CLOCK_PIN); cbi(LCD_CLOCK_PORT, LCD_CLOCK_PIN); }) 
#define data(x) ({ if(x) sbi(LCD_DATA_PORT, LCD_DATA_PIN); else cbi(LCD_DATA_PORT, LCD_DATA_PIN); })        
#define toggle_data()       ({ data(1); delay(F_CPU/6000000); data(0); })
 
register unsigned char x=0, rs=0;
 
       /* INITIALIZATION */
       /* Set clock and data pins as outputs, at low state and set rs value */ 
#if LCD_CLOCK_PORT_IS_IO
  sbi(LCD_CLOCK_DDR_REG, LCD_CLOCK_PIN); 
#endif
#if LCD_DATA_PORT_IS_IO
  sbi(LCD_DATA_DDR_REG, LCD_DATA_PIN);
#endif
       cbi(LCD_CLOCK_PORT, LCD_CLOCK_PIN); cbi(LCD_DATA_PORT, LCD_DATA_PIN); 
       if(mode==DATA_MODE) rs=1; else rs=0;
       
       /* send high nibble first */
       x=6; while(x--)   {  toggle_clock();  }           /* clear shift register */           
       data(1);             toggle_clock();              /* send E "AND" signal */
       data(rs);            toggle_clock();              /* send RS signal */
       x=0x80; while(x>=0x10) { data(lcd_data&x); toggle_clock(); x=(x>>1); }
       /* Strobe E pin making sure that the pulse is 450 ns min */
       toggle_data();   
       
       /* send low nibble  Clock and Data are already low */
       x=6; while(x--)   {  toggle_clock();  }           /* clear shift register */       
       data(1);             toggle_clock();              /* send E "AND" signal */
       data(rs);            toggle_clock();              /* send RS signal */
       x=0x08; while(x>=0x01) { data(lcd_data&x); toggle_clock(); x=(x>>1); }
       /* if INIT_MODE do NOT strobe the E pin else strobe it */
       if(mode!=INIT_MODE) { toggle_data(); }       
       
       delay(LCD_DELAY_SHORT);     /* wait for command to execute  */     
      
}
/*######################################################################################################*/
#endif /* #elif LCD_IO_MODE == 2 */
/*######################################################################################################*/
 
/*######################################################################################################*/
/* PUBLIC FUNCTIONS */
/*######################################################################################################*/
void lcd_command(unsigned char cmd)
/* send command <cmd> to LCD */
{
    lcd_write(cmd,CMD_MODE);
    
}
/*######################################################################################################*/
 
void lcd_gotoxy(unsigned char lcd_x, unsigned char lcd_y)
/* goto position (x,y) */
{
#if LCD_IO_MODE == 7 
 
if(lcd_x >= lcd_chars_per_line || lcd_y >= lcd_lines) { putc_lock=1; return; }
else putc_lock=0;
 
    if (lcd_y==0 )    { lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+lcd_x); }
    else if(lcd_y==1) { lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+lcd_x); }
    else if(lcd_y==2) { lcd_command((1<<LCD_DDRAM)+LCD_START_LINE3+lcd_x); }
    else              { lcd_command((1<<LCD_DDRAM)+LCD_START_LINE4+lcd_x); }
/*------------------------------------------------------------------------------------------------------*/
#elif LCD_IO_MODE == 6 || LCD_IO_MODE == 2
/*------------------------------------------------------------------------------------------------------*/
 
if(lcd_x >= LCD_CHARS_PER_LINE || lcd_y >= LCD_LINES) { putc_lock=1; return; }
else putc_lock=0;
    
#if LCD_LINES==1
    if (lcd_y==0 ) { lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+lcd_x); }
#endif
#if LCD_LINES==2
    if (lcd_y==0 ) { lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+lcd_x);  }
    else           { lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+lcd_x);  }
#endif
 
#if LCD_LINES==4
    if (lcd_y==0 )    { lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+lcd_x); }
    else if(lcd_y==1) { lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+lcd_x); }
    else if(lcd_y==2) { lcd_command((1<<LCD_DDRAM)+LCD_START_LINE3+lcd_x); }
    else              { lcd_command((1<<LCD_DDRAM)+LCD_START_LINE4+lcd_x); }
#endif
#endif
    x=lcd_x;
    y=lcd_y;
 
}/* lcd_gotoxy */
/*######################################################################################################*/
 
unsigned int lcd_getxy(void)
{
  return((y*100)+x); 
}
/*######################################################################################################*/
 
void lcd_clrscr(void)
/* clear lcd and set cursor to home position */
{
   lcd_command(1<<LCD_CLR);
#if LCD_READ_REQUIRED == 0 || LCD_IO_MODE == 2 || LCD_IO_MODE == 7
   delay(LCD_DELAY_LONG);       /* this command needs more waiting time to execute */
#elif LCD_READ_REQUIRED == 1 && LCD_IO_MODE == 6  
   lcd_waitbusy();
#endif
               
   x=0; y=0;
}
/*######################################################################################################*/
 
void lcd_clrline(unsigned char line)
/* clear a specific lcd line and set cursor at the start of the line */
{
#if LCD_IO_MODE == 7
   if(lcd_lines==1)
    {
       lcd_gotoxy(0, 0);
       while(x<lcd_chars_per_line) { lcd_putc(' '); }
       lcd_gotoxy(0, 0);
    }    
   
   if(line<lcd_lines)
    {
       lcd_gotoxy(0, line);
       while(x<lcd_chars_per_line) { lcd_putc(' '); }
       lcd_gotoxy(0, line);
    }   
 
#elif LCD_IO_MODE == 6 || LCD_IO_MODE == 2
 
#if LCD_LINES == 1
  lcd_gotoxy(0, 0);
  while(x<LCD_CHARS_PER_LINE) { lcd_putc(' '); }
  lcd_gotoxy(0, 0);
#else  /* #if LCD_LINES == 1 */
  if(line<LCD_LINES)
   {
      lcd_gotoxy(0, line);
      while(x<LCD_CHARS_PER_LINE) { lcd_putc(' '); }
      lcd_gotoxy(0, line);
   }   
#endif  /*  #if LCD_LINES == 1  */
#endif  /*  #if LCD_IO_MODE == 7 */
}
/*######################################################################################################*/
 
void lcd_home(void)
/* set cursor to home position */
{
    lcd_command(1<<LCD_HOME);
#if LCD_READ_REQUIRED == 0 || LCD_IO_MODE == 2 || LCD_IO_MODE == 7
    delay(LCD_DELAY_LONG);       /* this command needs more waiting time to execute */
#elif LCD_READ_REQUIRED == 1 && LCD_IO_MODE == 6 
    lcd_waitbusy();
#endif    
    x=0; y=0;
}
/*######################################################################################################*/
 
void lcd_putc(unsigned char c)
/* print character at current cursor position */
{
 if(!putc_lock)
  {
#if LCD_IO_MODE == 7
   if(lcd_lines !=1)
    {  if(c=='\n') { if(y<lcd_lines-1) lcd_gotoxy(0,(y+1)); }
       else if(x<lcd_chars_per_line) { lcd_write(c, DATA_MODE); x++; }
#if LCD_AUTO_LINE_FEED == 1
       else if(y<lcd_lines-1) { lcd_gotoxy(0,(y+1)); lcd_write(c, DATA_MODE); x++; }
       else { lcd_gotoxy(0,0); lcd_write(c, DATA_MODE); x++; }
#endif
    }
   else{
         if(c=='\n') { return; }
         if(x<lcd_chars_per_line) { lcd_write(c, DATA_MODE); x++; }
       }
#elif LCD_IO_MODE == 6 || LCD_IO_MODE == 2
 
#if LCD_LINES!=1
       if(c=='\n') { if(y<LCD_LINES-1) lcd_gotoxy(0,(y+1)); }
       else if(x<LCD_CHARS_PER_LINE) { lcd_write(c, DATA_MODE); x++; }
#if LCD_AUTO_LINE_FEED == 1
       else if(y<LCD_LINES-1) { lcd_gotoxy(0,(y+1)); lcd_write(c, DATA_MODE); x++; }
       else { lcd_gotoxy(0,0); lcd_write(c, DATA_MODE); x++; }
#endif
 
#else
       if(c=='\n') { return; }
       if(x<LCD_CHARS_PER_LINE) { lcd_write(c, DATA_MODE); x++; }
#endif
 
#endif  /*   #if LCD_IO_MODE == 7  */       
  }  
}
/*######################################################################################################*/
 
void lcd_puts(const unsigned char *s)
/* print string on lcd (no auto linefeed) */
{
    register unsigned char c;
 
    while ( (c = *s++) ) { lcd_putc(c);  }
 
}
/*######################################################################################################*/
 
void lcd_puts_p(const unsigned char *progmem_s)
/* print string from program memory on lcd (no auto linefeed) */
{
    register unsigned char c;
 
    while ( (c = PRG_RDB(progmem_s++)) ) { lcd_putc(c);  }
 
}
/*######################################################################################################*/
 
void lcd_puts_e(unsigned char *eeprom_s)
/* print string from eeprom on lcd (no auto linefeed) */
{
 register unsigned char c;
   
    while( (c=eeprom_rb((unsigned int)eeprom_s++))&& c!=0xFF ) { lcd_putc(c);  }
    /*{ if(c==0xFF) break; lcd_putc(c);  }*/               
}
/*######################################################################################################*/
 
void lcd_puti(int value, unsigned char dot_position)
/* print signed integer on lcd with or without comma (no auto linefeed) */
{
unsigned char lcd_data[6]={'0','0','0','0','0','0' }, position=sizeof(lcd_data), radix=10; 
 
        /* convert int to ascii  */ 
        if(value<0) { lcd_putc('-'); value=-value; }    
        do { position--; *(lcd_data+position)=(value%radix)+'0'; value/=radix;  } while(value); 
 
        /* some fractional digit corrections  */
        if( dot_position>=sizeof(lcd_data) ) return;
        while( (sizeof(lcd_data)-dot_position)<=position )  position--; 
 
        /* start displaying the number */
        for(;position<=(sizeof(lcd_data)-1);position++)
          {
            if( position==sizeof(lcd_data)-dot_position ) lcd_putc(',');  
            lcd_putc(lcd_data[position]);
          }
 
return;
}
/*######################################################################################################*/
#if LCD_IO_MODE == 6 || LCD_IO_MODE == 2
/*######################################################################################################*/
 
void lcd_init(void)
{
/* initialize display and select type of cursor */
/* dispAttr: LCD_DISP_OFF, LCD_DISP_ON, LCD_DISP_ON_CURSOR, LCD_DISP_CURSOR_BLINK */
 
#if LCD_LINES==1
#define LCD_FUNCTION_DEFAULT    LCD_FUNCTION_4BIT_1LINE 
#else
#define LCD_FUNCTION_DEFAULT    LCD_FUNCTION_4BIT_2LINES 
#endif 
 
#if LCD_IO_MODE == 6  
 
#if LCD_E_PORT_IS_IO==1
sbi(LCD_E_DDR_REG, LCD_E_PIN  );
#endif        
sbi(LCD_E_PORT, LCD_E_PIN  ); 
 
#if LCD_MULTIPLEX_ENABLE == 0 
 
#if LCD_D4_PORT_IS_IO==1
sbi(LCD_D4_DDR_REG, LCD_D4_PIN );
#endif
#if LCD_D5_PORT_IS_IO==1
sbi(LCD_D5_DDR_REG, LCD_D5_PIN );
#endif
#if LCD_D6_PORT_IS_IO==1
sbi(LCD_D6_DDR_REG, LCD_D6_PIN );
#endif
#if LCD_D7_PORT_IS_IO==1
sbi(LCD_D7_DDR_REG, LCD_D7_PIN );
#endif
#if LCD_RS_PORT_IS_IO==1
sbi(LCD_RS_DDR_REG, LCD_RS_PIN );
#endif
 
#if LCD_READ_REQUIRED == 1 
#if  LCD_RW_PORT_IS_IO == 1
sbi(LCD_RW_DDR_REG, LCD_RW_PIN  );
#endif
cbi(LCD_RW_PORT, LCD_RW_PIN  ); 
#endif
 
#endif  /* #if LCD_MULTIPLEX_ENABLE == 0 */
 
#endif  /* #if LCD_IO_MODE == 6 */
    
/*------ Initialize lcd to 4 bit i/o mode -------*/
/* initial write to lcd is 8bit using delay since busy flag can't be checked here anyway */
 
    delay(LCD_POWER_ON_DELAY);                          /* Wait 20 milliseconds  */
     
    lcd_write(LCD_FUNCTION_8BIT_1LINE, INIT_MODE);
    delay(LCD_INIT_DELAY);                              /* Wait 5 milliseconds */
    
    lcd_write(LCD_FUNCTION_8BIT_1LINE, INIT_MODE);
    
    lcd_write(LCD_FUNCTION_8BIT_1LINE, INIT_MODE);
    
    lcd_write(LCD_FUNCTION_4BIT_1LINE, INIT_MODE);      /* set IO mode to 4bit */
             
    
    /* from now on the lcd accepts only 4 bit I/O, so we can use lcd_command() */    
 
    lcd_command(LCD_FUNCTION_DEFAULT);      /* function set: display lines  */
    lcd_command(LCD_DISP_OFF);              /* display off                  */
    lcd_clrscr();                           /* display clear                */ 
    lcd_command(LCD_MODE_DEFAULT);          /* set entry mode               */
    lcd_command(LCD_DISP_ON);               /* LCD DISPLAY ON (DEFAULT)     */
 
}/* lcd_init */
/*######################################################################################################*/
#elif LCD_IO_MODE == 7 
/*######################################################################################################*/
 
void lcd_init(void)
{
unsigned char lcd_unit=0;
/* initialize display and select type of cursor */
/* dispAttr: LCD_DISP_OFF, LCD_DISP_ON, LCD_DISP_ON_CURSOR, LCD_DISP_CURSOR_BLINK */
 
#if LCD_D4_PORT_IS_IO == 1
sbi(LCD_D4_DDR_REG, LCD_D4_PIN );
#endif
#if LCD_D5_PORT_IS_IO == 1
sbi(LCD_D5_DDR_REG, LCD_D5_PIN );
#endif
#if LCD_D6_PORT_IS_IO == 1
sbi(LCD_D6_DDR_REG, LCD_D6_PIN );
#endif
#if LCD_D7_PORT_IS_IO == 1
sbi(LCD_D7_DDR_REG, LCD_D7_PIN );
#endif
#if LCD_RS_PORT_IS_IO == 1
sbi(LCD_RS_DDR_REG, LCD_RS_PIN );
#endif
 
#if LCD_0_E_PORT_IS_IO == 1
sbi(LCD_0_E_DDR_REG, LCD_0_E_PIN  );                 
#endif        
sbi(LCD_0_E_PORT, LCD_0_E_PIN  ); 
 
#if LCD_1_E_PORT_IS_IO == 1
sbi(LCD_1_E_DDR_REG, LCD_1_E_PIN  );                 
#endif        
sbi(LCD_1_E_PORT, LCD_1_E_PIN  ); 
 
#if NUMBER_OF_LCD_UNITS >= 3
#if LCD_2_E_PORT_IS_IO == 1
sbi(LCD_2_E_DDR_REG, LCD_2_E_PIN  );                 
#endif        
sbi(LCD_2_E_PORT, LCD_2_E_PIN  );
#endif 
 
/*------ Initialize lcd to 4 bit i/o mode -------*/
/* initial write to lcd is 8bit using delay since busy flag can't be checked here anyway */
    xy_coordinates[LCD_0].x=0;
    xy_coordinates[LCD_0].y=0;
    xy_coordinates[LCD_1].x=0;
    xy_coordinates[LCD_1].y=0;
#if NUMBER_OF_LCD_UNITS >=3
    xy_coordinates[LCD_2].x=0;
    xy_coordinates[LCD_2].y=0;
#endif
 
 
for(lcd_unit=0; lcd_unit<NUMBER_OF_LCD_UNITS; lcd_unit++)
  {
      select_lcd(lcd_unit);
 
      delay(LCD_POWER_ON_DELAY);                          /* Wait 20 milliseconds  */
      lcd_write(LCD_FUNCTION_8BIT_1LINE, INIT_MODE);
      delay(LCD_INIT_DELAY);                              /* Wait 5 milliseconds */
      lcd_write(LCD_FUNCTION_8BIT_1LINE, INIT_MODE);
      lcd_write(LCD_FUNCTION_8BIT_1LINE, INIT_MODE);
      lcd_write(LCD_FUNCTION_4BIT_1LINE, INIT_MODE);      /* set IO mode to 4bit */
             
      /* from now on the lcd accepts only 4 bit I/O, so we can use lcd_command() */    
      /* function set: set how many lines the lcd unit has.  */
      if(lcd_lines==1) { lcd_command(LCD_FUNCTION_4BIT_1LINE);  }  
      else { lcd_command(LCD_FUNCTION_4BIT_2LINES); }
    
      lcd_command(LCD_DISP_OFF);                               /* display off                  */
      lcd_clrscr();                                            /* display clear                */ 
      lcd_command(LCD_MODE_DEFAULT);                           /* set entry mode               */
      lcd_command(LCD_DISP_ON);                                /* Display on                   */
 
  } 
select_lcd(0);
 
return;  
}/* lcd_init */
 
#endif
/*######################################################################################################*/
/*                                         T H E   E N D                                                */
/*######################################################################################################*/
 

Rev 359	Rev 409
1		1
2	`/****************************************************************************`	2	`/****************************************************************************`
3	`Title : C file for the HD44780U LCD library (lcd_io.c)`	3	`Title : C file for the HD44780U LCD library (lcd_io.c)`
4	`Author: Chris efstathiou hendrix@otenet.gr`	4	`Author: Chris efstathiou hendrix@otenet.gr`
5	`Date: 1/Jul/2002`	5	`Date: 1/Jul/2002`
6	`Software: AVR-GCC with AVR-AS`	6	`Software: AVR-GCC with AVR-AS`
7	`Target: any AVR device`	7	`Target: any AVR device`
8	`Comments: This software is FREE.`	8	`Comments: This software is FREE.`
9		9
10	`*****************************************************************************/`	10	`*****************************************************************************/`
11	`#ifndef _IO_REG_MACRO_MODE_`	11	`#ifndef _IO_REG_MACRO_MODE_`
12	`#define _IO_REG_MACRO_MODE_ 1 /* In case you have the new assignment mode io headers */`	12	`#define _IO_REG_MACRO_MODE_ 1 /* In case you have the new assignment mode io headers */`
13	`#endif`	13	`#endif`
14		14
15	`#ifndef _SFR_ASM_COMPAT`	15	`#ifndef _SFR_ASM_COMPAT`
16	`#define _SFR_ASM_COMPAT 1 /* This is for GCC 3.2 */`	16	`#define _SFR_ASM_COMPAT 1 /* This is for GCC 3.2 */`
17	`#endif`	17	`#endif`
18		18
19	`#include <io.h>`	19	`#include <io.h>`
20	`#include <progmem.h>`	20	`#include <progmem.h>`
21	`#include <eeprom.h>`	21	`#include <eeprom.h>`
22	`#include "lcd_io.h"`	22	`#include "lcd_io.h"`
23		23
24	`/* constants/macros */`	24	`/* constants/macros */`
25	`#ifndef CONCAT1`	25	`#ifndef CONCAT1`
26	`#define CONCAT1(a, b) CONCAT2(a, b)`	26	`#define CONCAT1(a, b) CONCAT2(a, b)`
27	`#endif`	27	`#endif`
28		28
29	`#ifndef CONCAT2`	29	`#ifndef CONCAT2`
30	`#define CONCAT2(a, b) a ## b`	30	`#define CONCAT2(a, b) a ## b`
31	`#endif`	31	`#endif`
32		32
33	`#define LCD_POWER_ON_DELAY ( (20000(F_CPU/60000))/100 ) / 20 milliseconds */`	33	`#define LCD_POWER_ON_DELAY ( (20000(F_CPU/60000))/100 ) / 20 milliseconds */`
34	`#define LCD_INIT_DELAY ( (5000(F_CPU/60000))/100 ) / 5 milliseconds */`	34	`#define LCD_INIT_DELAY ( (5000(F_CPU/60000))/100 ) / 5 milliseconds */`
35		35
36	`#define INIT_MODE 2`	36	`#define INIT_MODE 2`
37	`#define DATA_MODE 1`	37	`#define DATA_MODE 1`
38	`#define CMD_MODE 0`	38	`#define CMD_MODE 0`
39		39
40		40
41	`/* CONVERSION OF LCD_DELAY_TIME TO TRUE MICROSECONDS */`	41	`/* CONVERSION OF LCD_DELAY_TIME TO TRUE MICROSECONDS */`
42	`#if LCD_READ_REQUIRED == 0 \|\| LCD_IO_MODE == 2 \|\| LCD_IO_MODE == 7`	42	`#if LCD_READ_REQUIRED == 0 \|\| LCD_IO_MODE == 2 \|\| LCD_IO_MODE == 7`
43	`#define LCD_DELAY_SHORT ( (LCD_DELAY_TIME*(F_CPU/60000))/100 )`	43	`#define LCD_DELAY_SHORT ( (LCD_DELAY_TIME*(F_CPU/60000))/100 )`
44	`#define LCD_DELAY_LONG ( LCD_DELAY_SHORT*40 )`	44	`#define LCD_DELAY_LONG ( LCD_DELAY_SHORT*40 )`
45	`#endif`	45	`#endif`
46		46
47		47
48		48
49	`/######################################################################################################/`	49	`/######################################################################################################/`
50	`#if LCD_IO_MODE == 2`	50	`#if LCD_IO_MODE == 2`
51	`/######################################################################################################/`	51	`/######################################################################################################/`
52		52
53	`#define LCD_DATA_PORT_IS_IO 1`	53	`#define LCD_DATA_PORT_IS_IO 1`
54	`#define LCD_CLOCK_PORT_IS_IO 1`	54	`#define LCD_CLOCK_PORT_IS_IO 1`
55		55
56	`#define LCD_DATA_PORT CONCAT1(PORT,LCD_DATA_SIGNAL_PORT)`	56	`#define LCD_DATA_PORT CONCAT1(PORT,LCD_DATA_SIGNAL_PORT)`
57	`#define LCD_DATA_DDR_REG CONCAT1(DDR,LCD_DATA_SIGNAL_PORT)`	57	`#define LCD_DATA_DDR_REG CONCAT1(DDR,LCD_DATA_SIGNAL_PORT)`
58		58
59	`#define LCD_CLOCK_PORT CONCAT1(PORT,LCD_CLOCK_SIGNAL_PORT)`	59	`#define LCD_CLOCK_PORT CONCAT1(PORT,LCD_CLOCK_SIGNAL_PORT)`
60	`#define LCD_CLOCK_DDR_REG CONCAT1(DDR,LCD_CLOCK_SIGNAL_PORT)`	60	`#define LCD_CLOCK_DDR_REG CONCAT1(DDR,LCD_CLOCK_SIGNAL_PORT)`
61		61
62	`#define LCD_READ_REQUIRED 0`	62	`#define LCD_READ_REQUIRED 0`
63		63
64		64
65		65
66	`#if defined(__AVR_ATmega103__)`	66	`#if defined(__AVR_ATmega103__)`
67		67
68	`#if LCD_DATA_PORT == PORTC`	68	`#if LCD_DATA_PORT == PORTC`
69	`#undef LCD_DATA_PORT_IS_IO`	69	`#undef LCD_DATA_PORT_IS_IO`
70	`#undef LCD_DATA_DDR_REG`	70	`#undef LCD_DATA_DDR_REG`
71	`#define LCD_DATA_PORT_IS_IO 0`	71	`#define LCD_DATA_PORT_IS_IO 0`
72	`#endif`	72	`#endif`
73		73
74	`#if LCD_CLOCK_PORT == PORTC`	74	`#if LCD_CLOCK_PORT == PORTC`
75	`#undef LCD_CLOCK_PORT_IS_IO`	75	`#undef LCD_CLOCK_PORT_IS_IO`
76	`#undef LCD_CLOCK_DDR_REG`	76	`#undef LCD_CLOCK_DDR_REG`
77	`#define LCD_CLOCK_PORT_IS_IO 0`	77	`#define LCD_CLOCK_PORT_IS_IO 0`
78	`#endif`	78	`#endif`
79	`#endif /* #if defined(__AVR_ATmega103__) */`	79	`#endif /* #if defined(__AVR_ATmega103__) */`
80		80
81	`/######################################################################################################/`	81	`/######################################################################################################/`
82	`#elif LCD_IO_MODE == 6`	82	`#elif LCD_IO_MODE == 6`
83	`/######################################################################################################/`	83	`/######################################################################################################/`
84	`#define lcd_toggle_e() ({ cbi(LCD_E_PORT, LCD_E_PIN); delay(F_CPU/6000000); \`	84	`#define lcd_toggle_e() ({ cbi(LCD_E_PORT, LCD_E_PIN); delay(F_CPU/6000000); \`
85	`sbi(LCD_E_PORT, LCD_E_PIN); })`	85	`sbi(LCD_E_PORT, LCD_E_PIN); })`
86		86
87	`#if LCD_READ_REQUIRED == 1`	87	`#if LCD_READ_REQUIRED == 1`
88	`#undef LCD_MULTIPLEX_REQUIRED`	88	`#undef LCD_MULTIPLEX_REQUIRED`
89	`#define LCD_MULTIPLEX_REQUIRED 0`	89	`#define LCD_MULTIPLEX_REQUIRED 0`
90	`#define BUSY_FLAG 0`	90	`#define BUSY_FLAG 0`
91	`#define DATA 1`	91	`#define DATA 1`
92	`#endif`	92	`#endif`
93		93
94	`#if LCD_LINES == 1 \|\| LCD_LINES == 2 \|\| LCD_LINES == 4`	94	`#if LCD_LINES == 1 \|\| LCD_LINES == 2 \|\| LCD_LINES == 4`
95	`#else`	95	`#else`
96	`#error THE LCD LINES MUST BE 1 OR 2 OR 4 !`	96	`#error THE LCD LINES MUST BE 1 OR 2 OR 4 !`
97	`#endif`	97	`#endif`
98		98
99	`#define LCD_D4_PORT_IS_IO 1`	99	`#define LCD_D4_PORT_IS_IO 1`
100	`#define LCD_D5_PORT_IS_IO 1`	100	`#define LCD_D5_PORT_IS_IO 1`
101	`#define LCD_D6_PORT_IS_IO 1`	101	`#define LCD_D6_PORT_IS_IO 1`
102	`#define LCD_D7_PORT_IS_IO 1`	102	`#define LCD_D7_PORT_IS_IO 1`
103	`#define LCD_RS_PORT_IS_IO 1`	103	`#define LCD_RS_PORT_IS_IO 1`
104	`#define LCD_RW_PORT_IS_IO 1`	104	`#define LCD_RW_PORT_IS_IO 1`
105	`#define LCD_E_PORT_IS_IO 1`	105	`#define LCD_E_PORT_IS_IO 1`
106		106
107	`#define LCD_D4_PORT CONCAT1(PORT, LCD_DATA4_PORT)`	107	`#define LCD_D4_PORT CONCAT1(PORT, LCD_DATA4_PORT)`
108	`#define LCD_D5_PORT CONCAT1(PORT, LCD_DATA5_PORT)`	108	`#define LCD_D5_PORT CONCAT1(PORT, LCD_DATA5_PORT)`
109	`#define LCD_D6_PORT CONCAT1(PORT, LCD_DATA6_PORT)`	109	`#define LCD_D6_PORT CONCAT1(PORT, LCD_DATA6_PORT)`
110	`#define LCD_D7_PORT CONCAT1(PORT, LCD_DATA7_PORT)`	110	`#define LCD_D7_PORT CONCAT1(PORT, LCD_DATA7_PORT)`
111	`#define LCD_RS_PORT CONCAT1(PORT, LCD_RS_SIGNAL_PORT)`	111	`#define LCD_RS_PORT CONCAT1(PORT, LCD_RS_SIGNAL_PORT)`
112	`#define LCD_RW_PORT CONCAT1(PORT, LCD_RW_SIGNAL_PORT)`	112	`#define LCD_RW_PORT CONCAT1(PORT, LCD_RW_SIGNAL_PORT)`
113	`#define LCD_E_PORT CONCAT1(PORT, LCD_E_SIGNAL_PORT)`	113	`#define LCD_E_PORT CONCAT1(PORT, LCD_E_SIGNAL_PORT)`
114		114
115	`#define LCD_D4_DDR_REG CONCAT1(DDR, LCD_DATA4_PORT)`	115	`#define LCD_D4_DDR_REG CONCAT1(DDR, LCD_DATA4_PORT)`
116	`#define LCD_D5_DDR_REG CONCAT1(DDR, LCD_DATA5_PORT)`	116	`#define LCD_D5_DDR_REG CONCAT1(DDR, LCD_DATA5_PORT)`
117	`#define LCD_D6_DDR_REG CONCAT1(DDR, LCD_DATA6_PORT)`	117	`#define LCD_D6_DDR_REG CONCAT1(DDR, LCD_DATA6_PORT)`
118	`#define LCD_D7_DDR_REG CONCAT1(DDR, LCD_DATA7_PORT)`	118	`#define LCD_D7_DDR_REG CONCAT1(DDR, LCD_DATA7_PORT)`
119	`#define LCD_RS_DDR_REG CONCAT1(DDR, LCD_RS_SIGNAL_PORT)`	119	`#define LCD_RS_DDR_REG CONCAT1(DDR, LCD_RS_SIGNAL_PORT)`
120	`#define LCD_RW_DDR_REG CONCAT1(DDR, LCD_RW_SIGNAL_PORT)`	120	`#define LCD_RW_DDR_REG CONCAT1(DDR, LCD_RW_SIGNAL_PORT)`
121	`#define LCD_E_DDR_REG CONCAT1(DDR, LCD_E_SIGNAL_PORT)`	121	`#define LCD_E_DDR_REG CONCAT1(DDR, LCD_E_SIGNAL_PORT)`
122		122
123		123
124		124
125	`#if LCD_READ_REQUIRED == 1`	125	`#if LCD_READ_REQUIRED == 1`
126		126
127	`#define LCD_D4_PIN_REG CONCAT1(PIN, LCD_DATA4_PORT)`	127	`#define LCD_D4_PIN_REG CONCAT1(PIN, LCD_DATA4_PORT)`
128	`#define LCD_D5_PIN_REG CONCAT1(PIN, LCD_DATA5_PORT)`	128	`#define LCD_D5_PIN_REG CONCAT1(PIN, LCD_DATA5_PORT)`
129	`#define LCD_D6_PIN_REG CONCAT1(PIN, LCD_DATA6_PORT)`	129	`#define LCD_D6_PIN_REG CONCAT1(PIN, LCD_DATA6_PORT)`
130	`#define LCD_D7_PIN_REG CONCAT1(PIN, LCD_DATA7_PORT)`	130	`#define LCD_D7_PIN_REG CONCAT1(PIN, LCD_DATA7_PORT)`
131		131
132	`#elif LCD_READ_REQUIRED == 0`	132	`#elif LCD_READ_REQUIRED == 0`
133		133
134	`#undef LCD_RW_PORT`	134	`#undef LCD_RW_PORT`
135	`#undef LCD_RW_DDR_REG`	135	`#undef LCD_RW_DDR_REG`
136	`#undef LCD_RW_PORT_IS_IO`	136	`#undef LCD_RW_PORT_IS_IO`
137		137
138	`#endif`	138	`#endif`
139		139
140		140
141		141
142	`#if defined(__AVR_ATmega103__)`	142	`#if defined(__AVR_ATmega103__)`
143		143
144	`#if LCD_D4_PORT == PORTC`	144	`#if LCD_D4_PORT == PORTC`
145	`#if LCD_READ_REQUIRED == 1`	145	`#if LCD_READ_REQUIRED == 1`
146	`#error THE PORT FOR LCD_D4 IS OUTPUT ONLY!`	146	`#error THE PORT FOR LCD_D4 IS OUTPUT ONLY!`
147	`#endif`	147	`#endif`
148	`#undef LCD_D4_PORT_IS_IO`	148	`#undef LCD_D4_PORT_IS_IO`
149	`#undef LCD_D4_DDR_REG`	149	`#undef LCD_D4_DDR_REG`
150	`#define LCD_D4_PORT_IS_IO 0`	150	`#define LCD_D4_PORT_IS_IO 0`
151	`#endif`	151	`#endif`
152		152
153	`#if LCD_D5_PORT == PORTC`	153	`#if LCD_D5_PORT == PORTC`
154	`#if LCD_READ_REQUIRED == 1`	154	`#if LCD_READ_REQUIRED == 1`
155	`#error THE PORT FOR LCD_D5 IS OUTPUT ONLY!`	155	`#error THE PORT FOR LCD_D5 IS OUTPUT ONLY!`
156	`#endif`	156	`#endif`
157	`#undef LCD_D5_PORT_IS_IO`	157	`#undef LCD_D5_PORT_IS_IO`
158	`#undef LCD_D5_DDR_REG`	158	`#undef LCD_D5_DDR_REG`
159	`#define LCD_D5_PORT_IS_IO 0`	159	`#define LCD_D5_PORT_IS_IO 0`
160	`#endif`	160	`#endif`
161		161
162	`#if LCD_D6_PORT == PORTC`	162	`#if LCD_D6_PORT == PORTC`
163	`#if LCD_READ_REQUIRED == 1`	163	`#if LCD_READ_REQUIRED == 1`
164	`#error THE PORT FOR LCD_D6 IS OUTPUT ONLY!`	164	`#error THE PORT FOR LCD_D6 IS OUTPUT ONLY!`
165	`#endif`	165	`#endif`
166	`#undef LCD_D6_PORT_IS_IO`	166	`#undef LCD_D6_PORT_IS_IO`
167	`#undef LCD_D6_DDR_REG`	167	`#undef LCD_D6_DDR_REG`
168	`#define LCD_D6_PORT_IS_IO 0`	168	`#define LCD_D6_PORT_IS_IO 0`
169	`#endif`	169	`#endif`
170		170
171	`#if LCD_D7_PORT == PORTC`	171	`#if LCD_D7_PORT == PORTC`
172	`#if LCD_READ_REQUIRED == 1`	172	`#if LCD_READ_REQUIRED == 1`
173	`#error THE PORT FOR LCD_D7 IS OUTPUT ONLY!`	173	`#error THE PORT FOR LCD_D7 IS OUTPUT ONLY!`
174	`#endif`	174	`#endif`
175	`#undef LCD_D7_PORT_IS_IO`	175	`#undef LCD_D7_PORT_IS_IO`
176	`#undef LCD_D7_DDR_REG`	176	`#undef LCD_D7_DDR_REG`
177	`#define LCD_D7_PORT_IS_IO 0`	177	`#define LCD_D7_PORT_IS_IO 0`
178	`#endif`	178	`#endif`
179		179
180	`#if LCD_RS_PORT == PORTC`	180	`#if LCD_RS_PORT == PORTC`
181	`#undef LCD_RS_PORT_IS_IO`	181	`#undef LCD_RS_PORT_IS_IO`
182	`#undef LCD_RS_DDR_REG`	182	`#undef LCD_RS_DDR_REG`
183	`#define LCD_RS_PORT_IS_IO 0`	183	`#define LCD_RS_PORT_IS_IO 0`
184	`#endif`	184	`#endif`
185		185
186	`#if LCD_READ_REQUIRED == 1`	186	`#if LCD_READ_REQUIRED == 1`
187	`#if LCD_RW_PORT == PORTC`	187	`#if LCD_RW_PORT == PORTC`
188	`#undef LCD_RW_PORT_IS_IO`	188	`#undef LCD_RW_PORT_IS_IO`
189	`#undef LCD_RW_DDR_REG`	189	`#undef LCD_RW_DDR_REG`
190	`#define LCD_RW_PORT_IS_IO 0`	190	`#define LCD_RW_PORT_IS_IO 0`
191	`#endif`	191	`#endif`
192	`#endif`	192	`#endif`
193		193
194	`#if LCD_E_PORT == PORTC`	194	`#if LCD_E_PORT == PORTC`
195	`#undef LCD_E_PORT_IS_IO`	195	`#undef LCD_E_PORT_IS_IO`
196	`#undef LCD_E_DDR_REG`	196	`#undef LCD_E_DDR_REG`
197	`#define LCD_E_PORT_IS_IO 0`	197	`#define LCD_E_PORT_IS_IO 0`
198	`#endif`	198	`#endif`
199		199
200	`#endif /* #if defined(__AVR_ATmega103__) */`	200	`#endif /* #if defined(__AVR_ATmega103__) */`
201		201
202	`/######################################################################################################/`	202	`/######################################################################################################/`
203	`#elif LCD_IO_MODE == 7`	203	`#elif LCD_IO_MODE == 7`
204	`/######################################################################################################/`	204	`/######################################################################################################/`
205		205
206	`#define lcd_toggle_e() ({ cbivar(lcd_E_port, lcd_E_pin); delay(F_CPU/6000000); \`	206	`#define lcd_toggle_e() ({ cbivar(lcd_E_port, lcd_E_pin); delay(F_CPU/6000000); \`
207	`sbivar(lcd_E_port, lcd_E_pin); })`	207	`sbivar(lcd_E_port, lcd_E_pin); })`
208	`#if SREG > 0X3F`	208	`#if SREG > 0X3F`
209	`#define IO_TO_MEM_OFFSET 0`	209	`#define IO_TO_MEM_OFFSET 0`
210	`#else`	210	`#else`
211	`#define IO_TO_MEM_OFFSET 0X20`	211	`#define IO_TO_MEM_OFFSET 0X20`
212	`#endif`	212	`#endif`
213		213
214	`#define LCD_READ_REQUIRED 0`	214	`#define LCD_READ_REQUIRED 0`
215		215
216	`#if LCD_0_LINES == 1 \|\| LCD_0_LINES == 2 \|\| LCD_0_LINES == 4`	216	`#if LCD_0_LINES == 1 \|\| LCD_0_LINES == 2 \|\| LCD_0_LINES == 4`
217	`#else`	217	`#else`
218	`#error THE LCD LINES MUST BE 1 OR 2 OR 4 !`	218	`#error THE LCD LINES MUST BE 1 OR 2 OR 4 !`
219	`#endif`	219	`#endif`
220		220
221	`#if LCD_1_LINES == 1 \|\| LCD_1_LINES == 2 \|\| LCD_1_LINES == 4`	221	`#if LCD_1_LINES == 1 \|\| LCD_1_LINES == 2 \|\| LCD_1_LINES == 4`
222	`#else`	222	`#else`
223	`#error THE LCD LINES MUST BE 1 OR 2 OR 4 !`	223	`#error THE LCD LINES MUST BE 1 OR 2 OR 4 !`
224	`#endif`	224	`#endif`
225		225
226	`#if NUMBER_OF_LCD_UNITS >= 3`	226	`#if NUMBER_OF_LCD_UNITS >= 3`
227	`#if LCD_2_LINES == 1 \|\| LCD_2_LINES == 2 \|\| LCD_2_LINES == 4`	227	`#if LCD_2_LINES == 1 \|\| LCD_2_LINES == 2 \|\| LCD_2_LINES == 4`
228	`#else`	228	`#else`
229	`#error THE LCD LINES MUST BE 1 OR 2 OR 4 !`	229	`#error THE LCD LINES MUST BE 1 OR 2 OR 4 !`
230	`#endif`	230	`#endif`
231	`#endif`	231	`#endif`
232		232
233	`#define LCD_D4_PORT_IS_IO 1`	233	`#define LCD_D4_PORT_IS_IO 1`
234	`#define LCD_D5_PORT_IS_IO 1`	234	`#define LCD_D5_PORT_IS_IO 1`
235	`#define LCD_D6_PORT_IS_IO 1`	235	`#define LCD_D6_PORT_IS_IO 1`
236	`#define LCD_D7_PORT_IS_IO 1`	236	`#define LCD_D7_PORT_IS_IO 1`
237	`#define LCD_RS_PORT_IS_IO 1`	237	`#define LCD_RS_PORT_IS_IO 1`
238	`#define LCD_0_E_PORT_IS_IO 1`	238	`#define LCD_0_E_PORT_IS_IO 1`
239	`#define LCD_1_E_PORT_IS_IO 1`	239	`#define LCD_1_E_PORT_IS_IO 1`
240		240
241	`#if NUMBER_OF_LCD_UNITS >=3`	241	`#if NUMBER_OF_LCD_UNITS >=3`
242	`#define LCD_2_E_PORT_IS_IO 1`	242	`#define LCD_2_E_PORT_IS_IO 1`
243	`#endif`	243	`#endif`
244		244
245	`#define LCD_D4_PORT CONCAT1(PORT, LCD_DATA4_PORT)`	245	`#define LCD_D4_PORT CONCAT1(PORT, LCD_DATA4_PORT)`
246	`#define LCD_D5_PORT CONCAT1(PORT, LCD_DATA5_PORT)`	246	`#define LCD_D5_PORT CONCAT1(PORT, LCD_DATA5_PORT)`
247	`#define LCD_D6_PORT CONCAT1(PORT, LCD_DATA6_PORT)`	247	`#define LCD_D6_PORT CONCAT1(PORT, LCD_DATA6_PORT)`
248	`#define LCD_D7_PORT CONCAT1(PORT, LCD_DATA7_PORT)`	248	`#define LCD_D7_PORT CONCAT1(PORT, LCD_DATA7_PORT)`
249	`#define LCD_RS_PORT CONCAT1(PORT, LCD_RS_SIGNAL_PORT)`	249	`#define LCD_RS_PORT CONCAT1(PORT, LCD_RS_SIGNAL_PORT)`
250	`#define LCD_0_E_PORT CONCAT1(PORT, LCD_0_E_SIGNAL_PORT)`	250	`#define LCD_0_E_PORT CONCAT1(PORT, LCD_0_E_SIGNAL_PORT)`
251	`#define LCD_1_E_PORT CONCAT1(PORT, LCD_1_E_SIGNAL_PORT)`	251	`#define LCD_1_E_PORT CONCAT1(PORT, LCD_1_E_SIGNAL_PORT)`
252		252
253	`#if NUMBER_OF_LCD_UNITS >=3`	253	`#if NUMBER_OF_LCD_UNITS >=3`
254	`#define LCD_2_E_PORT CONCAT1(PORT, LCD_2_E_SIGNAL_PORT)`	254	`#define LCD_2_E_PORT CONCAT1(PORT, LCD_2_E_SIGNAL_PORT)`
255	`#endif`	255	`#endif`
256		256
257	`#define LCD_D4_DDR_REG CONCAT1(DDR, LCD_DATA4_PORT)`	257	`#define LCD_D4_DDR_REG CONCAT1(DDR, LCD_DATA4_PORT)`
258	`#define LCD_D5_DDR_REG CONCAT1(DDR, LCD_DATA5_PORT)`	258	`#define LCD_D5_DDR_REG CONCAT1(DDR, LCD_DATA5_PORT)`
259	`#define LCD_D6_DDR_REG CONCAT1(DDR, LCD_DATA6_PORT)`	259	`#define LCD_D6_DDR_REG CONCAT1(DDR, LCD_DATA6_PORT)`
260	`#define LCD_D7_DDR_REG CONCAT1(DDR, LCD_DATA7_PORT)`	260	`#define LCD_D7_DDR_REG CONCAT1(DDR, LCD_DATA7_PORT)`
261	`#define LCD_RS_DDR_REG CONCAT1(DDR, LCD_RS_SIGNAL_PORT)`	261	`#define LCD_RS_DDR_REG CONCAT1(DDR, LCD_RS_SIGNAL_PORT)`
262	`#define LCD_0_E_DDR_REG CONCAT1(DDR, LCD_0_E_SIGNAL_PORT)`	262	`#define LCD_0_E_DDR_REG CONCAT1(DDR, LCD_0_E_SIGNAL_PORT)`
263	`#define LCD_1_E_DDR_REG CONCAT1(DDR, LCD_1_E_SIGNAL_PORT)`	263	`#define LCD_1_E_DDR_REG CONCAT1(DDR, LCD_1_E_SIGNAL_PORT)`
264		264
265	`#if NUMBER_OF_LCD_UNITS >=3`	265	`#if NUMBER_OF_LCD_UNITS >=3`
266	`#define LCD_2_E_DDR_REG CONCAT1(DDR, LCD_2_E_SIGNAL_PORT)`	266	`#define LCD_2_E_DDR_REG CONCAT1(DDR, LCD_2_E_SIGNAL_PORT)`
267	`#endif`	267	`#endif`
268		268
269		269
270	`#if defined(__AVR_ATmega103__)`	270	`#if defined(__AVR_ATmega103__)`
271		271
272	`#if LCD_D4_PORT == PORTC`	272	`#if LCD_D4_PORT == PORTC`
273	`#undef LCD_D4_PORT_IS_IO`	273	`#undef LCD_D4_PORT_IS_IO`
274	`#undef LCD_D4_DDR_REG`	274	`#undef LCD_D4_DDR_REG`
275	`#define LCD_D4_PORT_IS_IO 0`	275	`#define LCD_D4_PORT_IS_IO 0`
276	`#endif`	276	`#endif`
277		277
278	`#if LCD_D5_PORT == PORTC`	278	`#if LCD_D5_PORT == PORTC`
279	`#undef LCD_D5_PORT_IS_IO`	279	`#undef LCD_D5_PORT_IS_IO`
280	`#undef LCD_D5_DDR_REG`	280	`#undef LCD_D5_DDR_REG`
281	`#define LCD_D5_PORT_IS_IO 0`	281	`#define LCD_D5_PORT_IS_IO 0`
282	`#endif`	282	`#endif`
283		283
284	`#if LCD_D6_PORT == PORTC`	284	`#if LCD_D6_PORT == PORTC`
285	`#undef LCD_D6_PORT_IS_IO`	285	`#undef LCD_D6_PORT_IS_IO`
286	`#undef LCD_D6_DDR_REG`	286	`#undef LCD_D6_DDR_REG`
287	`#define LCD_D6_PORT_IS_IO 0`	287	`#define LCD_D6_PORT_IS_IO 0`
288	`#endif`	288	`#endif`
289		289
290	`#if LCD_D7_PORT == PORTC`	290	`#if LCD_D7_PORT == PORTC`
291	`#undef LCD_D7_PORT_IS_IO`	291	`#undef LCD_D7_PORT_IS_IO`
292	`#undef LCD_D7_DDR_REG`	292	`#undef LCD_D7_DDR_REG`
293	`#define LCD_D7_PORT_IS_IO 0`	293	`#define LCD_D7_PORT_IS_IO 0`
294	`#endif`	294	`#endif`
295		295
296	`#if LCD_RS_PORT == PORTC`	296	`#if LCD_RS_PORT == PORTC`
297	`#undef LCD_RS_PORT_IS_IO`	297	`#undef LCD_RS_PORT_IS_IO`
298	`#undef LCD_RS_DDR_REG`	298	`#undef LCD_RS_DDR_REG`
299	`#define LCD_RS_PORT_IS_IO 0`	299	`#define LCD_RS_PORT_IS_IO 0`
300	`#endif`	300	`#endif`
301		301
302	`#if LCD_0_E_PORT == PORTC`	302	`#if LCD_0_E_PORT == PORTC`
303	`#undef LCD_0_E_PORT_IS_IO`	303	`#undef LCD_0_E_PORT_IS_IO`
304	`#undef LCD_0_E_DDR_REG`	304	`#undef LCD_0_E_DDR_REG`
305	`#define LCD_0_E_PORT_IS_IO 0`	305	`#define LCD_0_E_PORT_IS_IO 0`
306	`#endif`	306	`#endif`
307		307
308	`#if LCD_1_E_PORT == PORTC`	308	`#if LCD_1_E_PORT == PORTC`
309	`#undef LCD_1_E_PORT_IS_IO`	309	`#undef LCD_1_E_PORT_IS_IO`
310	`#undef LCD_1_E_DDR_REG`	310	`#undef LCD_1_E_DDR_REG`
311	`#define LCD_1_E_PORT_IS_IO 0`	311	`#define LCD_1_E_PORT_IS_IO 0`
312	`#endif`	312	`#endif`
313		313
314	`#if NUMBER_OF_LCD_UNITS >=3`	314	`#if NUMBER_OF_LCD_UNITS >=3`
315	`#if LCD_2_E_PORT == PORTC`	315	`#if LCD_2_E_PORT == PORTC`
316	`#undef LCD_2_E_PORT_IS_IO`	316	`#undef LCD_2_E_PORT_IS_IO`
317	`#undef LCD_2_E_DDR_REG`	317	`#undef LCD_2_E_DDR_REG`
318	`#define LCD_2_E_PORT_IS_IO 0`	318	`#define LCD_2_E_PORT_IS_IO 0`
319	`#endif`	319	`#endif`
320	`#endif /* #if NUMBER_OF_LCD_UNITS >=3 */`	320	`#endif /* #if NUMBER_OF_LCD_UNITS >=3 */`
321		321
322	`#endif /* #if defined(__AVR_ATmega103__) */`	322	`#endif /* #if defined(__AVR_ATmega103__) */`
323		323
324	`#endif /* #elif LCD_IO_MODE == 7 */`	324	`#endif /* #elif LCD_IO_MODE == 7 */`
325	`/######################################################################################################/`	325	`/######################################################################################################/`
326		326
327	`/* type definitions */`	327	`/* type definitions */`
328		328
329	`typedef unsigned char u08;`	329	`typedef unsigned char u08;`
330	`typedef unsigned short u16;`	330	`typedef unsigned short u16;`
331		331
332	`/######################################################################################################/`	332	`/######################################################################################################/`
333	`/* FUNCTION PROTOTYPES */`	333	`/* FUNCTION PROTOTYPES */`
334	`/######################################################################################################/`	334	`/######################################################################################################/`
335		335
336	`#if LCD_IO_MODE == 7`	336	`#if LCD_IO_MODE == 7`
337	`static void sbivar(unsigned char port, unsigned char bit);`	337	`static void sbivar(unsigned char port, unsigned char bit);`
338	`static void cbivar(unsigned char port, unsigned char bit);`	338	`static void cbivar(unsigned char port, unsigned char bit);`
339	`#endif`	339	`#endif`
340		340
341	`#if LCD_READ_REQUIRED == 1`	341	`#if LCD_READ_REQUIRED == 1`
342	`static unsigned char lcd_read(unsigned char rs);`	342	`static unsigned char lcd_read(unsigned char rs);`
343	`static inline unsigned char lcd_waitbusy(void);`	343	`static inline unsigned char lcd_waitbusy(void);`
344	`#endif`	344	`#endif`
345		345
346	`static void delay(unsigned long int us);`	346	`static void delay(unsigned long int us);`
347		347
348	`/######################################################################################################/`	348	`/######################################################################################################/`
349	`/* GLOBAL variables */`	349	`/* GLOBAL variables */`
350	`/######################################################################################################/`	350	`/######################################################################################################/`
351		351
352	`static unsigned char x,y, putc_lock=0;`	352	`static unsigned char x,y, putc_lock=0;`
353	`#if LCD_IO_MODE == 7`	353	`#if LCD_IO_MODE == 7`
354	`static unsigned char lcd_E_port=0, lcd_E_pin=0, lcd_chars_per_line=0, lcd_lines=0, current_lcd_unit=0;`	354	`static unsigned char lcd_E_port=0, lcd_E_pin=0, lcd_chars_per_line=0, lcd_lines=0, current_lcd_unit=0;`
355	`static struct xy {`	355	`static struct xy {`
356	`unsigned char x;`	356	`unsigned char x;`
357	`unsigned char y;`	357	`unsigned char y;`
358	`} xy_coordinates[NUMBER_OF_LCD_UNITS];`	358	`} xy_coordinates[NUMBER_OF_LCD_UNITS];`
359		359
360	`#endif`	360	`#endif`
361		361
362	`/######################################################################################################/`	362	`/######################################################################################################/`
363	`/* local functions */`	363	`/* local functions */`
364	`/######################################################################################################/`	364	`/######################################################################################################/`
365		365
366	`static void delay(unsigned long int us)`	366	`static void delay(unsigned long int us)`
367	`/* delay for a minimum of <us> microseconds (with a 6 Mhz crystal, the resolution is 1 us) */`	367	`/* delay for a minimum of <us> microseconds (with a 6 Mhz crystal, the resolution is 1 us) */`
368	`{`	368	`{`
369	`while ( us ) { us--; } /* 6 cpu cycles per loop */`	369	`while ( us ) { us--; } /* 6 cpu cycles per loop */`
370	`}`	370	`}`
371		371
372	`/######################################################################################################/`	372	`/######################################################################################################/`
373	`#if LCD_IO_MODE == 7 /* lcd_write() function for 6 bit i/o one lcd unit */`	373	`#if LCD_IO_MODE == 7 /* lcd_write() function for 6 bit i/o one lcd unit */`
374	`/######################################################################################################/`	374	`/######################################################################################################/`
375		375
376		376
377	`static void sbivar(unsigned char port, unsigned char bit)`	377	`static void sbivar(unsigned char port, unsigned char bit)`
378	`{`	378	`{`
379	`register unsigned char temp=0;`	379	`register unsigned char temp=0;`
380		380
381	`temp=((unsigned char)(port+IO_TO_MEM_OFFSET));`	381	`temp=((unsigned char)(port+IO_TO_MEM_OFFSET));`
382	`temp\|= (1<<bit);`	382	`temp\|= (1<<bit);`
383	`((unsigned char)(port+IO_TO_MEM_OFFSET))=temp;`	383	`((unsigned char)(port+IO_TO_MEM_OFFSET))=temp;`
384		384
385	`return;`	385	`return;`
386	`}`	386	`}`
387	`/######################################################################################################/`	387	`/######################################################################################################/`
388		388
389	`static void cbivar(unsigned char port, unsigned char bit)`	389	`static void cbivar(unsigned char port, unsigned char bit)`
390	`{`	390	`{`
391	`register unsigned char temp=0;`	391	`register unsigned char temp=0;`
392		392
393	`temp=((unsigned char)(port+IO_TO_MEM_OFFSET));`	393	`temp=((unsigned char)(port+IO_TO_MEM_OFFSET));`
394	`temp &= ~(1<<bit);`	394	`temp &= ~(1<<bit);`
395	`((unsigned char)(port+IO_TO_MEM_OFFSET))=temp;`	395	`((unsigned char)(port+IO_TO_MEM_OFFSET))=temp;`
396		396
397	`return;`	397	`return;`
398	`}`	398	`}`
399	`/######################################################################################################/`	399	`/######################################################################################################/`
400		400
401	`static void lcd_write(unsigned char data, unsigned char mode)`	401	`static void lcd_write(unsigned char data, unsigned char mode)`
402	`{`	402	`{`
403	`register unsigned char rs=0;`	403	`register unsigned char rs=0;`
404		404
405		405
406	`if(mode==DATA_MODE) rs=1; else rs=0; /* set the rs value */`	406	`if(mode==DATA_MODE) rs=1; else rs=0; /* set the rs value */`
407	`/* output high nibble first */`	407	`/* output high nibble first */`
408	`if(data&0x10) sbi(LCD_D4_PORT, LCD_D4_PIN); else cbi(LCD_D4_PORT, LCD_D4_PIN);`	408	`if(data&0x10) sbi(LCD_D4_PORT, LCD_D4_PIN); else cbi(LCD_D4_PORT, LCD_D4_PIN);`
409	`if(data&0x20) sbi(LCD_D5_PORT, LCD_D5_PIN); else cbi(LCD_D5_PORT, LCD_D5_PIN);`	409	`if(data&0x20) sbi(LCD_D5_PORT, LCD_D5_PIN); else cbi(LCD_D5_PORT, LCD_D5_PIN);`
410	`if(data&0x40) sbi(LCD_D6_PORT, LCD_D6_PIN); else cbi(LCD_D6_PORT, LCD_D6_PIN);`	410	`if(data&0x40) sbi(LCD_D6_PORT, LCD_D6_PIN); else cbi(LCD_D6_PORT, LCD_D6_PIN);`
411	`if(data&0x80) sbi(LCD_D7_PORT, LCD_D7_PIN); else cbi(LCD_D7_PORT, LCD_D7_PIN);`	411	`if(data&0x80) sbi(LCD_D7_PORT, LCD_D7_PIN); else cbi(LCD_D7_PORT, LCD_D7_PIN);`
412	`if(rs) sbi(LCD_RS_PORT, LCD_RS_PIN); else cbi(LCD_RS_PORT, LCD_RS_PIN);`	412	`if(rs) sbi(LCD_RS_PORT, LCD_RS_PIN); else cbi(LCD_RS_PORT, LCD_RS_PIN);`
413	`lcd_toggle_e();`	413	`lcd_toggle_e();`
414	`/* output low nibble */`	414	`/* output low nibble */`
415	`/* if INIT_MODE skip this section else execute it */`	415	`/* if INIT_MODE skip this section else execute it */`
416	`if(mode!=INIT_MODE)`	416	`if(mode!=INIT_MODE)`
417	`{`	417	`{`
418	`if(data&0x01) sbi(LCD_D4_PORT, LCD_D4_PIN); else cbi(LCD_D4_PORT, LCD_D4_PIN);`	418	`if(data&0x01) sbi(LCD_D4_PORT, LCD_D4_PIN); else cbi(LCD_D4_PORT, LCD_D4_PIN);`
419	`if(data&0x02) sbi(LCD_D5_PORT, LCD_D5_PIN); else cbi(LCD_D5_PORT, LCD_D5_PIN);`	419	`if(data&0x02) sbi(LCD_D5_PORT, LCD_D5_PIN); else cbi(LCD_D5_PORT, LCD_D5_PIN);`
420	`if(data&0x04) sbi(LCD_D6_PORT, LCD_D6_PIN); else cbi(LCD_D6_PORT, LCD_D6_PIN);`	420	`if(data&0x04) sbi(LCD_D6_PORT, LCD_D6_PIN); else cbi(LCD_D6_PORT, LCD_D6_PIN);`
421	`if(data&0x08) sbi(LCD_D7_PORT, LCD_D7_PIN); else cbi(LCD_D7_PORT, LCD_D7_PIN);`	421	`if(data&0x08) sbi(LCD_D7_PORT, LCD_D7_PIN); else cbi(LCD_D7_PORT, LCD_D7_PIN);`
422	`if(rs) sbi(LCD_RS_PORT, LCD_RS_PIN); else cbi(LCD_RS_PORT, LCD_RS_PIN);`	422	`if(rs) sbi(LCD_RS_PORT, LCD_RS_PIN); else cbi(LCD_RS_PORT, LCD_RS_PIN);`
423	`lcd_toggle_e();`	423	`lcd_toggle_e();`
424	`}`	424	`}`
425		425
426	`delay(LCD_DELAY_SHORT);`	426	`delay(LCD_DELAY_SHORT);`
427		427
428	`}`	428	`}`
429	`/------------------------------------------------------------------------------------------------------/`	429	`/------------------------------------------------------------------------------------------------------/`
430	`void select_lcd(unsigned char lcd_unit)`	430	`void select_lcd(unsigned char lcd_unit)`
431	`{`	431	`{`
432	`/* Save the current lcd unit x,y coordinates */`	432	`/* Save the current lcd unit x,y coordinates */`
433	`xy_coordinates[current_lcd_unit].x=x;`	433	`xy_coordinates[current_lcd_unit].x=x;`
434	`xy_coordinates[current_lcd_unit].y=y;`	434	`xy_coordinates[current_lcd_unit].y=y;`
435		435
436	`if(lcd_unit==0)`	436	`if(lcd_unit==0)`
437	`{`	437	`{`
438	`lcd_E_port= LCD_0_E_PORT;`	438	`lcd_E_port= LCD_0_E_PORT;`
439	`lcd_E_pin = LCD_0_E_PIN;`	439	`lcd_E_pin = LCD_0_E_PIN;`
440	`lcd_chars_per_line = LCD_0_CHARS_PER_LINE;`	440	`lcd_chars_per_line = LCD_0_CHARS_PER_LINE;`
441	`lcd_lines = LCD_0_LINES;`	441	`lcd_lines = LCD_0_LINES;`
442	`current_lcd_unit=lcd_unit; /* Make the requested lcd unit current (active) */`	442	`current_lcd_unit=lcd_unit; /* Make the requested lcd unit current (active) */`
443	`x=xy_coordinates[lcd_unit].x; /* Load the saved x,y coordinates of the specified lcd unit */`	443	`x=xy_coordinates[lcd_unit].x; /* Load the saved x,y coordinates of the specified lcd unit */`
444	`y=xy_coordinates[lcd_unit].y;`	444	`y=xy_coordinates[lcd_unit].y;`
445	`}`	445	`}`
446	`else if(lcd_unit==1)`	446	`else if(lcd_unit==1)`
447	`{`	447	`{`
448	`lcd_E_port= LCD_1_E_PORT;`	448	`lcd_E_port= LCD_1_E_PORT;`
449	`lcd_E_pin = LCD_1_E_PIN;`	449	`lcd_E_pin = LCD_1_E_PIN;`
450	`lcd_chars_per_line = LCD_1_CHARS_PER_LINE;`	450	`lcd_chars_per_line = LCD_1_CHARS_PER_LINE;`
451	`lcd_lines = LCD_1_LINES;`	451	`lcd_lines = LCD_1_LINES;`
452	`current_lcd_unit=lcd_unit;`	452	`current_lcd_unit=lcd_unit;`
453	`x=xy_coordinates[lcd_unit].x;`	453	`x=xy_coordinates[lcd_unit].x;`
454	`y=xy_coordinates[lcd_unit].y;`	454	`y=xy_coordinates[lcd_unit].y;`
455	`}`	455	`}`
456	`#if NUMBER_OF_LCD_UNITS >=3`	456	`#if NUMBER_OF_LCD_UNITS >=3`
457	`else if(lcd_unit==2)`	457	`else if(lcd_unit==2)`
458	`{`	458	`{`
459	`lcd_E_port= LCD_2_E_PORT;`	459	`lcd_E_port= LCD_2_E_PORT;`
460	`lcd_E_pin = LCD_2_E_PIN;`	460	`lcd_E_pin = LCD_2_E_PIN;`
461	`lcd_chars_per_line = LCD_2_CHARS_PER_LINE;`	461	`lcd_chars_per_line = LCD_2_CHARS_PER_LINE;`
462	`lcd_lines = LCD_2_LINES;`	462	`lcd_lines = LCD_2_LINES;`
463	`current_lcd_unit=lcd_unit;`	463	`current_lcd_unit=lcd_unit;`
464	`x=xy_coordinates[lcd_unit].x;`	464	`x=xy_coordinates[lcd_unit].x;`
465	`y=xy_coordinates[lcd_unit].y;`	465	`y=xy_coordinates[lcd_unit].y;`
466	`}`	466	`}`
467	`#endif`	467	`#endif`
468	`return;`	468	`return;`
469	`}`	469	`}`
470	`/######################################################################################################/`	470	`/######################################################################################################/`
471	`#elif LCD_IO_MODE == 6 /* lcd_write() function for 6 bit i/o with multi lcd units */`	471	`#elif LCD_IO_MODE == 6 /* lcd_write() function for 6 bit i/o with multi lcd units */`
472	`/######################################################################################################/`	472	`/######################################################################################################/`
473		473
474	`#if LCD_READ_REQUIRED == 1`	474	`#if LCD_READ_REQUIRED == 1`
475		475
476	`#define LCD_READ_DELAY ( (10*(F_CPU/60000))/100 )`	476	`#define LCD_READ_DELAY ( (10*(F_CPU/60000))/100 )`
477		477
478	`static unsigned char lcd_read(unsigned char rs)`	478	`static unsigned char lcd_read(unsigned char rs)`
479	`{`	479	`{`
480	`register unsigned char data=0;`	480	`register unsigned char data=0;`
481	`/* RS=1: read data, RS=0: read busy flag, RW=1 read mode */`	481	`/* RS=1: read data, RS=0: read busy flag, RW=1 read mode */`
482	`if (rs) sbi(LCD_RS_PORT, LCD_RS_PIN); else cbi(LCD_RS_PORT, LCD_RS_PIN);`	482	`if (rs) sbi(LCD_RS_PORT, LCD_RS_PIN); else cbi(LCD_RS_PORT, LCD_RS_PIN);`
483		483
484	`/* configure data pins as input */`	484	`/* configure data pins as input */`
485	`cbi(LCD_D4_DDR_REG, LCD_D4_PIN );`	485	`cbi(LCD_D4_DDR_REG, LCD_D4_PIN );`
486	`cbi(LCD_D5_DDR_REG, LCD_D5_PIN );`	486	`cbi(LCD_D5_DDR_REG, LCD_D5_PIN );`
487	`cbi(LCD_D6_DDR_REG, LCD_D6_PIN );`	487	`cbi(LCD_D6_DDR_REG, LCD_D6_PIN );`
488	`cbi(LCD_D7_DDR_REG, LCD_D7_PIN );`	488	`cbi(LCD_D7_DDR_REG, LCD_D7_PIN );`
489		489
490	`/* set R/W pin for reading from LCD */`	490	`/* set R/W pin for reading from LCD */`
491	`sbi(LCD_RW_PORT, LCD_RW_PIN);`	491	`sbi(LCD_RW_PORT, LCD_RW_PIN);`
492	`delay(LCD_READ_DELAY);`	492	`delay(LCD_READ_DELAY);`
493		493
494	`if(bit_is_set(LCD_D7_PIN_REG, LCD_D7_PIN)) { data+=1; }`	494	`if(bit_is_set(LCD_D7_PIN_REG, LCD_D7_PIN)) { data+=1; }`
495	`data=(data<<1);`	495	`data=(data<<1);`
496	`if(bit_is_set(LCD_D6_PIN_REG, LCD_D6_PIN)) { data+=1; }`	496	`if(bit_is_set(LCD_D6_PIN_REG, LCD_D6_PIN)) { data+=1; }`
497	`data=(data<<1);`	497	`data=(data<<1);`
498	`if(bit_is_set(LCD_D5_PIN_REG, LCD_D5_PIN)) { data+=1; }`	498	`if(bit_is_set(LCD_D5_PIN_REG, LCD_D5_PIN)) { data+=1; }`
499	`data=(data<<1);`	499	`data=(data<<1);`
500	`if(bit_is_set(LCD_D4_PIN_REG, LCD_D4_PIN)) { data+=1; }`	500	`if(bit_is_set(LCD_D4_PIN_REG, LCD_D4_PIN)) { data+=1; }`

Subversion Repositories svnkaklik

(root)/programy/C/avr/SFR08/lcd_io.c @ 665 – Rev 359 → 409