AVR Freaks

I understand that about the minimum delay. But use 5mS as a predefined global delay? There are a lot of instructions that only requires like 1/2000 of that time! Aren't we being kinda slack using such amount of time as a predefined delay? Aren't we turning our code into a relatively slow code only because of those 5mS??? 

Ok, yes, I'm also aware that timings varies with quite some factors as voltage, frequency, temperature and probably even with the manufacturing process. But I don't want to get that way at all. I want to make things as simple as possible, but not as simple as just using someone's code just because.

I have my AtMega328 running with a 16MHz XTAL.

Back then I also struggled to make this to work on the hardware. I was using MCU 8051 IDE that allowed us to ignore all these timings. And we used the 8 bit mode.
And I memorised the idea (not sure if correct) that send an instruction (that I call command sometimes) was different of sending data which means send alpha numeric chars to the LCD and that the code for both actions was different. But looks like that the only difference is the RS bit.

But I think I already understood how to do it using 4 bit mode. My problem is the timings for instructions and for data. Is to line them up correctly.

It will take much more time to me to dissect that one.
Peter's code is more straightforward, I guess.

I have just tested the code I've just tested the code from this link:

http://www.johanekdahl.se/rwiki/...

and I added some delays but still could not make it work. Or better, some rubish shows up on the LCD display!

This is the code I tested:

/* Simple LCD character display module demonstrator using
 * the 4-bit interface. No handling of the busy flag is
 * done - all timing contraints are handled by delay loops.
 * This code should be good to run at up to 8 MHz.
 * Above that you might have to tweak the timing of things
 * including, but not restricted to, the existing delays.
 */

#include <avr/io.h>
#include <util/delay.h>

/* Here are some defines for the data connections,
 * DB4..7 on the LCD display module. These should be wired
 * up to the four high pins  of any port A..D. You need to alter
 * these to fit your wire up of your display.
 */
#define LCD_DATA_PORT PORTB
#define LCD_DATA_DDR  DDRB

#define LCD_D7 PB1
#define LCD_D6 PB2
#define LCD_D5 PB3
#define LCD_D4 PB4

/* Here are some defines for the control connections
 * (RS, R/W and E on the LCD display module). These can be wired
 * to any pins on any port A..D (all to the same port though).
 * You need to alter these to fit your wire up of your display.
 */
#define LCD_CTRL_PORT PORTC
#define LCD_CTRL_DDR  DDRC
#define LCD_RW        PC5
#define LCD_E         PC4
#define LCD_RS        PC3

/*
 * YOU SHOULD NOT NEED TO ALTER ANYTHING BEYOND THIS POINT!
 *
 * This holds as long as you have the four data signals
 * connected to the upper 4-bit nibble of the AVR port,
 * and you run at a maximum frequency of 8 MHz.
 */

/*
 * Here are some defines for the LCD instructions we'll use.
 */
#define LCD_FUNCTION_SET      0x30 // 0b00110000, 8 bit, 2 lines, 5x8 dots
#define LCD_FUNCTION_SET_4BIT 0x28 // 0b00101000, 4 bit, 2 lines, 5x8 dots
#define LCD_DISPLAY_OFF       0x08 // 0b00001000, Disp OFF, cursor OFF, blink OFF
#define LCD_DISPLAY_ON        0x0C // 0b00001111, Disp ON, cursor ON, Blink ON
#define LCD_DISPLAY_CLEAR     0x01 // 0b00000001, Display clear
#define LCD_ENTRY_MODE_SET    0x06 // 0b00000110, Increment ADC, no display shift
#define LCD_CURSOR_HOME       0x02 // 0b00000010, Return home


/* LcdSendNibble
 *
 * Sends a 4-bit nibble to the display.
 *
 * Parameters:
 *  uint8_t nibble  The high nibble of of this byte
 *                  is sent to the display.
 * Returns:
 *  nothing
 */
void LcdSendNibble( uint8_t nibble ){
   _delay_us(50);

   // Output upper nibble on the data ports upper bits
   LCD_DATA_PORT = (nibble & 0xF0) | (LCD_DATA_PORT & 0x0F);

   // Toggle the E line
   LCD_CTRL_PORT |=  (1 << LCD_E);   // Going up..
   _delay_us(50);
   LCD_CTRL_PORT &= ~(1 << LCD_E);  // ..and down.
}

