drivers/avr/hd44780.c

   1 /****************************************************************************
   2  Title:     HD44780U LCD library
   3  Author:    Peter Fleury <pfleury@gmx.ch>  http://tinyurl.com/peterfleury
   4  License:   GNU General Public License Version 3
   5  File:      $Id: lcd.c,v 1.15.2.2 2015/01/17 12:16:05 peter Exp $
   6  Software:  AVR-GCC 3.3
   7  Target:    any AVR device, memory mapped mode only for AT90S4414/8515/Mega
   8
   9  DESCRIPTION
  10        Basic routines for interfacing a HD44780U-based text lcd display
  11
  12        Originally based on Volker Oth's lcd library,
  13        changed lcd_init(), added additional constants for lcd_command(),
  14        added 4-bit I/O mode, improved and optimized code.
  15
  16        Library can be operated in memory mapped mode (LCD_IO_MODE=0) or in
  17        4-bit IO port mode (LCD_IO_MODE=1). 8-bit IO port mode not supported.
  18
  19        Memory mapped mode compatible with Kanda STK200, but supports also
  20        generation of R/W signal through A8 address line.
  21
  22  USAGE
  23        See the C include lcd.h file for a description of each function
  24
  25 *****************************************************************************/
  26 #include <inttypes.h>
  27 #include <avr/io.h>
  28 #include <avr/pgmspace.h>
  29 #include <util/delay.h>
  30 #include "hd44780.h"
  31
  32 /*
  33 ** constants/macros
  34 */
  35 #define DDR(x) (*(&x - 1))      /* address of data direction register of port x */
  36 #if defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__)
  37     /* on ATmega64/128 PINF is on port 0x00 and not 0x60 */
  38     #define PIN(x) ( &PORTF==&(x) ? _SFR_IO8(0x00) : (*(&x - 2)) )
  39 #else
  40         #define PIN(x) (*(&x - 2))    /* address of input register of port x          */
  41 #endif
  42
  43
  44 #if LCD_IO_MODE
  45 #define lcd_e_delay()   _delay_us(LCD_DELAY_ENABLE_PULSE)
  46 #define lcd_e_high()    LCD_E_PORT  |=  _BV(LCD_E_PIN);
  47 #define lcd_e_low()     LCD_E_PORT  &= ~_BV(LCD_E_PIN);
  48 #define lcd_e_toggle()  toggle_e()
  49 #define lcd_rw_high()   LCD_RW_PORT |=  _BV(LCD_RW_PIN)
  50 #define lcd_rw_low()    LCD_RW_PORT &= ~_BV(LCD_RW_PIN)
  51 #define lcd_rs_high()   LCD_RS_PORT |=  _BV(LCD_RS_PIN)
  52 #define lcd_rs_low()    LCD_RS_PORT &= ~_BV(LCD_RS_PIN)
  53 #endif
  54
  55 #if LCD_IO_MODE
  56 #if LCD_LINES==1
  57 #define LCD_FUNCTION_DEFAULT    LCD_FUNCTION_4BIT_1LINE
  58 #else
  59 #define LCD_FUNCTION_DEFAULT    LCD_FUNCTION_4BIT_2LINES
  60 #endif
  61 #else
  62 #if LCD_LINES==1
  63 #define LCD_FUNCTION_DEFAULT    LCD_FUNCTION_8BIT_1LINE
  64 #else
  65 #define LCD_FUNCTION_DEFAULT    LCD_FUNCTION_8BIT_2LINES
  66 #endif
  67 #endif
  68
  69 #if LCD_CONTROLLER_KS0073
  70 #if LCD_LINES==4
  71
  72 #define KS0073_EXTENDED_FUNCTION_REGISTER_ON  0x2C   /* |0|010|1100 4-bit mode, extension-bit RE = 1 */
  73 #define KS0073_EXTENDED_FUNCTION_REGISTER_OFF 0x28   /* |0|010|1000 4-bit mode, extension-bit RE = 0 */
  74 #define KS0073_4LINES_MODE                    0x09   /* |0|000|1001 4 lines mode */
  75
  76 #endif
  77 #endif
  78
  79 /*
  80 ** function prototypes
  81 */
  82 #if LCD_IO_MODE
  83 static void toggle_e(void);
  84 #endif
  85
  86 /*
  87 ** local functions
  88 */
  89
  90
  91 /*************************************************************************
  92 delay for a minimum of <us> microseconds
  93 the number of loops is calculated at compile-time from MCU clock frequency
  94 *************************************************************************/
  95 #define delay(us)  _delay_us(us)
  96
  97
  98 #if LCD_IO_MODE
  99 /* toggle Enable Pin to initiate write */
 100 static void toggle_e(void)
 101 {
 102     lcd_e_high();
 103     lcd_e_delay();
 104     lcd_e_low();
 105 }
 106 #endif
 107
 108
 109 /*************************************************************************
 110 Low-level function to write byte to LCD controller
 111 Input:    data   byte to write to LCD
 112           rs     1: write data
 113                  0: write instruction
 114 Returns:  none
 115 *************************************************************************/
 116 #if LCD_IO_MODE
 117 static void lcd_write(uint8_t data,uint8_t rs)
 118 {
 119     unsigned char dataBits ;
 120
 121
 122     if (rs) {        /* write data        (RS=1, RW=0) */
 123        lcd_rs_high();
 124     } else {         /* write instruction (RS=0, RW=0) */
 125        lcd_rs_low();
 126     }
 127     lcd_rw_low();    /* RW=0  write mode      */
 128
 129     if ( ( &LCD_DATA0_PORT == &LCD_DATA1_PORT) && ( &LCD_DATA1_PORT == &LCD_DATA2_PORT ) && ( &LCD_DATA2_PORT == &LCD_DATA3_PORT )
 130       && (LCD_DATA0_PIN == 0) && (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3) )
 131     {
 132         /* configure data pins as output */
 133         DDR(LCD_DATA0_PORT) |= 0x0F;
 134
 135         /* output high nibble first */
 136         dataBits = LCD_DATA0_PORT & 0xF0;
 137         LCD_DATA0_PORT = dataBits |((data>>4)&0x0F);
 138         lcd_e_toggle();
 139
 140         /* output low nibble */
 141         LCD_DATA0_PORT = dataBits | (data&0x0F);
 142         lcd_e_toggle();
 143
 144         /* all data pins high (inactive) */
 145         LCD_DATA0_PORT = dataBits | 0x0F;
 146     }
 147     else
 148     {
 149         /* configure data pins as output */
 150         DDR(LCD_DATA0_PORT) |= _BV(LCD_DATA0_PIN);
 151         DDR(LCD_DATA1_PORT) |= _BV(LCD_DATA1_PIN);
 152         DDR(LCD_DATA2_PORT) |= _BV(LCD_DATA2_PIN);
 153         DDR(LCD_DATA3_PORT) |= _BV(LCD_DATA3_PIN);
 154
 155         /* output high nibble first */
 156         LCD_DATA3_PORT &= ~_BV(LCD_DATA3_PIN);
 157         LCD_DATA2_PORT &= ~_BV(LCD_DATA2_PIN);
 158         LCD_DATA1_PORT &= ~_BV(LCD_DATA1_PIN);
 159         LCD_DATA0_PORT &= ~_BV(LCD_DATA0_PIN);
 160         if(data & 0x80) LCD_DATA3_PORT |= _BV(LCD_DATA3_PIN);
 161         if(data & 0x40) LCD_DATA2_PORT |= _BV(LCD_DATA2_PIN);
 162         if(data & 0x20) LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN);
 163         if(data & 0x10) LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN);
 164         lcd_e_toggle();
 165
 166         /* output low nibble */
 167         LCD_DATA3_PORT &= ~_BV(LCD_DATA3_PIN);
 168         LCD_DATA2_PORT &= ~_BV(LCD_DATA2_PIN);
 169         LCD_DATA1_PORT &= ~_BV(LCD_DATA1_PIN);
 170         LCD_DATA0_PORT &= ~_BV(LCD_DATA0_PIN);
 171         if(data & 0x08) LCD_DATA3_PORT |= _BV(LCD_DATA3_PIN);
 172         if(data & 0x04) LCD_DATA2_PORT |= _BV(LCD_DATA2_PIN);
 173         if(data & 0x02) LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN);
 174         if(data & 0x01) LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN);
 175         lcd_e_toggle();
 176
 177         /* all data pins high (inactive) */
 178         LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN);
 179         LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN);
 180         LCD_DATA2_PORT |= _BV(LCD_DATA2_PIN);
 181         LCD_DATA3_PORT |= _BV(LCD_DATA3_PIN);
 182     }
 183 }
 184 #else
 185 #define lcd_write(d,rs) if (rs) *(volatile uint8_t*)(LCD_IO_DATA) = d; else *(volatile uint8_t*)(LCD_IO_FUNCTION) = d;
 186 /* rs==0 -> write instruction to LCD_IO_FUNCTION */
 187 /* rs==1 -> write data to LCD_IO_DATA */
 188 #endif
 189
 190
 191 /*************************************************************************
 192 Low-level function to read byte from LCD controller
 193 Input:    rs     1: read data
 194                  0: read busy flag / address counter
 195 Returns:  byte read from LCD controller
 196 *************************************************************************/
 197 #if LCD_IO_MODE
 198 static uint8_t lcd_read(uint8_t rs)
 199 {
 200     uint8_t data;
 201
 202
 203     if (rs)
 204         lcd_rs_high();                       /* RS=1: read data      */
 205     else
 206         lcd_rs_low();                        /* RS=0: read busy flag */
 207     lcd_rw_high();                           /* RW=1  read mode      */
 208
 209     if ( ( &LCD_DATA0_PORT == &LCD_DATA1_PORT) && ( &LCD_DATA1_PORT == &LCD_DATA2_PORT ) && ( &LCD_DATA2_PORT == &LCD_DATA3_PORT )
 210       && ( LCD_DATA0_PIN == 0 )&& (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3) )
 211     {
 212         DDR(LCD_DATA0_PORT) &= 0xF0;         /* configure data pins as input */
 213
 214         lcd_e_high();
 215         lcd_e_delay();
 216         data = PIN(LCD_DATA0_PORT) << 4;     /* read high nibble first */
 217         lcd_e_low();
 218
 219         lcd_e_delay();                       /* Enable 500ns low       */
 220
 221         lcd_e_high();
 222         lcd_e_delay();
 223         data |= PIN(LCD_DATA0_PORT)&0x0F;    /* read low nibble        */
 224         lcd_e_low();
 225     }
 226     else
 227     {
 228         /* configure data pins as input */
 229         DDR(LCD_DATA0_PORT) &= ~_BV(LCD_DATA0_PIN);
 230         DDR(LCD_DATA1_PORT) &= ~_BV(LCD_DATA1_PIN);
 231         DDR(LCD_DATA2_PORT) &= ~_BV(LCD_DATA2_PIN);
 232         DDR(LCD_DATA3_PORT) &= ~_BV(LCD_DATA3_PIN);
 233
 234         /* read high nibble first */
 235         lcd_e_high();
 236         lcd_e_delay();
 237         data = 0;
 238         if ( PIN(LCD_DATA0_PORT) & _BV(LCD_DATA0_PIN) ) data |= 0x10;
 239         if ( PIN(LCD_DATA1_PORT) & _BV(LCD_DATA1_PIN) ) data |= 0x20;
 240         if ( PIN(LCD_DATA2_PORT) & _BV(LCD_DATA2_PIN) ) data |= 0x40;
 241         if ( PIN(LCD_DATA3_PORT) & _BV(LCD_DATA3_PIN) ) data |= 0x80;
 242         lcd_e_low();
 243
 244         lcd_e_delay();                       /* Enable 500ns low       */
 245
 246         /* read low nibble */
 247         lcd_e_high();
 248         lcd_e_delay();
 249         if ( PIN(LCD_DATA0_PORT) & _BV(LCD_DATA0_PIN) ) data |= 0x01;
 250         if ( PIN(LCD_DATA1_PORT) & _BV(LCD_DATA1_PIN) ) data |= 0x02;
 251         if ( PIN(LCD_DATA2_PORT) & _BV(LCD_DATA2_PIN) ) data |= 0x04;
 252         if ( PIN(LCD_DATA3_PORT) & _BV(LCD_DATA3_PIN) ) data |= 0x08;
 253         lcd_e_low();
 254     }
 255     return data;
 256 }
 257 #else
 258 #define lcd_read(rs) (rs) ? *(volatile uint8_t*)(LCD_IO_DATA+LCD_IO_READ) : *(volatile uint8_t*)(LCD_IO_FUNCTION+LCD_IO_READ)
 259 /* rs==0 -> read instruction from LCD_IO_FUNCTION */
 260 /* rs==1 -> read data from LCD_IO_DATA */
 261 #endif
 262
 263
 264 /*************************************************************************
 265 loops while lcd is busy, returns address counter
 266 *************************************************************************/
 267 static uint8_t lcd_waitbusy(void)
 268
 269 {
 270     register uint8_t c;
 271
 272     /* wait until busy flag is cleared */
 273     while ( (c=lcd_read(0)) & (1<<LCD_BUSY)) {}
 274
 275     /* the address counter is updated 4us after the busy flag is cleared */
 276     delay(LCD_DELAY_BUSY_FLAG);
 277
 278     /* now read the address counter */
 279     return (lcd_read(0));  // return address counter
 280
 281 }/* lcd_waitbusy */
 282
 283
 284 /*************************************************************************
 285 Move cursor to the start of next line or to the first line if the cursor
 286 is already on the last line.
 287 *************************************************************************/
 288 static inline void lcd_newline(uint8_t pos)
 289 {
 290     register uint8_t addressCounter;
 291
 292
 293 #if LCD_LINES==1
 294     addressCounter = 0;
 295 #endif
 296 #if LCD_LINES==2
 297     if ( pos < (LCD_START_LINE2) )
 298         addressCounter = LCD_START_LINE2;
 299     else
 300         addressCounter = LCD_START_LINE1;
 301 #endif
 302 #if LCD_LINES==4
 303 #if KS0073_4LINES_MODE
 304     if ( pos < LCD_START_LINE2 )
 305         addressCounter = LCD_START_LINE2;
 306     else if ( (pos >= LCD_START_LINE2) && (pos < LCD_START_LINE3) )
 307         addressCounter = LCD_START_LINE3;
 308     else if ( (pos >= LCD_START_LINE3) && (pos < LCD_START_LINE4) )
 309         addressCounter = LCD_START_LINE4;
 310     else
 311         addressCounter = LCD_START_LINE1;
 312 #else
 313     if ( pos < LCD_START_LINE3 )
 314         addressCounter = LCD_START_LINE2;
 315     else if ( (pos >= LCD_START_LINE2) && (pos < LCD_START_LINE4) )
 316         addressCounter = LCD_START_LINE3;
 317     else if ( (pos >= LCD_START_LINE3) && (pos < LCD_START_LINE2) )
 318         addressCounter = LCD_START_LINE4;
 319     else
 320         addressCounter = LCD_START_LINE1;
 321 #endif
 322 #endif
 323     lcd_command((1<<LCD_DDRAM)+addressCounter);
 324
 325 }/* lcd_newline */
 326
 327
 328 /*
 329 ** PUBLIC FUNCTIONS
 330 */
 331
 332 /*************************************************************************
 333 Send LCD controller instruction command
 334 Input:   instruction to send to LCD controller, see HD44780 data sheet
 335 Returns: none
 336 *************************************************************************/
 337 void lcd_command(uint8_t cmd)
 338 {
 339     lcd_waitbusy();
 340     lcd_write(cmd,0);
 341 }
 342
 343
 344 /*************************************************************************
 345 Send data byte to LCD controller
 346 Input:   data to send to LCD controller, see HD44780 data sheet
 347 Returns: none
 348 *************************************************************************/
 349 void lcd_data(uint8_t data)
 350 {
 351     lcd_waitbusy();
 352     lcd_write(data,1);
 353 }
 354
 355
 356
 357 /*************************************************************************
 358 Set cursor to specified position
 359 Input:    x  horizontal position  (0: left most position)
 360           y  vertical position    (0: first line)
 361 Returns:  none
 362 *************************************************************************/
 363 void lcd_gotoxy(uint8_t x, uint8_t y)
 364 {
 365 #if LCD_LINES==1
 366     lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
 367 #endif
 368 #if LCD_LINES==2
 369     if ( y==0 )
 370         lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
 371     else
 372         lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+x);
 373 #endif
 374 #if LCD_LINES==4
 375     if ( y==0 )
 376         lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
 377     else if ( y==1)
 378         lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+x);
 379     else if ( y==2)
 380         lcd_command((1<<LCD_DDRAM)+LCD_START_LINE3+x);
 381     else /* y==3 */
 382         lcd_command((1<<LCD_DDRAM)+LCD_START_LINE4+x);
 383 #endif
 384
 385 }/* lcd_gotoxy */
 386
 387
 388 /*************************************************************************
 389 *************************************************************************/
 390 int lcd_getxy(void)
 391 {
 392     return lcd_waitbusy();
 393 }
 394
 395
 396 /*************************************************************************
 397 Clear display and set cursor to home position
 398 *************************************************************************/
 399 void lcd_clrscr(void)
 400 {
 401     lcd_command(1<<LCD_CLR);
 402 }
 403
 404
 405 /*************************************************************************
 406 Set cursor to home position
 407 *************************************************************************/
 408 void lcd_home(void)
 409 {
 410     lcd_command(1<<LCD_HOME);
 411 }
 412
 413
 414 /*************************************************************************
 415 Display character at current cursor position
 416 Input:    character to be displayed
 417 Returns:  none
 418 *************************************************************************/
 419 void lcd_putc(char c)
 420 {
 421     uint8_t pos;
 422
 423
 424     pos = lcd_waitbusy();   // read busy-flag and address counter
 425     if (c=='\n')
 426     {
 427         lcd_newline(pos);
 428     }
 429     else
 430     {
 431 #if LCD_WRAP_LINES==1
 432 #if LCD_LINES==1
 433         if ( pos == LCD_START_LINE1+LCD_DISP_LENGTH ) {
 434             lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
 435         }
 436 #elif LCD_LINES==2
 437         if ( pos == LCD_START_LINE1+LCD_DISP_LENGTH ) {
 438             lcd_write((1<<LCD_DDRAM)+LCD_START_LINE2,0);
 439         }else if ( pos == LCD_START_LINE2+LCD_DISP_LENGTH ){
 440             lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
 441         }
 442 #elif LCD_LINES==4
 443         if ( pos == LCD_START_LINE1+LCD_DISP_LENGTH ) {
 444             lcd_write((1<<LCD_DDRAM)+LCD_START_LINE2,0);
 445         }else if ( pos == LCD_START_LINE2+LCD_DISP_LENGTH ) {
 446             lcd_write((1<<LCD_DDRAM)+LCD_START_LINE3,0);
 447         }else if ( pos == LCD_START_LINE3+LCD_DISP_LENGTH ) {
 448             lcd_write((1<<LCD_DDRAM)+LCD_START_LINE4,0);
 449         }else if ( pos == LCD_START_LINE4+LCD_DISP_LENGTH ) {
 450             lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
 451         }
 452 #endif
 453         lcd_waitbusy();
 454 #endif
 455         lcd_write(c, 1);
 456     }
 457
 458 }/* lcd_putc */
 459
 460
 461 /*************************************************************************
 462 Display string without auto linefeed
 463 Input:    string to be displayed
 464 Returns:  none
 465 *************************************************************************/
 466 void lcd_puts(const char *s)
 467 /* print string on lcd (no auto linefeed) */
 468 {
 469     register char c;
 470
 471     while ( (c = *s++) ) {
 472         lcd_putc(c);
 473     }
 474
 475 }/* lcd_puts */
 476
 477
 478 /*************************************************************************
 479 Display string from program memory without auto linefeed
 480 Input:     string from program memory be be displayed
 481 Returns:   none
 482 *************************************************************************/
 483 void lcd_puts_p(const char *progmem_s)
 484 /* print string from program memory on lcd (no auto linefeed) */
 485 {
 486     register char c;
 487
 488     while ( (c = pgm_read_byte(progmem_s++)) ) {
 489         lcd_putc(c);
 490     }
 491
 492 }/* lcd_puts_p */
 493
 494
 495 /*************************************************************************
 496 Initialize display and select type of cursor
 497 Input:    dispAttr LCD_DISP_OFF            display off
 498                    LCD_DISP_ON             display on, cursor off
 499                    LCD_DISP_ON_CURSOR      display on, cursor on
 500                    LCD_DISP_CURSOR_BLINK   display on, cursor on flashing
 501 Returns:  none
 502 *************************************************************************/
 503 void lcd_init(uint8_t dispAttr)
 504 {
 505 #if LCD_IO_MODE
 506     /*
 507      *  Initialize LCD to 4 bit I/O mode
 508      */
 509
 510     if ( ( &LCD_DATA0_PORT == &LCD_DATA1_PORT) && ( &LCD_DATA1_PORT == &LCD_DATA2_PORT ) && ( &LCD_DATA2_PORT == &LCD_DATA3_PORT )
 511       && ( &LCD_RS_PORT == &LCD_DATA0_PORT) && ( &LCD_RW_PORT == &LCD_DATA0_PORT) && (&LCD_E_PORT == &LCD_DATA0_PORT)
 512       && (LCD_DATA0_PIN == 0 ) && (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3)
 513       && (LCD_RS_PIN == 4 ) && (LCD_RW_PIN == 5) && (LCD_E_PIN == 6 ) )
 514     {
 515         /* configure all port bits as output (all LCD lines on same port) */
 516         DDR(LCD_DATA0_PORT) |= 0x7F;
 517     }
 518     else if ( ( &LCD_DATA0_PORT == &LCD_DATA1_PORT) && ( &LCD_DATA1_PORT == &LCD_DATA2_PORT ) && ( &LCD_DATA2_PORT == &LCD_DATA3_PORT )
 519            && (LCD_DATA0_PIN == 0 ) && (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3) )
 520     {
 521         /* configure all port bits as output (all LCD data lines on same port, but control lines on different ports) */
 522         DDR(LCD_DATA0_PORT) |= 0x0F;
 523         DDR(LCD_RS_PORT)    |= _BV(LCD_RS_PIN);
 524         DDR(LCD_RW_PORT)    |= _BV(LCD_RW_PIN);
 525         DDR(LCD_E_PORT)     |= _BV(LCD_E_PIN);
 526     }
 527     else
 528     {
 529         /* configure all port bits as output (LCD data and control lines on different ports */
 530         DDR(LCD_RS_PORT)    |= _BV(LCD_RS_PIN);
 531         DDR(LCD_RW_PORT)    |= _BV(LCD_RW_PIN);
 532         DDR(LCD_E_PORT)     |= _BV(LCD_E_PIN);
 533         DDR(LCD_DATA0_PORT) |= _BV(LCD_DATA0_PIN);
 534         DDR(LCD_DATA1_PORT) |= _BV(LCD_DATA1_PIN);
 535         DDR(LCD_DATA2_PORT) |= _BV(LCD_DATA2_PIN);
 536         DDR(LCD_DATA3_PORT) |= _BV(LCD_DATA3_PIN);
 537     }
 538     delay(LCD_DELAY_BOOTUP);             /* wait 16ms or more after power-on       */
 539
 540     /* initial write to lcd is 8bit */
 541     LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN);    // LCD_FUNCTION>>4;
 542     LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN);    // LCD_FUNCTION_8BIT>>4;
 543     lcd_e_toggle();
 544     delay(LCD_DELAY_INIT);               /* delay, busy flag can't be checked here */
 545
 546     /* repeat last command */
 547     lcd_e_toggle();
 548     delay(LCD_DELAY_INIT_REP);           /* delay, busy flag can't be checked here */
 549
 550     /* repeat last command a third time */
 551     lcd_e_toggle();
 552     delay(LCD_DELAY_INIT_REP);           /* delay, busy flag can't be checked here */
 553
 554     /* now configure for 4bit mode */
 555     LCD_DATA0_PORT &= ~_BV(LCD_DATA0_PIN);   // LCD_FUNCTION_4BIT_1LINE>>4
 556     lcd_e_toggle();
 557     delay(LCD_DELAY_INIT_4BIT);          /* some displays need this additional delay */
 558
 559     /* from now the LCD only accepts 4 bit I/O, we can use lcd_command() */
 560 #else
 561     /*
 562      * Initialize LCD to 8 bit memory mapped mode
 563      */
 564
 565     /* enable external SRAM (memory mapped lcd) and one wait state */
 566     MCUCR = _BV(SRE) | _BV(SRW);
 567
 568     /* reset LCD */
 569     delay(LCD_DELAY_BOOTUP);                    /* wait 16ms after power-on     */
 570     lcd_write(LCD_FUNCTION_8BIT_1LINE,0);   /* function set: 8bit interface */
 571     delay(LCD_DELAY_INIT);                      /* wait 5ms                     */
 572     lcd_write(LCD_FUNCTION_8BIT_1LINE,0);   /* function set: 8bit interface */
 573     delay(LCD_DELAY_INIT_REP);                  /* wait 64us                    */
 574     lcd_write(LCD_FUNCTION_8BIT_1LINE,0);   /* function set: 8bit interface */
 575     delay(LCD_DELAY_INIT_REP);                  /* wait 64us                    */
 576 #endif
 577
 578 #if KS0073_4LINES_MODE
 579     /* Display with KS0073 controller requires special commands for enabling 4 line mode */
 580         lcd_command(KS0073_EXTENDED_FUNCTION_REGISTER_ON);
 581         lcd_command(KS0073_4LINES_MODE);
 582         lcd_command(KS0073_EXTENDED_FUNCTION_REGISTER_OFF);
 583 #else
 584     lcd_command(LCD_FUNCTION_DEFAULT);      /* function set: display lines  */
 585 #endif
 586     lcd_command(LCD_DISP_OFF);              /* display off                  */
 587     lcd_clrscr();                           /* display clear                */
 588     lcd_command(LCD_MODE_DEFAULT);          /* set entry mode               */
 589     lcd_command(dispAttr);                  /* display/cursor control       */
 590
 591 }/* lcd_init */
 592