AVR Freaks

I have been mean while and found the Kartman's post useful and modified it accordingly.

//
//	Co-operative multitasking framework tutorial code
//	(c)Russell Bull 2010. Free for any use.
//	Code built for a Mega168 @ 16MHz
//
//	flash two outputs (PORTB.4,PORTB.5) at different speeds - blinky#2.
//

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

void init_devices(void);
void timer0_init(void);
void reset_task(char tsk);
void set_task(char tsk);
void task_dispatch(void);
void task0(void);
void task1(void);
void task2(void);
void task3(void);
void task4(void);
void task5(void);
void task6(void);
void task7(void);
//--------------------------------------------------------------------------------------------------------------
#define Device_Write_address	0xD0	/* Define RTC DS1307 slave write address */
#define Device_Read_address	0xD1	/* Make LSB bit high of slave address for read */
int second,minute,hour,day,date,month,year;
//--------------------------------------------------------------------------------------------------------------
#define degree_sysmbol 0xdf
//--------------------------------------------------------------------------------------------------------------
#define NUM_TASKS 8
char task_bits = 0;  /* lsb is hi priority task */
volatile char tick_flag = 0;    /* if non-zero, a tick has elapsed */
unsigned int task_timers[NUM_TASKS]={0,0,0,0,0,0,0,0};                  /* init the timers to 0 on startup */
static const PROGMEM char bit_mask[]={1,2,4,8,16,32,64,128};            /* value -> bit mask xlate table */
//---------------------------------------------------------------------------------------------------------------
void RTC_Read_Clock(char read_clock_address)
{
	I2C_Start(Device_Write_address);/* Start I2C communication with RTC */
	I2C_Write(read_clock_address);	/* Write address to read */
	I2C_Repeated_Start(Device_Read_address);/* Repeated start with device read address */

	second = I2C_Read_Ack();	/* Read second */
	minute = I2C_Read_Ack();	/* Read minute */
	hour = I2C_Read_Nack();		/* Read hour with Nack */
	I2C_Stop();			/* Stop i2C communication */
}

void RTC_Read_Calendar(char read_calendar_address)
{
	I2C_Start(Device_Write_address);
	I2C_Write(read_calendar_address);
	I2C_Repeated_Start(Device_Read_address);

	day = I2C_Read_Ack();		/* Read day */
	date = I2C_Read_Ack();		/* Read date */
	month = I2C_Read_Ack();		/* Read month */
	year = I2C_Read_Nack();		/* Read the year with Nack */
	I2C_Stop();			/* Stop i2C communication */
}

void ADC_Init(){
	DDRA = 0x00;	        /* Make ADC port as input */
	ADCSRA = 0x87;          /* Enable ADC, with freq/128  */
	ADMUX = 0x40;           /* Vref: Avcc, ADC channel: 0 */
}

int ADC_Read(char channel)
{
	ADMUX = 0x40 | (channel & 0x07);   /* set input channel to read */
	ADCSRA |= (1<<ADSC);               /* Start ADC conversion */
	while (!(ADCSRA & (1<<ADIF)));     /* Wait until end of conversion by polling ADC interrupt flag */
	ADCSRA |= (1<<ADIF);               /* Clear interrupt flag */
	_delay_ms(1);                      /* Wait a little bit */
	return ADCW;                       /* Return ADC word */
}