/* LcdSendByte
 *
 * Sends a 8-bit byte to the display.
 *
 * Parameters:
 *  uint8_t theByte The byte to send to the display
 *
 * Returns:
 *  nothing
 */
void LcdSendByte(uint8_t theByte){
   // Send the high nibble
   LcdSendNibble(theByte);
   // Shift theByte to get lower nibble in upper part...
   // ...and send it
   LcdSendNibble(theByte << 4);
}

/* LcdSendInstruction
 *
 * Sends an instruction to the display.
 *
 * Parameters:
 *  uint8_t command This byte is sent to the display as
 *                  an instruction (RS low).
 * Returns:
 *  nothing
 */
void LcdSendInstruction( uint8_t theInstruction ){
   // RS low for instructions
   LCD_CTRL_PORT &= ~(1 << LCD_RS);

   // Send the instruction
   LcdSendByte(theInstruction);
}

/* LcdSendCharacter
 *
 * Sends a character to the display.
 *
 * Parameters:
 *  uint8_t nibble  This byte is sent to the display as
 *                  a character (RS high).
 * Returns:
 *  nothing
 */
void LcdSendCharacter(uint8_t theChar){
   // RS high for characters to display
   LCD_CTRL_PORT |= (1 << LCD_RS);

   // Send the command
   LcdSendByte(theChar);
}

/* LcdInitialize
 *
 * Initialize the display.
 *
 * Parameters:
 *  none
 *
 * Returns:
 *  nothing
 */
void LcdInitialize(void){
   // initialize LCD control lines
   LCD_CTRL_PORT &= ~(1 << LCD_RS);   // RS low
   LCD_CTRL_PORT &= ~(1 << LCD_RW);   // R/W low
   LCD_CTRL_PORT &= ~(1 << LCD_E);    // E low

   // initialize LCD control lines to output
   LCD_CTRL_DDR |= (1 << LCD_RS);
   LCD_CTRL_DDR |= (1 << LCD_RW);
   LCD_CTRL_DDR |= (1 << LCD_E);

   // initialize LCD data port to input
   LCD_DATA_DDR |= 0xF0;      // Data on high four bits of port for now...

   // First part of init sequence is 3 x Function Set with
   // stipulated waits. Note that the display is in 8-bit mode
   // initially, but although the four low data lines are not connected
   // this does not matter as the instructions low nibble is zero anyway.
   _delay_ms(100);
   LcdSendNibble( LCD_FUNCTION_SET );
   _delay_ms(10);
   LcdSendNibble( LCD_FUNCTION_SET );
   _delay_us(200);
   LcdSendNibble( LCD_FUNCTION_SET );
   _delay_us(200);

   // Now, still in 8-bit mode, set the display to 4-bit mode
   LcdSendNibble( LCD_FUNCTION_SET_4BIT );
   _delay_us(80);
   // We are now in 4-bit mode.
   // Do the rest of the init sequence.
   LcdSendInstruction( LCD_FUNCTION_SET_4BIT );
   _delay_us(80);
   LcdSendInstruction( LCD_DISPLAY_OFF );
   _delay_us(80);
   LcdSendInstruction( LCD_DISPLAY_CLEAR );
   _delay_ms(4);
   LcdSendInstruction( LCD_ENTRY_MODE_SET );
   _delay_us(80);
   LcdSendInstruction( LCD_DISPLAY_ON );
   _delay_us(80);
}

char message[] = "4-bit avr-gcc";


int main(void){
   LcdInitialize();

   volatile int i = 0;
   while (message[i] != '\0'){
       LcdSendCharacter(message[i++]);
   }

   while(1);
   return 0;
}

This code is not working... Prints some garbage chars on the screen.