int main(void) 
{ 
	char Temperature[10];
	float celsius;
	char buffer[40];

  init_devices();
//start at least one task here
//	Rtc time and date are displayed here
//  temperature is also displayed here
// I have selected these 2 to be here because they require constant data supply from the modules/sensors

RTC_Read_Clock(0);	/* Read clock with second add. i.e location is 0 */
sprintf(buffer, "%02x:%02x:%02x ", (hour), minute, second);
lcd_print_xy(0,0,buffer);

RTC_Read_Calendar(3);	/* Read calendar with day address i.e location is 3 */
sprintf(buffer, "%02x/%02x/%02x  ", date,month, year);
lcd_print_xy(0, 1, buffer);

lcd_print_xy(1, 0,"TEMPERATURE");
celsius = (ADC_Read(0)*4.88);
celsius = (celsius/10.00);
sprintf(Temperature,"%d%cC  ", (int)celsius, degree_sysmbol);
lcd_print_xy(1,12,Temperature);
memset(Temperature,0,10);




//set_task(7);	//task7 runs
//set_task(6);	//task6 runs

//      main loop 

  while(1)
    {
    if (tick_flag)
      {
      tick_flag = 0;
	  task_dispatch();              // well.... 
	  }
	}
  return 0;
} 
//
//	a task gets dispatched on every tick_flag tick (10ms)
//
void task_dispatch(void)
{
  /* scan the task bits for an active task and execute it */

  char task;
	

/* take care of the task timers. if the value ==0 skip it
	else decrement it. If it decrements to zero, activate the task associated with it */

  task=0;
  while (task < NUM_TASKS )
    {
    if (task_timers[task])
	   {
  	   task_timers[task]--;            /* dec the timer */
	   if (task_timers[task] == 0 )
	   		{
	    	set_task(task); /* if ==0 activate the task bit */
			}
	   }
    task++;
    }

  task = 0; /* start at the most significant task */
  while (task <= NUM_TASKS )
    {
	  if ((task_bits & pgm_read_byte(&bit_mask[task])))
	  		{
	  		break; /* if activate task found..*/
			}
      task++;         /* else try the next one */
    }
  switch(task)            /* if task bit is active..execute the task */
    {
    case 0:
      task0();
      break;
    case 1:
      task1();
      break;
    case 2:
      task2();
      break;
    case 3:
      task3();
      break;
    case 4:
      task4();
      break;
    case 5:
      task5();
      break;
    case 6:
      task6();
      break;
    case 7:
      task7();
      break;
    default:
      break;                  /* no task was active!! */
    }                       
}

// enable a task for execution
void set_task(char tsk)
{
  task_bits |= pgm_read_byte(&bit_mask[tsk]);       /* sets a task bit */
}
// disable a task from executing
void reset_task(char tsk)
{
  task_bits &= (~pgm_read_byte(&bit_mask[tsk]));  /* resets a task bit */
}

void task0(void)
{
  reset_task(0);
}
void task1(void)
{
  reset_task(1);
}
void task2(void)
{
  reset_task(2);
}
void task3(void)
{
  reset_task(3);
}
void task4(void)
{
  reset_task(4);
}
void task5(void)
{
  reset_task(5);
}
//
//	flash PORTB.4 at 2hz
//
void task6(void)
{
PORTB ^= (1<<4);
task_timers[6] = 25;		//every 250ms
reset_task(6);
}
//
//	flash PORTB.5 at 1hz
//
void task7(void)
{
PORTB ^= (1<<5);
task_timers[7] = 50;		//every 500ms  
reset_task(7);
}
//call this routine to initialize all peripherals
void init_devices(void)
{
 //stop errant interrupts until set up
 cli(); //disable all interrupts


 DDRB = 0x30;	//port 4 & 5 as outputs

 timer0_init();
 
 MCUCR = 0x00;
 EICRA = 0x00; //extended ext ints
 EIMSK = 0x00;
 
 TIMSK0 = 0x02; //timer 0 interrupt sources
 
 PRR = 0x00; //power controller
 sei(); //re-enable interrupts
 //all peripherals are now initialized
}
//TIMER0 initialize - prescale:1024
// WGM: CTC
// desired value: 10mSec
// actual value: 10.048mSec (-0.5%)
void timer0_init(void)
{
  TCCR0B &= 0B11111000; //stop
  TCNT0 = 0x00; //set count
  TCCR0A |= (1 << WGM01);	//CTC mode
  OCR0A = 0x9C; 
  TCCR0B |= (1<<CS0)|(1<<CS2) //start timer
}

ISR(TIMER0_COMPA_vect)
{
 //TIMER0 has overflowed
 	tick_flag = 1;
}

Please check for any errors I was not able to run it because I was not able to translate the timer of atmega168 to atmega32 I am using because I had recently started to learn timers of the avr. Things for Noobs like me are hard to understand at once even if they are simple

Sorry my condition is a little bit confusing to me. Codes that i can see i can understand them almost all of it but then if i try to build something i have to face a lot of problems which are termed simple clearly this shows lack of practice and you are right in a way that is why i was experimenting with the timer code since yesterday and got quite impressive results.Thanks for guiding me.

Thanks Kartman you are really a kind person that helps beginners soo much I have also worked and was able to use the buttons using the interrupts found on PD2 and PD3 as i need only two buttons..Here is the updated code.
Now i need three things:
1. Transistion of the timer part of this code from atmega168 to atmega32(clocked at 8MHz).
2. To make the outputs behave in the way i have stated below, basically i want to add long delays to the outputs.
3. To use the countdown whenever the buttons are switched ON.
Please give me suggestions and don't do it by yourself. For you guys it could be simple but i want to learn it by myself.

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

void init_devices(void);
void timer0_init(void);
void reset_task(char tsk);
void set_task(char tsk);
void task_dispatch(void);
void task0(void);
void task1(void);
void task2(void);
void task3(void);
void task4(void);
void task5(void);

//--------------------------------------------------------------------------------------------------------------
#define DS1307_WRITE_ADDR	0xD0	/* Define RTC DS1307 slave write address */
#define DS1307_READ_ADDR	0xD1	/* Make LSB bit high of slave address for read */
int second,minute,hour,day,date,month,year;
//--------------------------------------------------------------------------------------------------------------
#define DEGREE_SYMBOL 0xdf
//--------------------------------------------------------------------------------------------------------------
#define NUM_TASKS 8
char task_bits = 0;  /* lsb is hi priority task */
volatile char tick_flag = 0;    /* if non-zero, a tick has elapsed */
unsigned int task_timers[NUM_TASKS]={0,0,0,0,0,0,0,0};                  /* init the timers to 0 on startup */
static const PROGMEM char bit_mask[]={1,2,4,8,16,32,64,128};            /* value -> bit mask xlate table */
//---------------------------------------------------------------------------------------------------------------
void RTC_Read_Clock(char read_clock_address)
{
	I2C_Start(DS1307_WRITE_ADDR);/* Start I2C communication with RTC */
	I2C_Write(read_clock_address);	/* Write address to read */
	I2C_Repeated_Start(DS1307_READ_ADDR);/* Repeated start with device read address */

	second = I2C_Read_Ack();	/* Read second */
	minute = I2C_Read_Ack();	/* Read minute */
	hour = I2C_Read_Nack();		/* Read hour with Nack */
	I2C_Stop();			/* Stop i2C communication */
}

void RTC_Read_Calendar(char read_calendar_address)
{
	I2C_Start(DS1307_WRITE_ADDR);
	I2C_Write(read_calendar_address);
	I2C_Repeated_Start(DS1307_READ_ADDR);

	day = I2C_Read_Ack();		/* Read day */
	date = I2C_Read_Ack();		/* Read date */
	month = I2C_Read_Ack();		/* Read month */
	year = I2C_Read_Nack();		/* Read the year with Nack */
	I2C_Stop();			/* Stop i2C communication */
}

void ADC_Init(){
	DDRA = 0x00;	        /* Make ADC port as input */
	ADCSRA = 0x87;          /* Enable ADC, with freq/128  */
	ADMUX = 0x40;           /* Vref: Avcc, ADC channel: 0 */
}

int ADC_Read(char channel)
{
	ADMUX = 0x40 | (channel & 0x07);   /* set input channel to read */
	ADCSRA |= (1<<ADSC);               /* Start ADC conversion */
	while ((ADCSRA & (1<<ADSC)));     /* Wait until end of conversion by polling ADC interrupt flag */
	return ADCW;                       /* Return ADC word */
}

int main(void)
{ 

  init_devices();
//start at least one task here

    set_task(5);

//      main loop 

  while(1)
    {
    if (tick_flag)
      {
      tick_flag = 0;
	  task_dispatch();              // well....
	  }
	}
  return 0;
}
//
//	a task gets dispatched on every tick_flag tick (10ms)
//
void task_dispatch(void)
{
  /* scan the task bits for an active task and execute it */

  char task;

/* take care of the task timers. if the value ==0 skip it
	else decrement it. If it decrements to zero, activate the task associated with it */

  task=0;
  while (task < NUM_TASKS )
    {
    if (task_timers[task])
	   {
  	   task_timers[task]--;            /* dec the timer */
	   if (task_timers[task] == 0 )
	   		{
	    	set_task(task); /* if ==0 activate the task bit */
			}
	   }
    task++;
    }

  task = 0; /* start at the most significant task */
  while (task <= NUM_TASKS )
    {
	  if ((task_bits & pgm_read_byte(&bit_mask[task])))
	  		{
	  		break; /* if activate task found..*/
			}
      task++;         /* else try the next one */
    }
  switch(task)            /* if task bit is active..execute the task */
    {
    case 0:
      task0();
      break;
    case 1:
      task1();
      break;
    case 2:
      task2();
      break;
    case 3:
      task3();
      break;
    case 4:
      task4();
      break;
    case 5:
      task5();
      break;
    default:
      break;                  /* no task was active!! */
    }
}