Howver, this code below, works perfectly and it prints in the LCD display correctly (the code is not mine and it was takne from here http://web.alfredstate.edu/weima...):

/****************************************************************************
    LCD-AVR-4d.c  - Use an HD44780U based LCD with an Atmel ATmega processor
 
    Copyright (C) 2013 Donald Weiman    (weimandn@alfredstate.edu)
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
/****************************************************************************
         File:    LCD-AVR-4d.c
         Date:    September 16, 2013
 
       Target:    ATmega328
     Compiler:    avr-gcc (AVR Studio 6)
       Author:    Donald Weiman
 
      Summary:    4-bit data interface, busy flag not implemented.
                  Any LCD pin can be connected to any available I/O port.
                  Includes a simple write string routine.
 */
/******************************* Program Notes ******************************
 
            This program uses a 4-bit data interface but does not use the
              busy flag to determine when the LCD controller is ready.  The
              LCD RW line (pin 5) is not connected to the uP and it must be
              connected to GND for the program to function.
 
            All time delays are longer than those specified in most datasheets
              in order to accommodate slower than normal LCD modules.  This
              requirement is well documented but almost always ignored.  The
              information is in a note at the bottom of the right hand
              (Execution Time) column of the instruction set.
 
  ***************************************************************************
 
            The four data lines as well as the two control lines may be
              implemented on any available I/O pin of any port.  These are
              the connections used for this program:
 
                 -----------                   ----------
                | ATmega328 |                 |   LCD    |
                |           |                 |          |
                |        PD7|---------------->|D7        |
                |        PD6|---------------->|D6        |
                |        PD5|---------------->|D5        |
                |        PD4|---------------->|D4        |
                |           |                 |D3        |
                |           |                 |D2        |
                |           |                 |D1        |
                |           |                 |D0        |
                |           |                 |          |
                |        PB1|---------------->|E         |
                |           |         GND --->|RW        |
                |        PB0|---------------->|RS        |
                 -----------                   ----------
 
  **************************************************************************/

#define F_CPU 16000000UL

#include <avr/io.h>
#include <util/delay.h>

// LCD interface (should agree with the diagram above)
//   make sure that the LCD RW pin is connected to GND
#define lcd_D7_port     PORTD                   // lcd D7 connection
#define lcd_D7_bit      PORTD7
#define lcd_D7_ddr      DDRD

#define lcd_D6_port     PORTD                   // lcd D6 connection
#define lcd_D6_bit      PORTD6
#define lcd_D6_ddr      DDRD

#define lcd_D5_port     PORTD                   // lcd D5 connection
#define lcd_D5_bit      PORTD5
#define lcd_D5_ddr      DDRD

#define lcd_D4_port     PORTD                   // lcd D4 connection
#define lcd_D4_bit      PORTD4
#define lcd_D4_ddr      DDRD

#define lcd_E_port      PORTB                   // lcd Enable pin
#define lcd_E_bit       PORTB1
#define lcd_E_ddr       DDRB

#define lcd_RS_port     PORTB                   // lcd Register Select pin
#define lcd_RS_bit      PORTB0
#define lcd_RS_ddr      DDRB

// LCD module information
#define lcd_LineOne     0x00                    // start of line 1
#define lcd_LineTwo     0x40                    // start of line 2
//#define   lcd_LineThree   0x14                  // start of line 3 (20x4)
//#define   lcd_lineFour    0x54                  // start of line 4 (20x4)
//#define   lcd_LineThree   0x10                  // start of line 3 (16x4)
//#define   lcd_lineFour    0x50                  // start of line 4 (16x4)

// LCD instructions
#define lcd_Clear           0b00000001          // replace all characters with ASCII 'space'
#define lcd_Home            0b00000010          // return cursor to first position on first line
#define lcd_EntryMode       0b00000110          // shift cursor from left to right on read/write
#define lcd_DisplayOff      0b00001000          // turn display off
#define lcd_DisplayOn       0b00001100          // display on, cursor off, don't blink character
#define lcd_FunctionReset   0b00110000          // reset the LCD
#define lcd_FunctionSet4bit 0b00101000          // 4-bit data, 2-line display, 5 x 7 font
#define lcd_SetCursor       0b10000000          // set cursor position

// Program ID
uint8_t program_author[]   = "Donald Weiman";
uint8_t program_version[]  = "LCD-AVR-4d (gcc)";
uint8_t program_date[]     = "Sep 16, 2013";

// Function Prototypes
void lcd_write_4(uint8_t);
void lcd_write_instruction_4d(uint8_t);
void lcd_write_character_4d(uint8_t);
void lcd_write_string_4d(uint8_t *);
void lcd_init_4d(void);

/******************************* Main Program Code *************************/
int main(void)
{
// configure the microprocessor pins for the data lines
    lcd_D7_ddr |= (1<<lcd_D7_bit);                  // 4 data lines - output
    lcd_D6_ddr |= (1<<lcd_D6_bit);
    lcd_D5_ddr |= (1<<lcd_D5_bit);
    lcd_D4_ddr |= (1<<lcd_D4_bit);

// configure the microprocessor pins for the control lines
    lcd_E_ddr |= (1<<lcd_E_bit);                    // E line - output
    lcd_RS_ddr |= (1<<lcd_RS_bit);                  // RS line - output

// initialize the LCD controller as determined by the defines (LCD instructions)
    lcd_init_4d();                                  // initialize the LCD display for a 4-bit interface

// display the first line of information
    lcd_write_string_4d(program_author);

// set cursor to start of second line
    lcd_write_instruction_4d(lcd_SetCursor | lcd_LineTwo);
    _delay_us(80);                                  // 40 uS delay (min)

// display the second line of information
    lcd_write_string_4d(program_version);

// endless loop
    while(1);
    return 0;
}
/******************************* End of Main Program Code ******************/

/*============================== 4-bit LCD Functions ======================*/
/*
  Name:     lcd_init_4d
  Purpose:  initialize the LCD module for a 4-bit data interface
  Entry:    equates (LCD instructions) set up for the desired operation
  Exit:     no parameters
  Notes:    uses time delays rather than checking the busy flag
*/
void lcd_init_4d(void)
{
// Power-up delay
    _delay_ms(100);                                 // initial 40 mSec delay

// IMPORTANT - At this point the LCD module is in the 8-bit mode and it is expecting to receive  
//   8 bits of data, one bit on each of its 8 data lines, each time the 'E' line is pulsed.
//
// Since the LCD module is wired for the 4-bit mode, only the upper four data lines are connected to 
//   the microprocessor and the lower four data lines are typically left open.  Therefore, when 
//   the 'E' line is pulsed, the LCD controller will read whatever data has been set up on the upper 
//   four data lines and the lower four data lines will be high (due to internal pull-up circuitry).
//
// Fortunately the 'FunctionReset' instruction does not care about what is on the lower four bits so  
//   this instruction can be sent on just the four available data lines and it will be interpreted 
//   properly by the LCD controller.  The 'lcd_write_4' subroutine will accomplish this if the 
//   control lines have previously been configured properly.

// Set up the RS and E lines for the 'lcd_write_4' subroutine.
    lcd_RS_port &= ~(1<<lcd_RS_bit);                // select the Instruction Register (RS low)
    lcd_E_port &= ~(1<<lcd_E_bit);                  // make sure E is initially low

// Reset the LCD controller
    lcd_write_4(lcd_FunctionReset);                 // first part of reset sequence
    _delay_ms(10);                                  // 4.1 mS delay (min)

    lcd_write_4(lcd_FunctionReset);                 // second part of reset sequence
    _delay_us(200);                                 // 100uS delay (min)

    lcd_write_4(lcd_FunctionReset);                 // third part of reset sequence
    _delay_us(200);                                 // this delay is omitted in the data sheet

// Preliminary Function Set instruction - used only to set the 4-bit mode.
// The number of lines or the font cannot be set at this time since the controller is still in the
//  8-bit mode, but the data transfer mode can be changed since this parameter is determined by one 
//  of the upper four bits of the instruction.
 
    lcd_write_4(lcd_FunctionSet4bit);               // set 4-bit mode
    _delay_us(80);                                  // 40uS delay (min)

// Function Set instruction
    lcd_write_instruction_4d(lcd_FunctionSet4bit);   // set mode, lines, and font
    _delay_us(80);                                  // 40uS delay (min)

// The next three instructions are specified in the data sheet as part of the initialization routine, 
//  so it is a good idea (but probably not necessary) to do them just as specified and then redo them 
//  later if the application requires a different configuration.

// Display On/Off Control instruction
    lcd_write_instruction_4d(lcd_DisplayOff);        // turn display OFF
    _delay_us(80);                                  // 40uS delay (min)

// Clear Display instruction
    lcd_write_instruction_4d(lcd_Clear);             // clear display RAM
    _delay_ms(4);                                   // 1.64 mS delay (min)

// ; Entry Mode Set instruction
    lcd_write_instruction_4d(lcd_EntryMode);         // set desired shift characteristics
    _delay_us(80);                                  // 40uS delay (min)

// This is the end of the LCD controller initialization as specified in the data sheet, but the display
//  has been left in the OFF condition.  This is a good time to turn the display back ON.
 
// Display On/Off Control instruction
    lcd_write_instruction_4d(lcd_DisplayOn);         // turn the display ON
    _delay_us(80);                                  // 40uS delay (min)
}

/*...........................................................................
  Name:     lcd_write_string_4d
; Purpose:  display a string of characters on the LCD
  Entry:    (theString) is the string to be displayed
  Exit:     no parameters
  Notes:    uses time delays rather than checking the busy flag
*/
void lcd_write_string_4d(uint8_t theString[])
{
    volatile int i = 0;                             // character counter*/
    while (theString[i] != 0)
    {
        lcd_write_character_4d(theString[i]);
        i++;
        _delay_us(80);                              // 40 uS delay (min)
    }
}

/*...........................................................................
  Name:     lcd_write_character_4d
  Purpose:  send a byte of information to the LCD data register
  Entry:    (theData) is the information to be sent to the data register
  Exit:     no parameters
  Notes:    does not deal with RW (busy flag is not implemented)
*/

void lcd_write_character_4d(uint8_t theData)
{
    lcd_RS_port |= (1<<lcd_RS_bit);                 // select the Data Register (RS high)
    lcd_E_port &= ~(1<<lcd_E_bit);                  // make sure E is initially low
    lcd_write_4(theData);                           // write the upper 4-bits of the data
    lcd_write_4(theData << 4);                      // write the lower 4-bits of the data
}

/*...........................................................................
  Name:     lcd_write_instruction_4d
  Purpose:  send a byte of information to the LCD instruction register
  Entry:    (theInstruction) is the information to be sent to the instruction register
  Exit:     no parameters
  Notes:    does not deal with RW (busy flag is not implemented)
*/
void lcd_write_instruction_4d(uint8_t theInstruction)
{
    lcd_RS_port &= ~(1<<lcd_RS_bit);                // select the Instruction Register (RS low)
    lcd_E_port &= ~(1<<lcd_E_bit);                  // make sure E is initially low
    lcd_write_4(theInstruction);                    // write the upper 4-bits of the data
    lcd_write_4(theInstruction << 4);               // write the lower 4-bits of the data
}


/*...........................................................................
  Name:     lcd_write_4
  Purpose:  send a byte of information to the LCD module
  Entry:    (theByte) is the information to be sent to the desired LCD register
            RS is configured for the desired LCD register
            E is low
            RW is low
  Exit:     no parameters
  Notes:    use either time delays or the busy flag
*/
void lcd_write_4(uint8_t theByte)
{
    lcd_D7_port &= ~(1<<lcd_D7_bit);                        // assume that data is '0'
    if (theByte & 1<<7) lcd_D7_port |= (1<<lcd_D7_bit);     // make data = '1' if necessary

    lcd_D6_port &= ~(1<<lcd_D6_bit);                        // repeat for each data bit
    if (theByte & 1<<6) lcd_D6_port |= (1<<lcd_D6_bit);

    lcd_D5_port &= ~(1<<lcd_D5_bit);
    if (theByte & 1<<5) lcd_D5_port |= (1<<lcd_D5_bit);

    lcd_D4_port &= ~(1<<lcd_D4_bit);
    if (theByte & 1<<4) lcd_D4_port |= (1<<lcd_D4_bit);

// write the data
                                                    // 'Address set-up time' (40 nS)
    lcd_E_port |= (1<<lcd_E_bit);                   // Enable pin high
    _delay_us(1);                                   // implement 'Data set-up time' (80 nS) and 'Enable pulse width' (230 nS)
    lcd_E_port &= ~(1<<lcd_E_bit);                  // Enable pin low
    _delay_us(1);                                   // implement 'Data hold time' (10 nS) and 'Enable cycle time' (500 nS)
}

The first code I posted is from the link provided here and I just adjusted the defines to match my wiring and firstly I tried the code just after adjusting the defines. It didn't worked.

Then I tried the other code I got from somewhere else, and also adjusted the defines to match my wirings and it worked.

Then I tried to add timings to the first code as they were on the second code but I can only see garbage chars on the display!

I just got to work now and only in 8 hours time I can get my hands on the hardware again to try to make it work!

I have noticed also some differences in the init routine of the LCD on both codes and I tried to change the 1st code to match the second but still no good!