// enable a task for execution
void set_task(char tsk)
{
  task_bits |= pgm_read_byte(&bit_mask[tsk]);       /* sets a task bit */
}
// disable a task from executing
void reset_task(char tsk)
{
  task_bits &= (~pgm_read_byte(&bit_mask[tsk]));  /* resets a task bit */
}

void task0(void)
{
  reset_task(0);
}
void task1(void)
{
  reset_task(1);
}
void task2(void)
{
  reset_task(2);
}
void task3(void)
{
  reset_task(3);
}
void task4(void)
{
  reset_task(4);
}
void task5(void)
{
//	Rtc time and date are displayed here
//  temperature is also displayed here
// I have selected these 2 to be here because they require constant data supply from the modules/sensors

	char Temperature[10];
	float celsius;
	char buffer[40];

    RTC_Read_Clock(0);	/* Read clock with second add. i.e location is 0 */
    sprintf(buffer, "%02x:%02x:%02x ", (hour), minute, second);
    lcd_print_xy(0,0,buffer);

    RTC_Read_Calendar(3);	/* Read calendar with day address i.e location is 3 */
    sprintf(buffer, "%02x/%02x/%02x  ", date,month, year);
    lcd_print_xy(0, 1, buffer);

    lcd_print_xy(1, 0,"TEMPERATURE");
    celsius = (float)ADC_Read(0)*4.88 / 10.0;
    sprintf(Temperature,"%d%cC  ", (int)celsius, DEGREE_SYMBOL);
    lcd_print_xy(1,12,Temperature);

    reset_task(5);
    task_timers[5] = 50;    //run twice per second
}
//
//	flash PORTB.4 at 2hz
//

    ISR(INT0_vect)//PD2
    {
	PORTD ^= (1<<PD6);		/* Toggle PIND6 */
	_delay_ms(50);  	/* Software debouncing control delay */
        //When switched on this output must turn on for 8mins.
     }

ISR(INT1_vect)//PD3
{
	PORTD ^= (1<<PD7);
	_delay_ms(50);
       //when turned on this output should turn on for 3mins
       // as you can see that is impossible to achieve using delays.
}

//call this routine to initialize all peripherals
void init_devices(void)
{
 //stop errant interrupts until set up
 cli(); //disable all interrupts

 DDRB = 0x30;	//port 4 & 5 as outputs

  timer0_init();
  GICR=0xc0;   //Enable External Interrupts INT0 and INT1
  MCUCR=0x08;  //Configure INT0 active low level triggered and INT1 as falling edge

 sei(); //re-enable interrupts
 //all peripherals are now initialized
}
//TIMER0 initialize - prescale:1024
// WGM: CTC
// desired value: 10mSec
// actual value: 10.048mSec (-0.5%)
void timer0_init(void)
{
  TCCR0  = 0; //stop
  OCR0A = 77;   //my guess is you're using 8MHz. Change to suit the actual clock rate
  TCCR0 = (1<<WGM01) | (1<<CS0) | (1<<CS2) //start timer

  TIMSK |= (1<<OCIE0);
}

ISR(TIMER0_COMP_vect)       //make sure this is correct - the compiler will complain if it's not
{
 //TIMER0 has overflowed
 	tick_flag = 1;
}

I have written the Countdown code but its not working as it never decreases the minutes and also when the seconds go to 0 they start again from 99 which is confusing as they should return with 59.

ISR(TIMER1_COMPA_vect)
{
	clock_millisecond++;
	if(clock_millisecond==1000)
	{
		clock_second--;
		clock_millisecond=0;
		if(clock_second==-1)
		{
			clock_minute--;
			clock_second=59;

			if(clock_minute==-1)
			{
				clock_hour--;
				clock_minute=59;
			}
		}
	}
}

Thanks for the precious answers you have posted really appreciate you guys..

Hello to everyone again I have been guided again and again to divide all the programming (tasks) into chunks which means to use the task_n fucntions Kartman has created. I have come a long way and learned many things here is what i have done to debounce the switches.

#include <avr/io.h>
#include <avr/interrupt.h>

typedef unsigned char	u8;

#define KEY_PIN		PIND
#define KEY0		PD0
#define KEY1		PD1

#define LED_DDR		DDRD
#define LED0		PD6
#define LED1		PD7

u8 key_state;				// debounced and inverted key state:
// bit = 1: key pressed
u8 key_press;				// key press detect

ISR (TIMER0_OVF_vect)			// every 10ms
{
	static u8;
	u8 i;

	TCNT0 = (u8)-(8000000 / 1024 * 10e-3 + 0.5);	// preload for 10ms

	i = key_state ^ ~KEY_PIN;		// key changed ?
	key_state ^= i;			// then toggle debounced state
	key_press |= key_state & i;		// 0->1: key press detect
}

u8 get_key_press( u8 key_mask )
{
	cli();					// read and clear atomic !
	key_mask &= key_press;                        // read key(s)
	key_press ^= key_mask;                        // clear key(s)
	sei();
	return key_mask;
}

int main( void )
{
	TCCR0 = 1<<CS02^1<<CS00;			// divide by 1024
	TIMSK = 1<<TOIE0;				// enable timer interrupt

DDRD = 0xf0;	// 0=In  1=In  2=In  3=In  4=Out 5=Out 6=Out 7=Out
PORTD = 0x0f;	// 0=Hi  1=Hi  2=Hi  3=Hi  4=Low 5=Low 6=Low 7=Low
	sei();

	while(1){					// main loop
		// single press

		if( get_key_press( 1<<KEY0 ))
		{
		DDRD ^= (1<<LED0);
		}

		if( get_key_press( 1<<KEY1 ))
		{
		DDRD ^= (1<<LED1);
		}

	}
}

Please tell me why this compiles without an error but doesn't toggle the outputs.

 

Another thing that I have implemented is to use a seconds downcounter which is an awesome idea, one of my earlier projects ran flawlessly due to this advice(Thanks to Kartman and David.prentice), I have found a code written by Clawson in another discussion on the site and used it as given below:-

#include <avr/io.h>
#include <avr/interrupt.h>

#include "lcd.h"

//Connection of Load
#define LOAD_DDR DDRC
#define LOAD_PORT PORTC
#define LOAD_POS PC0

//Global variable for the clock system

volatile char        clock_second=0;
volatile char        clock_minute=0;
uint32_t seconds_to_go;

void Wait(uint8_t n)
{

	uint8_t i,temp;
	temp=n*28;

	for(i=0;i<temp;i++)
	_delay_loop_2(0);
}

void LoadOn()
{
	LOAD_PORT|=(1<<LOAD_POS);
}

void LoadOff()
{
	LOAD_PORT&=(~(1<<LOAD_POS));
}
int main(void)
{

	while(1)
	{
		LOAD_DDR|=(1<<LOAD_POS);

		LoadOff();

		//Enable Pullups on Keypad

		PORTB|=((1<<PB2)|(1<<PB1)|(1<<PB0));

		int8_t min,sec; //Target Time
		min=sec=0;

		//Initialize the LCD Subsystem
		InitLCD(0);
		//Clear the display

		LCDClear();

		//Set up the timer1 as described in the
		//tutorial
		TCCR1B=(1<<WGM12)|(1<<CS11)|(1<<CS10);
		OCR1A=250;

		//Enable the Output Compare A interrupt

		TIMSK|=(1<<OCIE1A);

		//Enable interrupts globally
		sei();

		LCDClear();
		LCDWriteString("    Welcome     ");
		LCDWriteStringXY(0,1,"   Relay Timer  ");

		Wait(4);

		LCDClear();
		LCDWriteString("Set Time - 00:00");
		LCDWriteStringXY(0,1," Start     ^");

		uint8_t selection=1;
		uint8_t old_pinb=PINB;

		while(1)
		{
			while((PINB & 0b00000111) == (old_pinb & 0b00000111));

			//Input received

			if(!(PINB & (1<<PINB2)) && (old_pinb & (1<<PB2)))
			{
				//Selection key Pressed

				selection++;
				if(selection==3)
				selection =0;
			}

			if(!(PINB & (1<<PINB1)) && (old_pinb & (1<<PB1)))
			{
				//Up Key Pressed

				if(selection == 1)
				{

					//Hour is selected so increment it
					min++;

					if(min == 100)
					min =0;
				}

				if(selection == 2)
				{

					//Min is selected so increment it

					sec++;

					if(sec == 60)
					sec =0;
				}

				if(selection == 0)
				{
					//Start Selected
					break;
				}

			}

			if(!(PINB & (1<<PINB0)) && (old_pinb & (1<<PB0)))
			{
				//Down Key Pressed

				if(selection == 1)
				{

					//Hour is selected so decrement it
					min--;

					if(min == -1)
				 min =99;
				}

				if(selection == 2)
				{

					//Min is selected so decrement it

					sec--;

					if(sec == -1)
					sec =59;
				}

				if(selection == 0)
				{
					//Start Selected
					break;
				}

			}

			old_pinb=PINB;

			//Update Display

			LCDClear();
			LCDWriteString("Set Time - 00:00");
			LCDWriteStringXY(0,1," Start    ");

			//Hour
			LCDWriteIntXY(11,0,min,2);

			//Minute

			LCDWriteIntXY(14,0,sec,2);

			if(selection == 0)
			LCDWriteStringXY(0,1,">");

			if(selection == 1)
			LCDWriteStringXY(11,1,"^");

			if(selection == 2)
			LCDWriteStringXY(14,1,"^");

			_delay_loop_2(0);
			_delay_loop_2(0);
			_delay_loop_2(0);
			_delay_loop_2(0);

			_delay_loop_2(0);
			_delay_loop_2(0);
			_delay_loop_2(0);
			_delay_loop_2(0);
		}

		//Start the Load

		LoadOn();

		//Now start the timer
		clock_minute = min;
		clock_second = sec;
		seconds_to_go = ((min * 60) + sec);

		LCDClear();
		LCDWriteString("  Power Off In ");

		while(1)
		{
			clock_minute = seconds_to_go / 60;
			clock_second = seconds_to_go % 60;
			LCDWriteIntXY(4,1,clock_minute,2);
			LCDWriteString(":");
			LCDWriteIntXY(7,1,clock_second,2);

			if((clock_minute == 0) && (clock_second == 0))
			{
				//Time Out

				LoadOff();

				LCDClear();
				LCDWriteString("Load Turned Off");

				while(1)
				{
					LCDWriteStringXY(0,1,"*Press Any Key*");

					Wait(1);

					LCDWriteStringXY(0,1,"                ");

					Wait(1);

					if((~PINB) & 0b00000111)
					break;

				}

				break;

			}

			_delay_loop_2(0);
			_delay_loop_2(0);
			_delay_loop_2(0);
			_delay_loop_2(0);
		}
		//Continue again
	}
}

//The output compate interrupt handler
//We set up the timer in such a way that
//this ISR is called exactly at 1ms interval
ISR(TIMER1_COMPA_vect)
{
	--seconds_to_go;
	if(clock_second == 0)
	{
		--clock_minute;
		clock_second = 59;
	}

}

This has a problem it doesn't reach zero although i have told it to do so.

Thanks again for replying and giving me your precious time I can feel that i am very near to execute this project flawlessly.)

Thanks for the posts, by the advice of both of you, you guys  are clear that I require more practice to execute this code in a manner that i need it to behave. May be I should start with something simple next time and behave like a good newbie..By the way thank you guys for the precious time you have given , I am closing this discussion and marking Kartman's reply #4 as the solution as according to him and even I feel that that code is enough for multitasking the Avr. Thanks once again.

Thanks i will try.

Thanks again.

Anshumaan

You are absolutely correct this is what I have to do most of my time. So unfortunate but now I have the learning routine from which I can learn. Thanks to you for helping me soo much.

Anything else that I need to do to make this code (#35)running??Anyone??

Yup, you have made that sound funny I was just saying that the simulation said that the lcd received command when it was busy.

 

Yes it's correct I can vouch for that.

1. Well I am not sure what are you talking about in "1." you can explain me a little about "1."

2.And you must be talking about the time required for the lcd to process a command well I have solved that by using a good library and this works everytime but in other projects and not this one ,

so I think I must be doing something else wrong which is hidden from me .

3.

Didn't know about "1." I am a little bit confused about this , but for "2." I can refer to the datasheet of my lcd I am using (HD44780).

 

 

Ok. I will test this on my hardware today.

Yes , but I think the simulation or the hardware can tell, as far as I am concerned I cannot detect my problem hence I have asked and as you say I will create a new thread. Thanks for guiding me .