NPEducation

Understanding Timers in MSP430 Launch pad

2013-05-18T09:05:00.000-07:00

In this tutorial, I assume that you have an idea about the basic timers in 8051 or any other microcontroller. I am not going to define the timer’s definition and its applications. Here I just concentrate on programming aspects of the timers in MSP430 microcontroller.

Generally, first question arises in our mind about the timer’s is “How many timers are there in MSP430G2553”?

There are 16-bit two timers are available in MSP430G2553.

code:

A program generate 1 sec time day using Timers in MSP430 launch pad.

#include 

void Config_TimerA(void);
void Config_GPIO(void);


void main(void)
{

  WDTCTL = WDTPW + WDTHOLD; // Stop the Watch dog timer

 BCSCTL1 = CALBC1_1MHZ;
 DCOCTL = CALDCO_1MHZ;
 BCSCTL3 |= LFXT1S_2;                      // LFXT1 = VLO
 IFG1 &= ~OFIFG;                           // Clear OSCFault flag
 BCSCTL2 |= SELM_0 + DIVM_3 + DIVS_3;               // MCLK = DCO/8 , SMCLK = DCO/8
 Config_GPIO();
 Config_TimerA();
 __bis_SR_register(GIE);           // Stop DCO


 while(1);
}


void Config_GPIO(void)
{
 P1DIR = 0x01;                             // MAKE P1.0 as output port
 P1OUT = 0x00;                             // MAKE ALL pins to logic low
}

void Config_TimerA(void)
{
 // Configure the TimerA to operate with ACLK which is source from VLO (12KHz) - (TASSEL = 1) and in up mode (MC = 1)
 TACTL = TASSEL_1 + MC_1;
 CCTL0 = CCIE;  // Enable compare register interrupt in the CCTLO (capture compare control register)
 CCR0 = 12000;  // load the count 12000 in counter compare register  to generate 1 second delay (12000 * T) = 12000 * (1/12000) = 1sec;
 // T = 1/F = 1/12khz

}


#pragma vector = TIMER0_A0_VECTOR
__interrupt void Timer_A(void)
{
 CCR0 =+ 12000;
 P1OUT |= 0x01;
 _delay_cycles(1000);
 P1OUT &= ~0x01;
}

Understanding of Basic Clock System in MSP430 Launch pad

2013-05-15T22:13:00.001-07:00

A clock system is a heart of microcontroller. If we know the functioning of this heart system then it is easier to study remaining modules (like Timers, communication interface, etc.,) of the microcontroller. You people may have an idea about the clock system in 8051 and other microcontrollers, off course they are simple and easy to configure. But in MSP430 there is a highly sophisticated and accurate clock generation system is available. This clock system makes the CPU (of MSP430) may operate in different speeds and also helps to reduce the power consumption of it by operating in different low power modes. The aim of this tutorial is to make the clock system as simple as that easily understandable for the beginners.

Basically the MSP430 device contains four clock sources (oscillators) that are used to generate three different clock signals. Because the MSP430 classifies the peripherals into two categories (slow and fast) based upon their operating speeds. This categorization of peripherals is mainly to reduce the power consumption of CPU and the peripherals, i.e., high frequency operations require more power that compared with low frequency.

MSP430G2553 Clock Sources:

· VLOCLK – VERY LOW FREQUENCY – LOW POWER OSCILLATOR.

· LFXT1CLK – LOW FREQUENCY OR HIGH FREQUENCY OSCILLATOR.

· DCOCLK – DIGITALLY CONTROLLED OSCILLATOR.

· XT2CLK (optional) – HIGH FREQUENCY OSCILLATOR.

MSP430G2553 Clock signals:

· ACLK – for Slow Peripherals.

· MCLK -- to CPU and few peripherals.

· SMCLK -- for Fast Peripherals.

FIGURE 1.1 MSP430 CLOCK SYSTEMS WITH FOUR CLOCK SOURCES AND THREE CLOCK SIGNALS.

· VLO: Very low power – low frequency oscillator. It is especially for to generate low frequency signals and comes as internal feature to MSP430. It provides a frequency of 12KHz without any need of external crystal. It provides 500nA as stand by current.

· LFXT1: Low frequency or High frequency oscillator. This is operated in two modes.

o Low Frequency (LF) mode – (XTS = 0) – 32768KHz.

o High Frequency (HF) mode – (XTS = 1) – 400KHz – 16MHz.

o There is an in-built OSC-Fault mechanism available in MSP430. If OSC – fails to work then it switches to alternate clock source available in the device.

o The frequency can change by the changing the programmable capacitors present internally in the MSP430.

· DCO: Digital Controlled Oscillator – It generates a frequency range from 1MHz – 16MHz. generally beginners may like this, because it’s easy configure than compared to other.

· XT2: it is an optional high frequency oscillator similar to LFXT1 in HF mode. The frequency range is 400 KHz – 16MHz. Generally some device these optional clock sources

You can use any one of the oscillator to generate the three different clock sources based on the power and speed requirement.

· ACLK – used for slower devices and it can generate from one of either two clock sources (LFXT1 or VLO).

· MCLK – used for CPU and some peripherals. It can generate from either DCO or VLO or Low/High frequency crystals. Hence a mux is used to multiplex both oscillators as shown in the figure 1.1.

· SMCLK – used for High speed peripherals and it can generate from DCO oscillator only.

· Up on reset, MCLK and SMCLK are source from 1.1MHz DCO clock source. And ACLK is sourced from LFXT1 oscillator in LF mode with 6pF load capacitance.

· If LFXT1 fails, then the ACLK is source from the VLO oscillator as shown in the figure 1.1.

· Clock speed should match with the required operating VCC to achieve the very lower power possible otherwise unreliable execution results if Vcc < the minimum required value for the selected frequency.

Coming to the MSP430 programming, there are three special Basic Clock Control registers are available to configure the different clocks to different modules in the MSP430 microcontroller.

BASIC CLOCK SYSTEM CONTROL REGISTERS:

· BCSCTL1 – Used to ACLK frequency select (DIVAx bits) and LFXT1 mode select (LF and HF).

· BCSCTL2 – Used to select MCLK and SMCLK sources (either DCO or LFXT1 or VLO).

And also provides frequency range selection bits for MCLK (DIVMx bits) and SMCLK (DIVSx bits).

· BCSCTL3 – used to select LFXT1 oscillator frequency range.

· DCOCTL – DCO control register – used to select DCO frequency (1MHz, 4MHz, 8MHz, and 16MHz).

Status register contains some control bits (SCG0, SCG1, OSCOFF, and CPUOFF) used to enable or disable some portions of the Basic clock module and also used to configure the MSP430 operating modes.

C Program to generate 1 sec delay using low frequency oscillator (VLO). Here in this program LED blinks for every one second and also we can see the lowest frequency of operation. This can be achieved by taking the VLO oscillator which is the very low frequency oscillation (~12KHz) and divide it with maximum dividend which is 8 in this context.

Step 1: Stop the watch dog timer, to avoid unnecessary resets of the microcontroller.

We will discuss more on watch dog timer later

WDTCTL = WDTPW + WDTHOLD; // stop watch dog timer

Step 2: Select the VLO as clock source.

BCSCTL3 |= LFXT1S_2; // LFXT1 = VLO, check out theMSP430x2xx family

// user guide page number 290.

Step 3: In the basic clock system by default OFIFG (oscillator-fault flag) bit is set and force the

MCLK to use DCO as its source. But our intension is to make the MCLK should use VLO

as its source. So we need to clear the OFIFG bit.

IFG1 &= ~OFIFG; // Clear OSCFault flag

Step 4: The OSC_Fault flag takes 50 milliseconds to react, so single instruction is enough to produce

that delay since the clock speed is 12KHz. That single instruction is used to block the DCO

source for MCLK. It is better to disable the DCOCLK and this can be done by setting the

bits ‘SCG0’ and ‘SCG1’ in the status register.

__bis_SR_register(SCG1 + SCG0); // Stop DCO clock and this ‘__’ indicates that

// this instruction is an assembly level call from c language.

Step 5: Now source the MCLK with the VLO oscillator and divide the value by 8 why because

here we are trying to achieve the lowest frequency of operation in MSP430 (~ 1.5KHz)

BCSCTL2 |= SELM_3 + DIVM_3; // MCLK = LFXT1/8 = VLO/8

Step 6: Make port1 bit 0 as output, which is connected to RED LED on the LAUNCH PAD

board. This can be done by placing 1 on direction register (P1DIR)

P1DIR = 0x01; // (output – 1, input – 0)

Step 7: place zero on the P1.0 pin, to make output zero.

P1OUT = 0x00; // all port1 pins are at logic low.

Step 8: Blinking LED code using _delay_cycles() functions, this function produces delay equal to

that the number passed to that function. For example, if the operating clock frequency is

1MHz then _delay_cycles(1) produce 1microsecond delay. Likewise _delay_cycles(10)

produce 10 microseconds. In this program, we are operating with 1.5KHz, hence one

_delay_cycles(1) may take (1/1.5KHz = 0.666 milliseconds) Here one question arises that

how many delay cycles that are needed to produce 1 second with our clock source. Answer

is 1500 (1/0.66m = 1500).

While(1)

{

P1OUT = 0X01;

_delay_cycles(1);

P1OUT = 0X00;

_delay_cycles(1);

}

code:

#include  

void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop watchdog timer
  BCSCTL3 |= LFXT1S_2;                      // LFXT1 = VLO
  IFG1 &= ~OFIFG;                           // Clear OSCFault flag
  __bis_SR_register(SCG1 + SCG0);           // Stop DCO and to wait 50 milliseconds
  BCSCTL2 |= SELM_3 + DIVM_3;               // MCLK = LFXT1/8
  P1DIR = 0x01                              // make P1.0 as output and remaing all are output
  P1OUT = 0x00;                             // All P1.x reset
  
  for (;;)
  {
    P1OUT |= 0x01;                          // P1.0 set
    _delay_cycles(100);
    P1OUT &= ~0x01;                         // P1.0 reset
    _delay_cycles(1400);
  }
}

video:

IR sensor based Distance measurement system

2013-05-08T11:33:00.002-07:00

In this tutorial, I am going show how we can measure the distance over a short range using infrared sensors. Such application is very much useful in robotics, transportation, etc.,

For example, A robotic car which take diversions based upon the distance measure between the obstacle and the car. An application like, snake robot can measure the diameter of the hole and make a decision according to that. Similarly in transportation, inter-vehicular-distance is very important for a safe driving. The inter-vehicular-distance can be measured by using IR or UV rays sensors.

1. Construction:

1.1 simple IR transmitter:

The IR transmitter can be designed by using simple IR diode and a 220 ohms resistor, which is shown on the circuit diagram figure 1.

1.2 Simple IR receiver:

In this application, the main objective is to measure the distance between obstacle and the IR receiver. Due to that the analog variation of the IR receiver output is taken and then connected it to an Analog to Digital converter. Here the receiver diode and a 10k ohms resistor are connected in series between supply and ground to form a voltage divider network which is shown in the circuit diagram. The principle of operation is very simple; whenever the IR light is falls on the receiver diode, the resistance offered by the IR receiver is decreases and allow more current through it. The IR receiver offers more resistance when no IR light is falls on it. Keep in mind that both IR transmitter and receiver is connected side by side, so that the reflected light from the obstacle is easily catch by the receiver.

1.3 Analog to Digital converter connections:

The IR receiver produces different voltage variations as output, depend upon the amount of IR light is reflected back by the obstacle. By using an Analog to digital converter the analog voltage variations of the IR receiver are converted into digital values. Here I used a single channel ADC (ADC0804) which contains single input channel. The output of the IR receiver is connected to pin6 (input channel VIN (+)) of the ADC0804 IC and digital output is taken from the pin 11(LSB) to 18(MSB). And pin7 VIN (-) is connected to ground.

A clock circuit is made by using simple resistor and capacitor connected to 4^th and 9^th pins of IC, similarly an external clock can be connected instead of R and C circuit between 4 and 19^th pins of the ADC IC. Here, the product of R and C values should result 600 kHz at 5V check the data sheet, hence R = 10k and c = 150pF is used in the clock circuit. The maximum clock frequency that ADC0804 can operate at 5V is 800 kHz, whereas at 6v the clock frequency is 1200khz.

Frequency F = 1/(1.1RC).

A 10k pot is used as external reference voltage for the ADC IC, if no external reference is used then the reference voltage = VREF/2 (or Vcc/2). This is useful to adjust the step size. If the VREF = 5V (vcc) then the step size is VREF/MAXIMUM DIGITAL OUTPUT value.

Step size = 5v/255 = 19.33mV.

The internal conversion process is completed in 64 clock cycles, but 1 to 8 clock periods are used after the write pin low to high transition and before conversion starts. And also 1 clock period is taken before INTR pin goes low. Approximately the maximum conversion time taken by the ADC is equal to (t conversion = 8 clock cycles+ 64 clock cycles + 1 clock cycle = 73 clock cycles).

Therefore in this example, t conversion = 73 * 1/(606khz) = 120 microseconds.

Finally we three control pins for the ADC operation Read (2^nd pin of ADC), Write (3^rd pin of ADC), INTR (5^th pin of ADC). All these three pins are active low signals. By providing a high to low logic on the Write pin will START the conversion process. If a low to high logic will eventually set the INTR pin to high. The INTR pin is used to indicate the END of conversion process. Finally a low signal on Read pin will latch the internal converted data on to the data port of the ADC.

1.4 Steps to perform the conversion process on ADC:

· Provide a high to low logic (>200ns) on write pin to start the conversion process.

· Again provide a low to high logic on write pin to set the INTR pin to high.

· Check for INTR pin, if it is low means the conversion process is completed.

· Finally provide a logic low on the read pin, to read the converted data from the ADC.

· After all the steps are completed make read pin.

· Make sure that CS, AGND, v- and GND are grounded before performing all the above steps.

1.5 16x2 LCD interface:

The LCD connections and its interfacing programming with 8051 is already discussed on this website. Therefore, here I encourage you to read the related topics on LCD provided in this site.

Here is URL: “http://www.npeducations.com/2012/08/8051-based-16x2-lcd-interfacing-in-8.html”.

1.6 Ciruit Diagram for IR sensor based Distance measurement system:

Figure1 Ciruit Diagram for IR sensor based Distance measurement system

Note: 1. White color reflects more IR light than any other colour
2. One major problem with the IR distance measure is going below the minimum sensor range means an object is so close the sensor cannot get an accurate reading. And this theory is better explained in the URL http://www.societyofrobots.com/sensors_sharpirrange.shtml

1.7 software code:

/******************************************************************************************************************************/
// http://www.npeducations.com
// IR_Distance_Measurement.c - measuring the obstacle distance using infrared sensors. the output will show the distance upto 9 cm, the video is taken during testing
// so don't confuse with the video output.
// Author - lovakiranvarma, M.tech
/******************************************************************************************************************************/
#include

#define LCD_PORT P2 
#define ADC_DATA P1

// function prototypes
void converttochar(void);
void lcd_data_string(unsigned char *);
void delay(unsigned int );
void lcd_cmd(unsigned char );
void lcd_data(unsigned char );
void LCD_Init(void);

// LCD control pins declaration
sbit RS = P3^7;     // Register Select line
sbit RW = P3^5;  // Read/ADC_WRITEite line
sbit ENABLE = P3^6; // Enable line

// ADC control pins declaration
sbit ADC_READ= P3^0;
sbit ADC_WRITE= P3^1;
sbit ADC_INTR= P3^2;

int value1=0;

void main()
{
ADC_DATA = 0xff; // make P1 as input port
LCD_PORT = 0x00; //make P2 as outport

LCD_Init();
lcd_cmd(0x85);  // Setting cursor location at 5th position of the first line
delay(2);

lcd_data_string("IR BASED DISTANCE MEASURE");
delay(100);
lcd_cmd(0x01);
delay(5);
lcd_cmd(0x80);
delay(5);
lcd_data_string("DISTANCE:");
while(1)
{
  delay(5);
  ADC_READ=1;
  ADC_WRITE=0;  // make WRITE to high to low for start of conversion
  delay(5);
  ADC_WRITE=1;
  while(ADC_INTR==1); // check for END of conversion
  ADC_READ=0;         // read the converted digital data form the ADC port
  value1=ADC_DATA;
  delay(5);
  ADC_INTR=1;
  converttochar();
}
}



void LCD_Init()
{
lcd_cmd(0x38);  //2 Line, 5X7 Matrix
delay(5);
lcd_cmd(0x0E);  //Display On, CuRSor Blink
delay(5);
lcd_cmd(0x06);
delay(5);
lcd_cmd(0x01);  // Clear Screen
delay(5);
}

void lcd_cmd(unsigned char Command) // LCD Command Sending Function declaration
{
LCD_PORT = Command;
RS= 0;
RW=0;
ENABLE = 1;
delay(1);
ENABLE = 0;
return;
}

void lcd_data(unsigned char data_value)  // LCD data Sending Function declaration
{
LCD_PORT = data_value;
RS= 1;
RW=0;
ENABLE = 1;
delay(1);
ENABLE = 0;
return;
}

void lcd_data_string(unsigned char *string) // LCD Command Sending String declaration
{
int i=0,j=0;
while(string[i]!='\0')
{
 if(i>=9)
 { 
  // If the number of characters in the string > 16, then the below command automatically 
 lcd_cmd(0xc0+j++);  // Shift the display right side 
 }
  lcd_data(string[i]);
  i++;
  delay(2);
}
return;
}

void converttochar()
{
int M;

M=value1/100;
M=M/10;
value1=value1%100;
value1=value1%10;

lcd_cmd(0x8a);
if(M!=0)
lcd_data(M+48);
else
lcd_cmd(0x06);
M=value1/10;
value1=value1%10;
lcd_data(M+48);
lcd_data(value1+48);
lcd_data(' ');
delay(5);
}

void delay(unsigned int DELAY_VALUE ) // delay function
{
int i ,j ;
for(i=0;i<=DELAY_VALUE;i++)
  for(j=0; j<1000 data-blogger-escaped-j="" data-blogger-escaped-pre="">

Interfacing 16x2 character LCD display with MSP430 Launch pad

2013-05-06T10:08:00.001-07:00

Interfacing 16x2 character LCD display with MSP430 Launch pad is quite simple. You just need a separate 5V power supply to drive the LCD. One of the main advantages of MSP430 Launch pad is its in-built debugging feature and its pin configuration. In this tutorial, I am not going to start from the scrap of LCD. But I encourage you to read my previous tutorials about introduction to LCD and its interfacing to microcontroller, where you can find the LCD commands, LCD functions, LCD interface mechanism etc. In this post, I just show the connections between the LCD and MSP430 Launch pad, A test program to display a string of characters on it, and finally a small video is presented in which output of the program is shown.

1. Construction:

Generally 16x2 character LCD displays requires eight data lines, three control lines (RS, EN, R/W) and 5v power supply and common ground. Here the microcontroller belongs to MSP430 family which runs worth 3.3v USB power supply. But the 16x2 LCD requires 5v power supply which should be provided separately. Generally, when we interface the same LCD with 8051 microcontroller there is no need of separate power supply. Why because both LCD and 8051 microcontroller works with the same 5v supply.

A small important note for you “don’t use USB power supply taken from MSP430 launch pad for LCD display” which may damage your pc USB port, so be careful about that.

All the data lines of the LCD are connected to Port 2 pins of the MSP430G2553 microcontroller and the control lines connected to Port1 pins (RS - P1.6 and EN - P1.7). Another more import thing is that connect the ground pin MSP430 Launch Pad with LCD ground pin in order form the closed loop circuit. If you won’t connect the two grounds, then you notice some garbage characters appear on the LCD display while executing the program. One more important point in this tutorial that I connected the R/W pin of the LCD to ground, because I am not performing read operation on LCD, just write operation only. For write operation the LCD R/W pin should be connected to the ground.

2. Circuit Diagram to interface 16x2 LCD with MSP430 microcontroller:

Circuit Diagram to interface 16x2 LCD with MSP430 microcontroller

Note:

1. Don’t use USB power supply for LCD display which is taken from the MSP430 launch pad board. Otherwise your pc USB port may damage by drawing more current from it.

2. Join MSP430 launch pad ground point with LCD ground pin in order to form a closed circuit. Otherwise garbage characters will display.


/******************************************************************************************************************************/
// http://www.npeducations.com
// MSP430_LCD.c 
// Author - lovakiranvarma, M.tech
/******************************************************************************************************************************/

#include  "msp430g2553.h"
#include  "stdio.h"
#include  "string.h"
#include "stdlib.h"
#define delay_value 500

void LCD_Init(void)
{
 send_cmd(0x38);   // configure LCD as 2 lined 5x7 matrix
 delayms(delay_value);
 send_cmd(0x0E);   //display on, cursor blink
 delayms(delay_value);
 send_cmd(0x06);  // auto increment of cursor
 delayms(delay_value);
 send_cmd(0x01);  // clear display
 delayms(delay_value);

}

void send_cmd(unsigned char command)
{

 P1OUT &= 0X00;
 P2OUT &= 0X00;
 P2OUT = command;
 P1OUT &= 0X00;
    P1OUT &= ~0x40;                        // RS = 0 for command, P1.6 0x40
    //RW is grounded
    P1OUT &= ~0x80;                        //EN = 0, P1.7, 0x80
    delayms(delay_value);
    P1OUT |= 0x80;                        // EN = 1, P1.7, 0x80
    delayms(delay_value);
    P1OUT &= ~0x80;                        //EN = 0, P1.7, 0x80
    delayms(delay_value);

}

void send_char(unsigned char character)
{
 P1OUT &= 0X00;
 P2OUT &= 0X00;
 P2OUT = character;
  // P1OUT &= 0x00;
     P1OUT |= 0x40;                        // RS = 0 for command, P1.6
   //  RW is grounded
     P1OUT &= ~0x80;                        //EN = 0, P1.7
     delayms(delay_value);
     P1OUT |= 0x80;                        // EN = 1, P1.7
     delayms(delay_value);
     P1OUT &= ~0x80;                        //EN = 0, P1.7
     delayms(delay_value);
}


void send_string(char *String)
{
unsigned char i=0;

 while(String[i]!='\0')
 {

  P1OUT &= 0X00;
  P2OUT &= 0X00;
  P2OUT = String[i];
  P1OUT |= 0x40;                        // RS = 0 for command, P1.6
     //  RW is grounded
  P1OUT &= ~0x80;                        //EN = 0, P1.7
  delayms(delay_value);
  P1OUT |= 0x80;                        // EN = 1, P1.7
  delayms(delay_value);
  P1OUT &= ~0x80;                        //EN = 0, P1.7
  delayms(delay_value);
  if(i>=16)   // If the number of characters in the string > 16, then the below command automatically
  send_cmd(0x18);  // Shift the display right side
  delayms(40000);   // 100 millisec delay
  i++;
 }

}





void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
  BCSCTL1 = CALBC1_1MHZ;                    // Set DCO
  DCOCTL = CALDCO_1MHZ;
  BCSCTL2 &= ~(DIVS_3); //This line of code ensures that the SMCLK divider is 0,
   // so we have SMCLK=DCO=1MHz (in fact if we are to have a /8 divider, it should be BCSCTL2 |= DIVS_3;).


  P1DIR = 0xFF; // make P1 as output
  P2DIR = 0xFF; // make P2 as output


  P2SEL = 0;  // These two are "Function Select Registers PxSEL and PxSEL2",
  P2SEL2 = 0; // If both are zero's means simple I/O function is selected.



  P1DIR |= 0x01;                            // Set P1.0 to output direction
  P1REN |= 0x01;


   delayms(1500); // wait for more than 15ms after supply rises to 4.5V
   send_cmd(0x30);
   delayms(400);  // wait more than 4.1ms
   send_cmd(0x30);
   delayms(100);  // wait more than 100us, but delayms(1) will provide 1ms
   send_cmd(0x30);
   delayms(100);
   send_cmd(0x02); // return to home
   delayms(100);


  LCD_Init(); // LCD initialization

       
   while(1)
   {

   send_cmd(0x01);  // clear display
       delayms(delay_value);
       send_cmd(0x81);  // clear display
       delayms(delay_value);
       send_string("NPEDUCATIONS");
       delayms(delay_value);
   send_cmd(0xC0);  // clear display
       delayms(delay_value);
       send_string("http://www.npeducations.com");
       delayms(delay_value);
   }

}

You tube video:

Interfacing 4x3 keypad with 8051 Microcontroller

2013-05-05T07:59:00.000-07:00

Basically, the 4x3 keypad contains push buttons that are arranged in four rows and three columns produce twelve characters as shown in the figure1.Sometimes this called as “4x3 switch matrix” due to the arrangement of switches in a matrix form. The internal construction of these keypads includes metal dome contacts and conductive rubber. Ok! Construction of keypad is out of scope the tutorial. In this tutorial I am only concentrating on interfacing of keypad with 8051 microcontroller.

1. CONNECTIONS:

The three column lines of the keypad as shown in the figure 1 are connected to the PORT 1 upper pins (P1.0 – COL1, P1.1 – COL2, P1.2 – COL3) and the four row lines are connected to PORT1 lower pins (P1.4 – ROW1, P1.5 – ROW2, P1.6 – ROW3, P1.7 – ROW7). Three resistors of 10k are connected between the column lines and power supply, to make the column lines are always high. Here one thing should be clear, that the column lines connected to the microcontroller should act as input lines and the row lines acts as output lines.

2. WORKING:

2.1 INITIALIZATION:

Remember that, the column lines of keypad are connected to port1 pins and these pins should be configured as input by placing logic high (‘LOGIC 1’) during port initialization. Similarly, the row lines of keypad are connected to port1 pins and configured them as output by placing logic zero (‘LOGIC 0’) during port initialization.

ROW1 = 0; //MAKE ALL ROW LINES OF KEY TO ZERO

ROW2 = 0; // TO MAKE THEM AS OUTPUT LINES

ROW3 = 0;

ROW4 = 0;

COL1 = 1; // MAKE ALL COL'S AS HIGH

COL2 = 1; // TO MAKE THEM AS INPUT LINES

COL3 = 1;

2.2 SCANNING MECHANISM:

The scanning mechanism starts by making the first row (ROW1) of keypad to LOW (LOGIC ‘0’) and all column lines should be high (LOGIC ‘1’). Now check any one of the column lines goes low. If any column line goes low means that particular button is pressed, otherwise nothing is pressed.

Now the question in our mind is “which button is pressed”. This can be identified by checking which column is goes low.

If ROW1 = 0, COL1 = 0, remaining all lines are high means BUTTON1 is pressed.

If ROW1 = 0, COL2 = 0, remaining all lines are high means BUTTON2 is pressed.

If ROW1 = 0, COL3 = 0, remaining all lines are high means BUTTON3 is pressed.

If ROW2 = 0, COL1 = 0, remaining all lines are high means BUTTON4 is pressed.

Likewise we can identify the remaining buttons also and the logic is shown in the figure1. This can be done by repeatedly, that why use a infinite loop in the routine “key()” – check out the c program.

Figure1 shows the keypad connection and its logic to interface with MCU.

3. PROGRAM DESCRIPTION:

Firstly create an 2-D array (look up table) of numbers like below. This array holds the numbers represented by the keypad. Off course you can change the data as you need, means you define characters, special symbols, numbers, etc..,

char keypad[4][3]= {

'1','2','3',

'4','5','6',

'7','8','9',

'*','0','#'

}; //look up table

Now in the subroutine “key()”, first make first row lines to zero one and scan for the column status. And next make the next row and scan for the column and so on.

ROW1 = 0; //MAKE FIRST ROW IN KEYPAD TO ZERO

ROW2 = 1;

ROW3 = 1;

ROW4 = 1;

COL1 = 1; // MAKE ALL COL'S AS HIGH

COL2 = 1;

COL3 = 1;

If any one of the column line is low then wait until it back to logic high by continuously checking the col line (while(COL1 == 0)). If col line goes high then place column and row values to get the correct value from the keypad array. Finally place a break statement to get out of the loop, otherwise it stay in infinite loop.

if (COL1 == 0){while(COL1 == 0);row=1;col=1;break;}.

For LCD interface I encourage you to read the tutorial to interface 16x2 LCD with 8051.

Circuit Diagram of 4x3 keypad interface with 8051 along with 16x2 LCD.

Figure2 shows the circuit diagram for 4x3 keypad interface with 8051 along with LCD

4. Keypad interface code:

#include
#include
#include "LCD.h"

sbit COL1=P1^0;
sbit COL2=P1^1;
sbit COL3=P1^2;

sbit ROW1=P1^4;
sbit ROW2=P1^5;
sbit ROW3=P1^6;
sbit ROW4=P1^7;

unsigned char ROW=0,COL=0;
char value='\0', temp=0;
char keypad[4][3]=	{	'1','2','3',
				'4','5','6',
				'7','8','9',
				'*','0','#' };	  //look up table

char key(void);
void main(void)
{	
	P2 = 0x00;
        ROW1 = 0; //MAKE ALL ROWs IN KEYPAD TO ZERO
        ROW2 = 0;
	ROW3 = 0;
	ROW4 = 0;		
	COL1 = 1; // MAKE ALL COL'S AS HIGH
	COL2 = 1;
	COL3 = 1;

       LCD_init();

	while(1)
	{
		send_cmd(0x01);
		delayms(50);
		send_cmd(0x80);
		delayms(50);
		send_data("Enter keys....");
		delayms(600);
		send_cmd(0x01);
		delayms(50);
		send_cmd(0x80);
		delayms(50);
		while(1)		
		{
			value =  key();
			delayms(50);				
			send_char(value);
			delayms(100);
		 }
	}

} 

char key()
{
	
	while(1)
	{

		ROW1 = 0; //MAKE FIRST ROW IN KEYPAD TO ZERO
		ROW2 = 1;
		ROW3 = 1;
		ROW4 = 1;		
		COL1 = 1; // MAKE ALL COL'S AS HIGH
		COL2 = 1;
		COL3 = 1;
		if(COL1 == 0){while(COL1 == 0);ROW=1;COL=1;break;}  
		if(COL2 == 0){while(COL2 == 0);ROW=1;COL=2;break;}  
		if(COL3 == 0){while(COL3 == 0);ROW=1;COL=3;break;}  
		ROW1 = 1; 
		ROW2 = 0; //MAKE SECOND ROW IN KEYPAD TO ZERO
		ROW3 = 1;
		ROW4 = 1;		
		COL1 = 1; // MAKE ALL COL'S AS HIGH
		COL2 = 1;
		COL3 = 1;
		if(COL1 == 0){while(COL1 == 0);ROW=2;COL=1;break;}  
		if(COL2 == 0){while(COL2 == 0);ROW=2;COL=2;break;}  
		if(COL3 == 0){while(COL3 == 0);ROW=2;COL=3;break;}
		ROW1 = 1; 
		ROW2 = 1; 
		ROW3 = 0;//MAKE THIRD ROW IN KEYPAD TO ZERO
		ROW4 = 1;		
		COL1 = 1; // MAKE ALL COL'S AS HIGH
		COL2 = 1;
		COL3 = 1;
		if(COL1 == 0){while(COL1 == 0);ROW=3;COL=1;break;}  
		if(COL2 == 0){while(COL2 == 0);ROW=3;COL=2;break;}  
		if(COL3 == 0){while(COL3 == 0);ROW=3;COL=3;break;}
		ROW1 = 1; 
		ROW2 = 1; 
		ROW3 = 1;
		ROW4 = 0;//MAKE 4TH ROW IN KEYPAD TO ZERO		
		COL1 = 1; // MAKE ALL COL'S AS HIGH
		COL2 = 1;
		COL3 = 1;
		if(COL1 == 0){while(COL1 == 0);ROW=4;COL=1;break;}  
		if(COL2 == 0){while(COL2 == 0);ROW=4;COL=2;break;}  
		if(COL3 == 0){while(COL3 == 0);ROW=4;COL=3;break;}
		delayms(500);
	}

	return	keypad[ROW-1][COL-1];
}

Inter-Vehicle Communication for Safety Driving

2013-04-24T10:41:00.000-07:00

In Highways and Streets, traffic is increasing in exponential manner, so that accident rates also increases. According to the World Health Organization, road traffic injuries lead to an estimated 1.26 million deaths worldwide. The main reasons for these traffic accidents are due to reckless driving of drivers or vehicle owner (Driver behavior) who doesn't maintain necessary distance between vehicles, drunken drivers, over taking, traffic rules violation, break failure, poor roadway maintenance, and Hazard visibility (failed to Look properly). Collision of four wheel vehicles and other big vehicles lead to more death rate than compared with other small vehicles.

To avoid such accidents, it is necessary to maintain certain distance between vehicles – “Inter-Vehicular Distance”. A warning system should be employed inside the vehicle, so that the vehicle could sense the distance between other vehicles and intimate to driver. And this warning systems will also shows presence of other vehicles around it with their speeds and other necessity information. This system also provides information regarding any Hazard conditions (Brake failure, door lock failure, etc) happened inside the vehicle body.

In order to maintain minimum distance between vehicles, each vehicle is employed with some distance measure sensors (Infrared based or ultra-sonic sensors). Sensors send information to a graphical LCD via controller. Not only distance, has LCD also displayed the fuel consumption, speed of the vehicle, brake failure status, etc. Each vehicle shares this information to other vehicles and vice versa by using an Ad-hoc wireless network. In this project, ZIGBEE/ blue-tooth based wireless Ad-hoc network will be used for Inter- Vehicular communication.

Block Diagram

Inter-Vehicle Communication for safety driving

Digital Stethoscope for digital doctors

2013-01-25T09:38:00.001-08:00

Stethoscope has been used for many years, and has been very effective to diagnose certain cardiologic and pulmonologic sounds. For many years healthcare professionals would listen quietly to patients internal organs so they could diagnose from specific sounds of such internal organs. The problems faced with the ordinary stethoscope are:

ü Two other sounds (s3&s4) which also exist along with the two classic sounds (lub & dub) cannot be detected by the graphical recording.

ü Does not allow early detection of heart diseases.

ü Does not provide graphical plot of the heart sound with respect to time.

ü Permanent record of analysis cannot be maintained.

The objective is to develop a peripheral interface controller based digital stethoscope to capture the heart sounds. The proposed designed device consists of the following hardware stages:

ü Front-end pickup circuitry

ü microcontroller

ü graphical display

ü Serial EEPROM

The software time and frequency domain analysis of the heart sound is done using MATLAB. A digital stethoscope would help healthcare professional record their findings on a serial EEPROM. Once the data is stored, the healthcare professionals can hear and plot the graph. This would be a quick and more effective since there is a visual and audio representation to diagnose such cardiologic sounds.

Voice based electronic guidance system for visually impaired (Blind) people

2013-01-22T20:30:00.000-08:00

Blind people cannot detect what are the obstacles in front of them. Because of this, there is a chance to misshapenness such as automobiles collisions, obstacles, and accident that leads to great loss of human lives and can have disastrous results. To avoid this, it is better to have a another person with them to guide about the obstacles. But this is not possible in all cases, so blind people faces lot of problems while moving on a road, at home or at offices. In this fast moving world, no one spares time to help other people like blind people or don’t even think about them. But for these visually impaired people, there is always need an assistant to them while moving on roads or any other places.

The solution for the above mentioned problems for blind people is to have a guiding assistant while moving on roads or any other places. It is also mentioned that a human guiding assistance is not always possible in this busy world. The alternative solution for the above specified problem is to have an electronic guidance system and it should be voice enabled. This electronic guidance system is generally placed on a walking stick, whenever it detects any obstacle comes near to the blind people who carries this stick the obstacle sensor (ultrasonic) will detect and intimate it to them with a predefine voice. Working principle of this electronic guidance system is simple, firstly the ultrasonic sensor is used to detect obstacles and the ADC will convert the analog variations into digital. This digital data is given the 8-bit microcontroller for processing. A voice based chip is connected to the microcontroller and based on the obstacle sensor data the microcontroller will send commands to voice based chip which in turn pronounce the commands via a speaker connected to it. In this way, the electronic guidance system will help the blind people and protect them from obstacle in front of them.

The technology is used in this project is mainly ultrasonic sensor is used to detect obstacle in front of it and APR9600 voice based chip which is used to pronounce some predefined voice commands through a simple speaker. The 89S52 microcontroller or any other suitable microcontroller will provide interface between the ultrasonic sensor and the voice enabled chip.

Block Diagram:

Block diagram for Voice based electronic guidance system for visually impaired (Blind) people

GAS LEAKAGE ALERT AND PROTECTION SYSTEM

2013-01-21T12:57:00.001-08:00

In the past few decades, there are many disasters had taken place due to the leakage of poisonous gas from different chemical industries. There are so many people died who live in the premises of chemical industries due to these poisonous gases leakage suddenly. Not only that, these toxic gases may pollute the earth atmosphere, which in turn effect environment and is not good for animals lives in water, earth, etc., Leakage of gas from the industry pipelines and containers also cause revenue loss for the industries.

In this project, a solution is provided for the above mentioned problems. An automatic gas leakage detector is proposed to detect any leakage in gas pipelines in industries and also in group of houses if any leakage occurs it will detect and it protect from that leakage. Whenever the gas sensor detects any gas leakage in pipelines or at homes, the device will immediately alert the people who live in surroundings by using siren. Before the advent of this project, alert system is in the OFF state, i.e., shown through an exhaust fan. Whenever the gas leakage is detected by the sensor then immediately the siren is played and the power is shut down i.e., the bulb status is off, and simultaneously the exhaust fan is ON until and unless gas leakage is not detected. Therefore this system is useful where human errors are possible.

The entire control circuit for this project is designed by using any suitable microcontroller. But here for the simplicity 8-bit microcontroller (89S52) is used. A gas sensor is interfaced to 89S52 microcontroller via an Analog to Digital converter. A buzzer is also interface to the microcontroller which acts as a siren when the leakage is detected. A DC motor is also interfaced to 89S52 microcontroller to represent the exhaust fan which will on when gas leakage is detected.

Block Diagram:

Block Diagram for GAS LEAKAGE ALERT AND PROTECTION SYSTEM

Railway Track - Crack Detection Robot

2013-01-20T11:38:00.004-08:00

There are many times and in many areas cracks will occur on railway track due to bad weather conditions, floods, cyclone, and earthquake. Not only had these climatic conditions, cracks on railway track occur due to the aging of railway track and intruders may damage the track for their benefits. A small crack on railway track will lead to a big disaster because thousands of people travelling a train. So the railway track-crack inspection is a challenging work and it should be more precise. The regular manual track-crack inspection team (or railway track maintenance team) will check each and every railway track manually and update the status to the railway authority which in turn sends the information to corresponding trains. The manual inspection method is a more time consuming and team may fail to update the information in time in some real time situations. Checking each and every track manually for cracks is a very tedious job, due to this, railway workers may show some laziness during crack inspection and may fail to inspect the railway track properly and precisely.

For the above mentioned problems, the solution should be automatic and precise. A crack detection robot will fulfill the above requirement which is automatic and precise one. A crack detection robot may use any sort of sensor technology to detect the crack on the railway track. This robot will continuously travels along the railway track and monitors about the cracks on it. If any crack is observed by the robot, it will immediately send the information to railway authority people about the location via any wireless medium. And the railway authority people will immediately respond and may further intimate to trains. This robot also marks the crack place and stores the co-ordinates of the crack position in memory. This feature is very much helpful for maintenance team to locate crack position easily.

In this project, LDR and white LED light source are used as sensor technology to detect the cracks on railway track. A track follower robot is designed and implemented with 89S52 or any suitable microcontroller as its control circuit. A Zigbee or any wireless medium which is operated with battery is used to transfer information to railway authority. A simple robotic hand is used to mark the crack position which is automatically controlled by the robot control circuit. A GPS module is integrated to the robot control circuit to track the crack position co-ordinates and stored in memory, which is very helpful during maintenance of the railway track.

Block diagram:

Block diagram for Railway Track - Crack Detection Robot

AUTOMATIC ELECTRICAL APPLIANCES ON/OFF CONTROL USING BIDIRECTIONAL VISITOR COUNTER

2013-01-19T11:21:00.001-08:00

Now a days people are wasting electrical power in home or offices due to their negligence and laziness. For example when all staff left the office, they won’t bother about the electrical appliances (like FAN, lights, AC, etc.,), whether appliances are switched off or not. Here office management maintains a person to monitor the all electrical appliances and switch off them when there is no person in the room to reduce power usage and also to reduce electricity bill. Most of electricity wastage happens in homes and offices. Wastage of Electricity will affect the environment directly or in directly. It will show effect on non-renewable resources, which are sweeping out from the earth for the need of mankind. Not only that, unnecessary usage of electrical appliances will increase the earth surface temperature.

In order to control this electricity wastage we must have an automatic power control device which will monitor the number of persons count in the room and operate the electrical appliance according to that. The mechanism to count the number of persons entering and leaving is done through a sensor circuit. There are two sensor circuit are placed inside (A) and outside (B) of the door. When a person crosses the sensor circuits ‘B’ first and then ‘A’ means that the he enters in to the room. Similarly, if a person crosses the sensor circuits ‘A’ first and then ‘B’ means that the he left the room. According to this mechanism the device will maintains the count about the person in a room. If the count is zero, the device will automatically switch off the electrical appliance in the room. In this way, the wastage of the power can reduce. This project uses two sensor circuits for the bidirectional count; hence this project is titled as “AUTOMATIC ELECTRICAL APPLIANCES ON/OFF CONTROL USING BIDIRECTIONAL VISITOR COUNTER”.

In this project the sensor circuits can be implemented by using any type of sensors like infrared (IR), LASER or Ultrasonic sensors. But for the cost factor IR sensors are used as bidirectional visitor counter. The IR transmitter always transmits the IR rays and the IR receiver should be placed in such a way that the IR rays from transmitter should fall on it. The circuit always sends a logic high signal to the microcontroller (89S52) circuit when there is IR rays falls on receiver. If the receiver finds the break in the IR rays (i.e. when a person crosses it) then the receiver circuit will produce a logic low signal on the microcontroller interrupt pin. Now the microcontroller will update the count based on sensor circuit crossing and it will displayed on to 7-segment display.

Block Diagram:

Block Diagram for AUTOMATIC ELECTRICAL APPLIANCES ON/OFF CONTROL USING BIDIRECTIONAL VISITOR COUNTER

A car with I Vision

2013-01-18T09:29:00.001-08:00

Now a days technology growing drastically and providing solutions to so many new and existing problems. But still there are some problems in real life which may cause loss of life like road accidents. The main reasons of road accidents are due to traffic rules violation, rash driving, break failures, health condition of the driver, alcoholic drivers, etc. If vehicle ‘A’ over taking the vehicle ‘B’ without following the traffic rules suddenly, then the person in the vehicle ‘B’ may not react suddenly and confused to lead to accidents. These cases are directly shows impact on human life. For middle class people it also shows impact on vehicle property, money, time, etc.,

To providing a solution for the above discussed problems a new intelligent system should be embedded in a car. The system should be designed in such a way that it automatically overrides the manual driving of the car when abrupt changes occur in the traffic. It always monitors the minimum distance between two vehicles and according to that it will control the vehicle speed and direction. Hence the vehicle may free from the accidents.

In this project, arrays of sensors (may be infrared or ultrasonic) are used to monitor the distance between each vehicle. The control system designed by using 89S52 micro controller will process the sensed information and will transmit it to the car control mechanism. Therefore the micro controller circuit will overrides the manual driving of the car and controlled it automatically. The minimum distance between vehicles shown in LCD and also warns the driver if he crosses the minimum distance between vehicles.

Block Diagram:

Block diagram for A car with I vision

Remote Vehicle monitoring and guiding system using 8051

2013-01-17T10:28:00.001-08:00

From last decade, the traffic density is increased largely in urban areas. Due to the traffic congestion, travelling has become very time consuming, and this is a problem as man cannot afford to spend a lot time travelling. Damaged roads in rainy seasons, weak bridges, roads blocks, etc., are the some of the cases where the travelling time increases. The travelling time is more important factor for vehicles which carries goods for an organization. If goods are not delivered in time, organization itself finds revenue loss in millions. Travelling time is also a tedious factor for emergency vehicles like ambulance, government vehicles, etc.

From above described problems, a vehicle needs a proper route guiding system, which may reduce the travelling time. In this project, a remote route guiding system which tracks each and every vehicle and locates it on the Google maps, and also remote monitoring station monitors the status of traffic density, road health in rainy seasons, weak bridges from different sources like FM radio, TV news, etc., and update it to the vehicles. So that vehicles follow the guiding information sent by remote monitoring system and may reach the destination in time.

The tracking system is designed by using GSM and GPS technologies with a 89S52 microcontroller based control system. A java software resides in PC may track the location on Google maps according to the coordinates sent by the vehicle. Again the status about the traffic density, road blocks, etc., is updated by using GSM to vehicles and displays the information on 16x2 LCD display. In this project speed controlling is also added to the vehicle.

Block diagram:

Block Diagram for remote vehicle monitoring and guiding system

SMS BASED INNOVATIVE WEATHER REPORT INFORMATION SYSTEM

2013-01-16T11:15:00.001-08:00

In the present world, the weather report information is more important in various fields like agriculture, marine, air traffic, forestry, transportation etc. Due to the lack of proper information regarding changes in the weather, the people in these fields are facing many problems. If the people know about the weather condition before, they will take necessary precaution and cares in respected fields. The different techniques used in making weather reports are complex and it is difficult to measure the weather parameters manually. There may be the possibility of errors also due to the manual measurement.

The people in the present world are mostly fascinated towards automatic systems. Even this weather information can be automatically received as an SMS. This also provides solution to various problems mentioned earlier. This SMS based weather report information system can measure different weather parameters like room temperature, light, humidity in a locality. By this the people can be made aware of the changes in the weather conditions by receiving an SMS.

This project consists of mainly two phases i.e., Data monitoring and Data transferring. In the first phase, the Sensors are used to sense and measure weather parameter values and the LCDs are used to display the values of different parameters. In the second phase, the parameter’s values are sent to a location in the form of an SMS by interfacing a GSM modem to a microcontroller depend upon the user request. GSM interface is one of the main features of the project in which various data like value of parameters, date and time are sent by an SMS. Through this system, the obtained values are more accurate when compared to manual measurement. This system also extended to user registration facility, and sent the weather information to all the users whose register to this weather information system.

BLOCK DIAGRAM:

BLOCK DIAGRAM: SMS BASED INNOVATIVE WEATHER REPORT INFORMATION SYSTEM

HEAD MOTION CONTROLLED POWER WHEEL CHAIR FOR PHYSICALLY DISABLED PERSONS

2013-01-15T08:06:00.001-08:00

A person whose spinal cord is injured or whose legs are paralyzed cannot move on his own without the assistance of other person. These kinds of people prefer to move their body under their own command. This is possible by using power wheel chairs which can be controlled automatically.

Power wheel chairs can be controlled using different mechanisms. Earlier, the systems used, just control the movement of the wheel chair automatically by using the keypad alone. It does not detect the object opposite to it and should be operated using hands. The second mechanism involves controlling the wheelchair with a controller that lies in the mouth. This is very difficult for the user while talking and eating. Third mechanism the person should blow or suck air through tubes placed in his mouth. But all these mechanisms are expensive and complex for the patient to perform. These are the drawbacks of the existing system.

The proposed system rectifies the above mentioned difficulties. It operates just by tilting the head. The head motion could be left, right, forward, and backward or stopped. The accelerometer implanted on the head provides different signals based on the motion of the head. These signals are processed by the microcontroller and the motor is operated based on the microcontroller outputs. This system can also detect obstacles using obstacle sensor and can avoid motion when obstacles are encountered. In order to activate this device a voice based control is placed along with motion control system. The start and stop voice commands processed by the voice based control system and according to those commands these the motion control will activates or deactivates.

*This project mainly consists of accelerometer, ADC, microcontroller, motor driver circuits, motor, power supply units and obstacle sensors.

BLOCK DIAGRAM:

Block diagram

Automatic Accident detection and messaging system using GSM & GPS services

2013-01-14T04:28:00.002-08:00

Now a day’s accident occurs more frequently. Because of these accidents many of the people lost their life. If a person see an accident ,then he will immediately call for ambulance by using emergency numbers like 108 (India), 911 (USA), etc. In this process we have some problems.

· There may be a delay exist to call for ambulance. When accident occurs the period is very crucial, the injured person fighting with his life and every minute counts for his life. Therefore no delay is acceptable in such situations to call ambulance.

· If accident occurs during night time or at agency places (unmanned areas), there will be no one to call for ambulance.

In the above two cases there is a chance to die that particular injured person.

The above mentioned problems (like delay and unmanned areas to call ambulance) can be avoided by using this project. In this project, a solution is presented to reduce failure cases to save the life of injured persons in accidents. A device is placed in a vehicle so that whenever any accident occurs, it will immediately track its location and a SMS is sent it to emergency services and also to the required persons. Hence an immediate service is available to the injured persons in accidents and percentage of chance of lives will increase in accidents.

The above solution can be implemented by using GPS and GSM technology. Hardware in this project includes GPS module, GSM modem, AT89S52, LCD display, MEMS sensor, power supply. With GPS (global positioning system) one can automatically determine the precise location at any point on earth using a ground device that picks up signals from multiple satellites. GSM is a type of cellular service available and developed using TDMA technology. Microcontroller monitors GPS module in prefixed intervals. Whenever any accident occur MEMS sensor detects and sends the accident location which is tracked by GPS device and sent SMS via GSM device to ambulance and also to remaining authorized persons.

Block Diagram:

Figure 1.1 Block diagram

LASER LIGHT BASED DOOR OPENER

2013-01-12T20:09:00.001-08:00

Fig 1.1 circuit Diagram

The LASER guided door open system contains a LASER light as transmitter and a photodiode acts as a receiver. When a person crosses the laser light, the photodiode and its control circuit will excite the relay circuit, and then the motor starts rotates. The circuit diagram is shown in figure 1.1

The entire circuit diagram is divided into four sections

· LASER and Photo diode interface.
· LM358 OPAMP circuit for digital output values.
· Relay and Buzzer interface circuit.
· 12V DC converter circuit.

LASER and Photo diode interface circuit.

Any LASER diode can act as a transmitter (any normal LASER diode). Here one end (positive terminal) of the diode is connected to 5V power supply as shown in figure 1.1 and other end is connected to ground via R1 to protect the LASER diode by not allowing more current from power supply.

R1 can be calculated as R1 = (Vs-Vdiode)/Idiode = (5-3)/20mA = 100 Ohms.

Current ‘Idiode’ is chosen in such a way that the LASER diode produce more intensity.

The photodiode act as LASER receiver detects the light falling on it and varies its resistance according to the LASER light intensity. Note that ambient light conditions (sunlight, etc.,) may affect the circuit performance. Therefore the photo diode should be enclosed in a closed surface and provide a small hole to allow the LASER light fall on it. Whenever LASER light fall on the photodiode its resistance will decrease with respect to the light intensity LASER light, otherwise it offers huge amount resistance in order of Mega ohms.

A 1k pot (potentiometer) is connected to adjust the sensitivity of the photodiode circuit that means the circuit will respond for small changes in light. The photodiode and the trim pot (1k) combination act a voltage divider network and the output is connected to simple transistor based amplifier. When there is no light the photo diode offers high resistance. Therefore, no current will flow through trim pot. Hence the voltage drop across the trim pot is zero. Hence the transistor is off. On other hand when light falls on photodiode, its resistance decreases and the current starts flowing through 1k trim pot then some voltage is appear across the 1k trim pot. If this voltage is greater than Vbe of the transistor then the transistor conducts

R2 = (5v – Vbe - Vled)/I

LM358 OPAMP section:

Fig 1.2 Pin diagram of LM358

LM358 contains dual differential input amplifiers and its operating voltage ranges from 3.3V to 30V. The main advantage of LM358 is single power supply and it requires low power when compare to LM741. Pin diagram is shown in figure 1.2. The use of this opamp in open loop configuration in this circuit is used to produce to two discrete levels of voltage (+Vsat and -Vsat). The output of the photo diode circuit which is taken from the emitter of transistor (T1 BC 547) and it is connected to pin 2 of LM358. A 1k trim pot (VR1) is connected to pin 3, if the voltage at the pin 2 is more at pin 3, the ouput is –Vsat. Otherwise the output is + Vsat. Comparator circuit is shown in figure in 1.3.

Fig 1.3 LM358 as comparator

In this circuit, we make use of both opamps provides in the LM358. The output taken from the pin 7 is connected to buzzer driving circuit and pin1 is connected to relay driving circuit.

Buzzer and relay circuit:

The base of the transistor T2 is connected to the output of the opamp at pin7. A resistance 4.7kohms is used to limit the base current of the transistor which in turn limits the collector current flowing through the buzzer.

A base resistor can be calculated as follows.

Rb = (Vopamp - Vbe)/Ib

The resistance R6 is used to limit the collector current. The same base resistance is used for the relay driver transistor (T3).

The 12V relay coil require 70mA to excite, hence transistor circuit should be designed to allow more than 70mA current. Here BC547 is best suited and allow up to 100mA current.

The diode D4 is called fly wheel diode. When the transistor T2 is off, the current flowing through the relay is also off. But inductor does not allow sudden changes in the current in it. Hence a huge voltage is produce across the transistor which may damage the transistor. Hence D4 is connected across the coil to protect the transistor when relay is suddenly off.

How to start with Stellaris LM3S811 Evaluation Board

2012-09-10T09:13:00.003-07:00

Introduction:

When I got selected in Texas Instruments MCU contest, then I start working on it and learned alot. In this site I will share my experience and knowledge with the LM3S811 evaluation kit. The company itself provided me an LM3S811 evaluation board for doing the project. When I got mail from the company about the tool, I expected a lot about evaluation board. But when I received the tool from the TI Company, I was really surprised that EK-LM3S811-ND evaluation kit contains just two main IC’s soldered on PCB and an USB cable for power and communication purpose. Initially I don’t understand that what I will do with this simple board. Later I realized that the evaluation board is not just a simple PCB, it’s a tool with a lot of options and operations inbuilt in it. That’s what actually an embedded programmer needs to develop an application within a short time and easily. TI developed and provided everything to us just you need to connect and program it.

The LM3S811 evaluation board contains inbuilt power supply, inbuilt serial communication (UART0) via USB (virtual port), inbuilt In System Programming, inbuilt debugging (ICDI-no external debugger is needed), the same board acts an external debugger for other LM3S811 boards, User programmable LED and switch, reset switch, GPIO lines for external world interface.

Installation and working:

Installing and Working with Texas Instruments Stellaris LM3S811 Evaluation Board is very easy than any other in my experience. Let us know simple things about this board, firstly by seeing the LM3S811 evaluation board you can find mainly two processors of Texas instruments LM3S3601 and LM3S811. This stellaris board is becoming very famous for motion control, industrial automation and single board computing.

Actually these two processors are come from Luminary Micro Company based in Austin. Later it was acquired by Texas Instruments. Hence the IC’s have suffix LM (luminary Micro).

The LM3S3601 processor act as USB device controller on the board and it runs with 16MHz clock. This processor is main heart of the evaluation board, because through this all inbuilt are performed for example inbuilt debugging, virtual serial port, it acts external JTAG debugger for other LM3S811 board etc.

The LM3S811 is actual microcontroller through which you can develop the applications. To develop applications on LM3S811 you should have the knowledge about its internal architecture, memory, communication ports etc., all the details are available in the LM3S811 datasheet.

Installation of required tools before working with EK-LM3S811-ND eval board:

The following tools to be installed in your PC, if you want to work with the EK-LM3S811-ND board.

1) Install the LM3S811 board drivers.

2) Install the IDE.

3) Install the Stellaris Ware package.

4) Install LM flash Programmer

All the above tools are available in your CD provide along with the EK-LM3S811-ND board or you can find those tools from the below link.

http://www.ti.com/tool/ekk-lm3s811

Install the LM3S811 board drivers:

When you connect the EK-LM3S811-ND eval board to the PC, the operating system (windows) it will show a pop-up “Found New Hardware Wizard” asking for drivers to be installed as shown figure 1.1

Figure 1.1 asking for ICDI debug port driver installation

While installing the drivers again it will operating system pop-up a window asking for passing window logo testing... as shown in figure 1.2, press “Continue Anyway” button.

Figure 1.2 windows logo testing verify

The same window with different driver names will pop-up three times for installing three types of drivers.

1) ICDI Debug port.

2) ICDI Serial port or ICDI serial peripheral.

3) ICDI DFU device.

You simply accept all the drivers’ installation.

ICDI means is acronym for In-Circuit Debug Interface.

DFU means “Device Firmware Update”.

Install IDE for programming and debugging:

There are several IDE’s are available in the market like

1) Code Composer studio.

2) IAR Embedded Workbench

3) KEIL.

Every IDE has its own capabilities, but Keil IDE is simple, more examples are available on internet and easy for beginners who exposed with keil in 8051 MCU’s.

Ok. Now Install the Keil MDK tool latest version or the version provided in your CD provided by TI Company.

Install the Stellaris Ware package:

A complete set of C-library covering all peripherals and functionality of the Stellaris device available in this package. This package will install in C:\StellarisWare package This StellarisWare package all variety of examples for testing peripherals like UART, LED, I2C, CAN, etc.,

Install the LM flash Programmer:

Install LM Flash Programmer provided in the CD tools folder. By using LM Flash Programmer you can update or rewrite your firmware available in USB controller IC called Dust Devil (LM3S3601) by loading .bin files via DFU port. You can burn the programs in to the LM3S811 IC by using this tool.

Now you can understand that why three drivers are installed for the EK-LM3S811-ND board.

1) ICDI DFU port is used by the LM Flash programmer to update or overwrite the firmware.

2) ICDI serial port is used as virtual communication port for serial communication via USB between PC and LM3S811 IC. LM3S811 has two UART (Uart0,Uart1) and It uses UART0 of LM3S811 IC as Virtual com port (see schematic diagram of the board in hardware folder). In the schematic the PA0 (Uart0Rx) and PA1(Uart0Tx) are connected to VCP out and VCP IN. VCP means virtual com port.

Virtual com port is nothing but a serial com port; this will come into picture when there is no physical serial peripheral or port for your PC. Generally laptops don’t have serial com ports (DB9 connector), so USB ports are configured as serial com port by installing required drivers. Hence it is called virtual com port.

3) ICDI debug port is used for debugging operating along with IDE. In built debugging and programming minimises the time required to develop the embedded applications.

Testing LED blinking program on LM3S811 board with keil IDE:

1)      Open keil IDE software.

2)  Open project – “C:\Stellarisware\boards\{board-name}\blinky”   à these are the examples programs provided by the texas instrument company. These programs will loaded into the your computer when the Stellaris Ware package is installed.

3)      Edit the delay in the program by changing 200000 to 2000000 in the for loop and save it as shown in Figure 1.3.

for(ulLoop = 0; ulLoop < 200000; ulLoop++)

Now two onboard LEDs will blink with large delay.

Figure 1.3 shows the LED blink code for stellaris LM3S811 eval board in KEIL IDE.

4) Build target by pressing F7 key on the keyboard or go to the project on menu, select rebuild all targets as shown in figure 1.4. If no errors and no warnings then your compilation and building is successful.

Figure 1.4 how to build the program on KEIL IDE for Stellaris LM3S811 eval board

5) Now Load the “LM flash programmer” by double clicking on the ICON and choose LM3S811 Evaluation Board in Quick set menu as shown in figure 1.3

figure 1.5 LM FLASH programmer

6) Select your required .bin file in the program tab and also select “RESET MCU after program” option as shown figure 1.6.

Figure 1.6 Selecting required setting on LM Flash Programmer.

7) Click program button to burn your program in to LM3S811 IC as shown in figure 1.7.

Figure 1.7 programming .bin file into LM3S811 using LM Flash Programmer.

Real Time Operating System Tutorial - part2

2012-09-07T10:48:00.001-07:00

In this tutorial, i have introduced the Task object and its functionality. Two basics algorithm of RTOS are described with simple diagrams.

What is Task Management?

Task Management allows programmers to design their software as a number of separate tasks (chunks of codes) with each handling a distinct goal and deadline.

Task Management includes

· Task Object

· Task Scheduling (Provides multitasking feature)

· Task Synchronization

· Inter-task Communication

What is a task?

The application is divided into small, schedulable and sequential program units to achieve concurrency in real time systems known as TASK. Generally kernel allocates some chunk of time to the task as they needed to run.

What is a task object?

A task object is defined by the following set of components:

· Task Control block

· Task Stack (Stack memory dedicated for Task in RAM)

· Task Routine (Program code residing in ROM)

What is Task Control Block (TCB) ?

· A complex data structures is used for task management are Task Control Block and Stack.

· The Task Control Block stores all the information (task state, priority, etc..,) about the task as shown in Fig 1.6. Each task has its own TCB and stack.

· By using TCBs the Kernel identifying and managing the tasks.

Task Control Block

Task States:

A task can typically be any of the following states:

· Dormant or Sleeping

· Ready

· Running

· Pending

Task States

Ready: A task is ready to run is said to be in ready state.

Running (Active): A task is currently being executed by the CPU is said to be in running state.

Pending (Waiting): A task is waiting for an event like a time-out, message, semaphore, or a

Signal is said to be in Pending state.

Dormant: Any task which has been defined in memory but not yet initialized or started is said be in Dormant.

Each task may exist in any of the four states as shown in fig 1.7.During the execution of an application program, individual tasks are continuously changing from one state to another. However at particular instant of time only one task will be in running state. In the process where CPU control is change from one task to another, context of the to-be-suspended task will be saved while context of the to-be-executed task will be retrieved. This process of saving the context of a task being suspended and restoring the context of a task being resumed is called context switching.

Task Scheduling:

Task Scheduling is a plan of allocating resources (time, memory, statck) for tasks in multitasking systems.
A set of algorithms are used to handle Task Scheduling is called Scheduler.

Generally the scheduler keeps record of the state of each task (using TCB of the tasks) and selects the next task to be executed and allocates the CPU time to one of them. A scheduler helps to maximize CPU utilization among different tasks in a multi-tasking program and to minimize waiting time.

There are two types of Scheduling Algorithms are there:

· Non-preemptive scheduling

· Preemptive Scheduling

Non-preemptive scheduling:

In non-preemption scheduling there are two algorithms

· Co-operative scheduling

· Round robin scheduling

In Co-operative scheduling all tasks cooperate with each other to explicitly give up control of the processor. When CPU executing a task, until the completion of the task the CPU control will not be transfer to other task.

In Round robin scheduling, the algorithm is designed based upon sharing of CPU time between different tasks. i.e., All runnable(ready to execute) tasks are kept in a circular queue. The CPU scheduler goes around this queue, allocating the CPU time (generally in milliseconds) to each task. If the allocated time of a particular task is expired then CPU control is transferred to next task to be executed and the current task is added to the tail of the queue.

In Round Robin Scheduling all tasks have same Priority; this shows parallel execution of several tasks. off course tasks are not really executed concurrently but because of the time slice allocated for each task is short (only a few milliseconds) it appears as though tasks execute simultaneously.

Round Robin Scheduling

Pre-emptive Scheduling:

Priority based preemptive scheduling

Why capacitor doesn’t allow sudden change in the voltage – In depth analysis

2012-09-05T10:56:00.003-07:00

Why capacitor doesn’t allow sudden change in the voltage – In depth analysis

In our studies we come through the capacitors and its usages in many applications. Almost 90 percent of the students don’t know why the capacitor does not allow the sudden changes in the voltage. But still they are trying to plot graphs of the experiment in laboratory. Consider an example RC low pass filter circuit experiment in circuit’s laboratory, when a square wave is applied to the RC low pass filter the output of the circuit is exponential rise towards the maximum voltage during positive square pulse input and for the negative input the output rises exponential towards the negative voltage.

In such circuit, for sudden rise of input voltage from zero to maximum the capacitor voltage is exponential rise towards the maximum voltage. At that time our lectures or tutors will say “capacitor doesn’t allow sudden changes in the voltage”. Then a question arises in our mind why the capacitor doesn’t allow sudden changes in the voltages?.

Before going to know about the answer for the above question let us look for the simple basics of capacitor. Off course we can write a complete text book about capacitors, but here the discussion is limited.

What is a capacitor?

A capacitor is an electronic device has the capability to store electric energy by holding electric charge.

How Electric charged is stored in the capacitor?

The basic model of the capacitor contains two conducting materials separated by an insulating material or vacuum. For the simplicity, we assume two parallel plates as conducting materials separated by vacuum as shown in fig 1.1.

Figure 1.1 Two parallel plates with vacuum as dielectric create a capacitor.

Formula for capacitance is given by (C) = Charge (Q)/Voltage (V)

V: Potential difference between two conductors.

Q: Magnitude is charge on one of the conductors.

C: Capacitance in farads

1 Farad = 1 Columb/1Volt

When a battery is connected to a parallel plate capacitor as shown in the figure 1.2, the capacitor starts charging towards the maximum voltage of battery. Assume initially the capacitor has no charge that means both plates are neutral (each plate have equal number of protons and electrons). If a battery is connected to a parallel plate capacitor, the positive terminal of the battery forcibly attracts the electrons from the capacitor plate A and the negative terminal of the battery will send the electrons to capacitor plate B. Therefore the plate A becomes more positive and plate B becomes more negative.

Figure 1.2 A battery is connected to a capacitor to make it charge.

The number of electrons that are accumulate on plate B is equal to the number of electrons that are attracted by the positive terminal of the battery from plate A. In this way the plates of the capacitor will get charged as positive and negative and this charging process will continue until the voltage across the capacitor reaches maximum voltage of the battery. This charge stored in a capacitor will not go anywhere until you provide a discharge path. Simple discharge path to a capacitor is just short circuit the two terminals of the capacitor.

Caution: Does not touch the charged capacitor lead with your hands which may cause shock and it may be worse when the capacitor is large.

Why capacitor doesn’t allow sudden change in the voltage

Here the solution is explained by taking four different cases. For better understanding only two electrons movement is shown and also the time taken to move the electrons is shown in seconds. But remember practically millions of electrons will flow in fraction of seconds.

Case 1 (t = 0): At t = 0, the switch is opened therefore there is no charge flow. That means the capacitors plates are neutral and the potential difference across the capacitor is zero. Therefore the voltage across the capacitor is zero.

Case 2 (t = t1): Whenever the switch is closed (sudden change in voltage from 0V to 5V), the positive terminal of the battery will attract electrons from the plate A and at the same time the negative terminal of the battery will provide same number electrons to plate B in very small amount of time. Therefore the voltage rises linearly towards the maximum voltage as shown in the voltage graph. But current graph is initially is at its maximum this is because the number of electrons passing in given time is defined as current (I = Q/T). If the time is short, obviously the current is Maximum.

Case 3 (t = t3): The deficiency of electrons on the plate A, make it more positive. Similarly the plate B is more negative due excess of electrons. Because of the more positive charge of the plate A will make the electron movement difficult, hence the movement of electron is slow and the voltage graph is slowly rising and is into curved shaped. The time required to move the electrons towards the positive terminal of battery from plate A is increased, therefore the fall in current is shown in the graph. Similar situation will happen at the negative terminal.

Case 4 (t = t4): Now the plate A is more positive and the plate B is more negative in nature.

Due to this, more time is required to bring the electron from the plate A to the battery positive terminal. Hence the voltage graph is almost parallel to x axis. And the current is almost zero and graph reaches to x axis.

Conclusion: During the capacitor charging the capacitor plates get charged, so that the attraction and repulsive forces of the capacitor plates will make the electron flow difficult. Hence the capacitor will not allow the sudden changes in the voltage.

8051 based 16x2 LCD interfacing using busy status flag

2012-09-03T06:32:00.001-07:00

1. Introduction LCD interfaces using busy status flag:

In this tutorial, LCD is interfaced to 8051 microcontroller using busy status flag. The advantage of using busy status flag method is there is no wastage of CPU time which is pre-dominant in other method. Here the LCD busy status flag will pull low during the internal processing of command or data, after completion of internal operation the status flag brings back to high. The microcontroller monitors the busy flag continuously, whenever it goes high then it will send the next byte to LCD.

2. Hardware interface with 8051 Circuit:

Figure1.1 LCD Hardware interface with 8051 circuit

In the above figure, the data lines (D7-D0) are connected to port0 with 10k pull up resistors, since in 8051 microcontroller the port0 pins are open collector configuration. You may use 4.7k – 10k pull ups as per datasheet. A power on reset circuit is designed with a capacitor and resistor whose values are C = 10uF and R = 10K. The power on reset circuit are provides some time for both power supply and oscillator are stabilized. The power on reset circuit is also useful when the supply voltage drops below the required, then automatically a reset is applied to the circuit. A preset is connected at pin3 of LCD to vary the contrast of LCD; the 1k resistor protects the LCD by not allowing large current when the preset is at its minimum value.

The control pins (Enable, R/W, RS) of the LCD are connected to port2 of the 8051 MCU (P2.2, P2.1, P2.0) respectively. The busy status of LCD is taken from the D7 line as shown in figure 1.1. During write operation the D7 pin acts as simple data line, whereas for read operation it provides the status of the LCD i.e., whether the LCD controller (HD44780) performing internal operation or not. If LCD completes the internal operation, the D7 pin goes LOW otherwise it is in logic HIGH. To get the busy status, the RS line should be low (RS = 1) and R/W should be high (R/W = 1).

Remember the LCD will not accept any instructions (commands) or data while it is performing internal operations. For this purpose, MCU check the busy flag state of LCD to know whether it completes internal operations or not. There is another method that MCU should wait certain amount of time until the LCD completes the internal operations, that’s we introduce some random delay after each command or data is sent. This method is not much efficient when comparing with busy status flag checking method, why because there is some wastage of CPU time will occur by introducing delay after each command or data.

A clock circuit of 12Mhz with two 33pF capacitors are connected at the XTAL1 and XTAL2 pins.

3. LCD interface timing diagrams:

Figure 1.2 Timing diagram of LCD interface using busy flag shows the no wastage of CPU time.

C code to interface LCD to 8051 using busy flag

/**********************************************************************************************************************************/
// http://www.npeducations.com
//LCDwithDelay.c - implementing the LCD interface with 89s52 microcontroller using busy flag status
//author - lovakiranvarma
/**********************************************************************************************************************************/

/********************************************** Header Files Declaration *********************************************************/
#include
#include

/********************************************* LCD control signals declaration ***************************************************/

sbit RS = P2^0;     // Register Select line
sbit RW = P2^1;  // Read/write line
sbit Enable = P2^2; // Enable line
sbit LED = P2^5;
sbit Busy_Flag = P2^3;

/********************************************* LCD function prototypes ***************************************************/

void send_cmd(unsigned char);
void send_String(unsigned char*);
void send_Char(unsigned char character);
void delayms(unsigned int);
void lcd_BusyCheck(void);
void lcd_ScrollData(unsigned char NumberOfTimes, unsigned char strlength);


/********************************************* Main Funciton declaration ***************************************************/

void main()
{

P0 = 0x00;        // make P0 as output port

/********************************************* LCD initialization ***************************************************/
send_cmd(0x38);       // configuring LCD as 2 line 5x7 matrix
send_cmd(0x0E);       // Display on, Cursor blinking
send_cmd(0x01);       // Clear Display Screen
send_cmd(0x06);       // Increment Cursor (Right side)



 while(1)
 {
  send_cmd(0x83);       // Force cursor to beginning of 1st line, if the number is 0x85 then force the cursor to 5th position
  send_String("NPEDUCATIONS");    // displays at first line
  delayms(100);
  lcd_ScrollData(5,12);      // Scroll the text "npeducations" for 5 times
  delayms(100);
  send_cmd(0xC0);          // Force cursor to beginning of 2nd line
  send_String("http://www.npeducations.com"); // displays at first line
  delayms(100);
  send_cmd(0x01);         // Clear Display Screen
  
                    
 }

}


/*********************************************LCD Command Sending Function declaration**********************************/

void send_cmd(unsigned char Command)
{
 P0 = Command;
 lcd_BusyCheck();
 RS = 0;      // Select Command Register
 RW = 0;    // write operation
 Enable = 1;      // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
 delayms(1);
 Enable = 0;

}

/******************************************* LCD data sending Function declaration****************************************/

void send_String(unsigned char *String)
{
unsigned char i=0;

while(String[i]!='\0')
{
     
 P0 = String[i++];
 lcd_BusyCheck();
 RS = 1;    // Select Data Register
 RW = 0;    // write operation
 Enable = 1;      // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
 delayms(1);
 Enable = 0;
 if(i>=16)     // the following three instructions will shift the display right if the 
 send_cmd(0x1C);    //number of characters more than the 16(not fit on the screen)
 delayms(150); 


}
 
return;

}
/******************************************* LCD single character sending Function declaration************************************/

void send_Char(unsigned char character)
{
             
 P0 = character;
 lcd_BusyCheck();
 RS = 1;    // Select Data Register
 RW = 0;    // write operation
 Enable = 1;      // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
 delayms(1);
 Enable = 0;
 return;

}

/********************************************* LCD Scrolling Function ******************************************************/
void lcd_ScrollData(unsigned char NumberOfTimes, unsigned char strlength)
{
unsigned char i;
send_cmd(0x02);

 while(NumberOfTimes>0) // scroll the text for given number of times
 {
  delayms(10);
  for(i=16-strlength;i>0;i--)
  {
   delayms(50);
   send_cmd(0x1C);   // left Shift 
  }
  delayms(10);

  for(i=16-strlength;i>0;i--)
  {
   delayms(50);
   send_cmd(0x18);   // Right Shift
  }

  
  
  NumberOfTimes--;
 }
}

/******************************************* BusyCheck Function declaration***********************************************/
void lcd_BusyCheck()
{
 Busy_Flag = 1;
 RS = 0;
 RW = 1;
 while(Busy_Flag == 1)
 {
  Enable = 0;
  delayms(1);
  Enable = 1;
 }

}

/******************************************* delayms Function declaration***********************************************/
void delayms(unsigned int value)
{
 unsigned int i,j;
 for(i=0;i<=value;i++)
 {
  for(j=0;j<100 data-blogger-escaped-j="j" data-blogger-escaped-pre="pre">

Custom character generation on 16x2 LCD using 8051 microcontroller

2012-08-31T08:43:00.000-07:00

1. Introduction:

In this tutorial, we learn how to create or design custom characters on 16x2 LCD using 8051 microcontroller. Before going to discuss custom characters design on LCD, we will see how the standard characters (which are already stored in LCD memory during manufacture) are displayed on the 16x2 LCD.

2. Displaying standard characters on LCD:

In 16x2 LCD controller HD44780, there are three memory locations are available to store characters, numbers and special symbols.

1. Display data RAM (DDRAM).

2. Character Generator ROM (CGROM).

3. Character Generator RAM (CGRAM). Power failure data loss

Out of these three memory locations, DDRAM and CGROM are used to generate regular standard characters (ASCII characters). By using these three memory locations, a user can generate different character fonts and symbols on LCD display. A character font describes the shape and style of the character. Each shape of a character is designed by taking the number of pixels in mind. For example, in 16x2 LCD there are 16 segments available per single line. Each segment contains pixels in 5x7 or 5x10 matrix forms.

For example, a character in both uppercase ‘A’ and lowercase ‘a’ is designed by making corresponding pixels into black (no light) as shown in figure 1.1,

Figure 1.1 shows the uppercase and lowercase formats of character ‘A’ in 5x7 matrix of LCD display.

In each row, the ON and OFF pixels of 5x7 matrix is represented by binary values 1 and 0 respectively, from these binary values the hexadecimal code is designed by gathering all 1’s and 0’s as shown in the figure 1.1. All these eight hexadecimal codes (referred as character pattern) of each character are stored in memory. LCD Manufacturers store these hexadecimal representation codes of all ASCII characters in character generator ROM (CGROM) area as shown in figure1.2. We refer the hexadecimal codes in CGROM as standard or basic fonts of characters in LCD.

Figure 1.2 shows Standard ASCII characters stored in CGROM and equivalent ASCII code in hexadecimal is presented as address of that particular character.

The Display Data RAM (DDRAM) stores the ASCII code of a character which is sent by the microcontroller. Now the LCD controller (HD44780) maps the corresponding ASCII code in DDRAM with CGROM address to bring the hexadecimal codes (character pattern) of that particular character. By using those hexadecimal codes the 5x7 matrix segment will light according to that character pattern to display corresponding character on it as shown in figure 1.3.

Figure 1.3 block diagram shows character generation on LCD.

3. Creating and displaying Custom Characters on LCD display:

To create custom characters on LCD, the display controller (HD44780) make use of CGRAM area to store hexadecimal codes (character pattern) which are designed by user. In addition to CGRAM area, DDRAM area is also used to store the CGRAM address of a particular character which is sent by microcontroller in hexadecimal format.

Don’t confuse with the above section of this tutorial “Displaying standard characters on LCD”, in which DDRAM and CGROM memory areas are used to generate regular standard characters. But here, to create and display custom characters on LCD, we use DDRAM and CGRAM (both are RAM’s).

There are only 8 memory locations are available to store user defined characters in CGRAM with address 0x01 (00000001n) – 0x07 (01100001b), which is shown in the figure 1.2 by highlighting locations with green color.

3.1 Steps to create and display custom character on 16x2 LCD using microcontroller

1. To create custom characters, first draw a table with 7 rows and 5 columns (5x7 matrix) on a paper. Fill the corresponding squares with some color according to your style of custom character pattern and form the hexadecimal code for each row as shown in figure 1.1.

2. Initialize LCD with required commands.

3. Send the Initial address (0x40) of CGRAM as a command to LCD to store the custom character. The next address to store another custom character should be ‘0x48’. That means we should add eight bytes to the present address to get the next address of CGRAM.

4. Send the all hexadecimal bytes of custom character to CGRAM.

5. Force the LCD cursor to where you want to display your custom character. If it is beginning of 1st line, then send ‘0x80’ as command.

6. Send the position of your custom character in CGRAM to LCD.

4. C code to display single custom character program ver1.1:

/**********************************************************************************************************************/
// http://www.npeducations.com
// LCDwithDelay.c - Generating single custom character on 16x2 LCD using 89s52 microcontroller -- program v 1.1
// Author - lovakiranvarma, (M.tech)
// Note: no need provide external delay after command or data, because the send_cmd and send_data functions it self
// provide 1 milliseconds after enable pulse
/**********************************************************************************************************************/
/********************************************** Header Files Declaration **********************************************/
#include
#include
#include
/********************************************* LCD control signals declaration ****************************************/

sbit RS = P2^0;     // Register Select line
sbit RW = P2^1;		// Read/write line
sbit Enable = P2^2;	// Enable line
#define LCD_PORT P0 // define port

/********************************************* LCD function prototypes ************************************************/

void LCD_init(void);
void send_cmd(unsigned char);
void send_char(unsigned char);
void send_String(unsigned char *);
void delayms(unsigned int);
void CustomCharacterStore(void);

/********************************Character array to hold custom character patterns*************************************/
unsigned char CharacterArray[8] = {0x0E,0x11,0x0E,0x04,0x1F,0x04,0x1B,0x00};


/********************************************* Main Funciton declaration **********************************************/

void main()
{

LCD_PORT = 0x00; // Make the port as output port

  	 /****************** Reset process from datasheet **************/
     delayms(15);	// wait for more than 15ms after supply rises to 4.5V
	 send_cmd(0x30);
	 delayms(4);		// wait more than 4.1ms
	 send_cmd(0x30);
	 delayms(1);		// wait more than 100us, but delayms(1) will provide 1ms
	 send_cmd(0x30);
	 delayms(1);
	 send_cmd(0x02); // return to home
	 delayms(1);

  /****************** Initialize LCD **************/		
	LCD_init();				        // LCD initialization
	CustomCharacterStore();

	while(1)
	{
			send_cmd(0x83);  // Force cursor to beginning of 1st line, if the number is 0x83 then force the cursor to 53rd position			
			send_char(0x00); // locate the first character in CGRAM
	}
	

}

void CustomCharacterStore()
{
	unsigned char i=0,j=0;
		send_cmd(0x40);       //Load the location where we want to store
		
		/**Store the custom character pattern in CGRAM area**/
        send_char(0x0E);      //Load row 1 data
	    send_char(0x11);      //Load row 2 data
	    send_char(0x0E);      //Load row 3 data
	    send_char(0x04);      //Load row 4 data
	    send_char(0x1F);      //Load row 5 data
	    send_char(0x04);      //Load row 6 data
		send_char(0x1B);      //Load row 7 data
		send_char(0x00);      //Load row 8 data, this 8th won't display on LCD, because the matrix is 5x7
}

/********************************************* LCD Initialization Function declaration ********************************/

void LCD_init()
{
	send_cmd(0x38);  					// configuring LCD as 2 line 5x7 matrix in 8-bit mode
	send_cmd(0x0C);  					// Display on, Cursor blinking
	send_cmd(0x01);  					// Clear Display Screen
	send_cmd(0x06);  					// Increment Cursor (Right side)
}

/******************************************* LCD single character sending Function declaration************************************/

void send_char(unsigned char character)
{
	LCD_PORT = character;
	RS = 1;				// Select Data Register
	RW = 0;				// write operation
	Enable = 1;		    // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
	delayms(1);			// 1 millisec delay
	Enable = 0;
	delayms(1);			// 1 millisec delay
}


/*********************************************LCD Command Sending Function declaration********************************/

void send_cmd(unsigned char Command)
{
	LCD_PORT = Command;
	RS = 0;		  		// Select Command Register
	RW = 0;				// write operation
	Enable = 1;		    // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
	delayms(1);			// 1 millisec delay
	Enable = 0;
	delayms(1);			// 1 millisec delay

}
/******************************************* LCD String sending Function declaration*************************************/

void send_String(unsigned char *String)
{
unsigned char i=0;

	while(String[i]!='\0')
	{
				 
		LCD_PORT = String[i++];
		RS = 1;			 // Select Data Register
		RW = 0;			 // write operation
		Enable = 1;		 // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
		delayms(1);		 // 1 millisec delay
		Enable = 0;
		delayms(1);		 // 1 millisec delay
		if(i>=16)		 // If the number of characters in the string > 16, then the below command automatically 
		send_cmd(0x1C);	 // Shift the display right side 
		delayms(100);	 // 100 millisec delay
	}
	
}

/******************************************* delayms Function declaration***********************************************/
void delayms(unsigned int value)
{
	unsigned int i,j;
		
	for(i=0;i<=value;i++)
	{
		for(j=0;j<100;j++)
		_nop_();		 // no operation produce 1us time delay
	}
	
}

4.1 Output in proteus software for the program1.1:

Figure 1.4 displaying animated boy on LCD using proteus simulation software

5. C code to display more than one custom character using pointers:

In this code I have the changed CustomCharacterStore() function, which is allowed to store 1 to 8 custom characters in CGRAM with the help of pointers concept in C language. And I have created a two dimensional array to define custom character patterns and in the main function, each character is called separately using send_char() function.

5.1 C code to display eight custom characters – program ver1.2:

/***************************************************************************************************************************/
// http://www.npeducations.com
// LCDwithDelay.c - Generation of custom characters on 16x2 LCD using 89s52 microcontroller
// Author - lovakiranvarma, (M.tech)
// Note: no need provide external delay after command or data, because the send_cmd and send_data functions it self
// provide 1 milliseconds after enable pulse
/***************************************************************************************************************************/
/********************************************** Header Files Declaration ***************************************************/
#include
#include
#include
/********************************************* LCD control signals declaration ***************************************************/

sbit RS = P2^0;     // Register Select line
sbit RW = P2^1;		// Read/write line
sbit Enable = P2^2;	// Enable line
#define LCD_PORT P0 // define port

/********************************************* LCD function prototypes ************************************************/

void LCD_init(void);
void send_cmd(unsigned char);
void send_String(unsigned char*);
void send_char(unsigned char);
void delayms(unsigned int);
void CustomCharacterStore(void);

/********************************Character array to hold custom character patterns*************************************/
unsigned char CharacterArray[8][8] = {{0x0E,0x11,0x0E,0x04,0x1F,0x04,0x1B,0x00}, // boy
									  {0x00,0x00,0x1E,0x13,0x13,0x0C,0x1F,0x00},	// cup
									  {0x00,0x0A,0x0A,0x00,0x11,0x0E,0x06,0x00},	// simley
									  {0x00,0x00,0x1B,0x1F,0x0E,0x04,0x00,0x00}, // love
									  {0x00,0x19,0x1A,0x04,0x0B,0x13,0x00,0x00}, // percentage
									  {0x1F,0x11,0x0A,0x04,0x0A,0x15,0x1F,0x00}, // hour glass
									  {0x00,0x1B,0x15,0x11,0x11,0x1F,0x00,0x00},// mail folder
									  {0x00, 0x0E, 0x11, 0x1F, 0x15, 0x1F, 0x0A}}; // android robo


/********************************************* Main Funciton declaration ***********************************************/

void main()
{

LCD_PORT = 0x00; // Make the port as output port

  	 /****************** Reset process from datasheet **************/
     delayms(15);	// wait for more than 15ms after supply rises to 4.5V
	 send_cmd(0x30);
	 delayms(4);		// wait more than 4.1ms
	 send_cmd(0x30);
	 delayms(1);		// wait more than 100us, but delayms(1) will provide 1ms
	 send_cmd(0x30);
	 delayms(1);
	 send_cmd(0x02); // return to home
	 delayms(1);

  /****************** Initialize LCD **************/		
	LCD_init();				        // LCD initialization
	CustomCharacterStore();

	while(1)
	{
			send_cmd(0x80);  // Force cursor to beginning of 1st line, if the number is 0x83 then force the cursor to 53rd position			
			send_char(0x00); // locate the first character in CGRAM
			send_char(' ');  // space
			send_char(0x01); // locate the second character in CGRAM
			send_char(' ');  // space
			send_char(0x02); // locate the third character in CGRAM
			send_char(' ');  // space
			send_char(0x03); // locate the fourth character in CGRAM
			send_char(' ');  // space
			send_char(0x04); // locate the fifth character in CGRAM
			send_char(' ');  // space
			send_char(0x05); // locate the sixth character in CGRAM
			send_char(' ');  // space
			send_char(0x06); // locate the seventh character in CGRAM
			send_char(' ');  // space
			send_char(0x07); // locate the eigth character in CGRAM		
			send_char(' ');  // space
			
	

}

void CustomCharacterStore()
{
unsigned char i=0,j=0;
		//send_cmd(0x48);       //Load the location where we want to store
		//delayms(1);				// Delay of 1millisec

		/**Store the custom character patterns in CGRAM area**/
											     
		while(j<8)
		{
			send_cmd(0x40 + (j*8));
				for(i=0;i<8;i++)
				{
					send_char(CharacterArray[j][i]);
				}
				j++;
		}
	
}

/********************************************* LCD Initialization Function declaration ********************************/

void LCD_init()
{
	send_cmd(0x38);  					// configuring LCD as 2 line 5x7 matrix in 8-bit mode
	send_cmd(0x0C);  					// Display on, Cursor blinking
	send_cmd(0x01);  					// Clear Display Screen
	send_cmd(0x06);  					// Increment Cursor (Right side)
}

void send_char(unsigned char character)
{
	LCD_PORT = character;
	RS = 1;				// Select Data Register
	RW = 0;				// write operation
	Enable = 1;		    // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
	delayms(1);			// 1 millisec delay
	Enable = 0;
	delayms(1);			// 1 millisec delay
}


/*********************************************LCD Command Sending Function declaration********************************/

void send_cmd(unsigned char Command)
{
	LCD_PORT = Command;
	RS = 0;		  		// Select Command Register
	RW = 0;				// write operation
	Enable = 1;		    // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
	delayms(1);			// 1 millisec delay
	Enable = 0;
	delayms(1);			// 1 millisec delay
}

/******************************************* delayms Function declaration***********************************************/
void delayms(unsigned int value)
{
	unsigned int i,j;
		
	for(i=0;i<=value;i++)
	{
		for(j=0;j<100;j++)
		_nop_();		 // no operation produce 1us time delay
	}
	
}

5.2 Output in proteus software for program 1.2

Figure 1.5 displaying different animated custom characters on LCD using proteus simulation software.

8051 based 16x2 LCD interfacing in 4-bit mode without using busy status flag

2012-08-29T06:55:00.000-07:00

1. Introduction 4-bit LCD interface:

The 4-bit mode LCD interface requires four data lines and two or three control lines. In this tutorial, 16x2 LCD interfaced with 8051 microcontroller in 4-bit mode without using busy status flag. In 4-bit mode LCD interface, MCU sends the data or command byte in two 4-bit bus transfers to LCD as nibbles. A nibble is 4bit data, which is half a byte.

2. Hardware interface with 8051 Circuit:

Figure 1 LCD Hardware interface with 8051 circuit.

In the above figure, the port0 upper four lines of the 8051 microcontroller is connected to data lines (D4-D7) of the LCD. In 8051 microcontroller, the port0 doesn’t have the internal pull-up resistors and all these port0 pins are open drain configuration. So we need to connect an external pull-up resistor to each port pin to improve the driving capability of the port0. The pull-up resistor values should be between 4.7kohms to 10kohms as recommended in the data sheet of the microcontroller.

The control pins (Enable, R/W, RS) of the LCD are connected to port2 of the 8051MCU (P2.2, P2.1, P2.0) respectively.

A 10k preset is connected at 3^rd pin of the LCD to vary the contrast of the LCD. The 10k value is better chosen that not to vary the contrast drastically (If we use 1k or below preset value, the variation of the contrast is very drastic which make the operation of preset more sensitive). The 1k resistor is connected in series with 10k preset, which will limit the maximum current flow when the preset wiper is at its minimum position. A reset circuit made up of resistor and capacitor which is connected at 9^th pin of the microcontroller and it is named as power on reset. This reset circuit is used to apply a proper reset pulse after the power supply is settled down, hardly it takes 100 milliseconds (TC = 10uf*10K). A clock circuit of 12Mhz with two 33pF capacitors are connected at the XTAL1 and XTAL2 pins.

3. LCD interface timing diagrams:

Figure 1.2 Timing diagram of LCD interface without using busy flag shows the wastage of CPU time.

In the timing diagram as shown in the figure 1.2, the data can be sent to LCD in two different 4-bit transfers. Hence two enable pulses are shown for each byte transfer. During the data or command transfer to LCD, the higher nibble (D7-D4) of a byte should be transferred first. After the command or data byte is transferred, the LCD will take some time to process it. A time delay N milliseconds should be provided to LCD for internal processing. Here I provided 100 milliseconds as time delay between each byte transfer (Check out the source code below). If delay is not provided between each byte transfers, the LCD will not accept the second byte until the first byte is completed. Therefore the LCD will not show desire output to user.

The main disadvantage of this procedure is unnecessary wastage of CPU or MCU time, because there is no exact time provided in the data sheet that an LCD will take to process the command or data. This can be solved by using busy status flag which is discussed in next tutorial.

“8051 based 8-bit mode 16x2 LCD interfacing using busy status flag”

4. Description about the LCD functions used:

There are five functions are implemented in embedded c (keil c). In each function, the data byte is divided into two parts (nibbles) by using logical masking, and then transferred. The higher nibble is transferred first and then lower nibble.

1. Send_cmd() à Microcontroller send command to LCD using “send_cmd()” function, in which the RD and R/W signals both are at logic low.

2. Send_string() à Data string can be sent to LCD using this “Send_string()” function, in which the RS should be at logic high and R/W should be at logic low. When the number of characters in a string is greater than display size (> 16 characters) then the function “send_string()” will automatically shifts the display to right side.

3. Send_char()à Using this function, we can send single char at a time.

4. delayms(1)à this function generates 1ms delay approximately and it is tested in keil software. It uses a new function _nop_(), which generates 1us time delay and it available in intrins.h header file.

5. LCD_Init() àby using this function, LCD is configured as 2 line with 5x7 matrix. This function makes the LCD display ON with cursor blinking and also has automatic cursor increment to right side. The commands used in this function are 0x83, 0x01, 0xc0. 0x80. Refer table 1.1 for description about the commands.

5. LCD Commands used:

In this tutorial basic commands are used to display alpha numeric characters on LCD. A list of LCD commands used in this tutorial shown in the table 1.1

S.No	Command	Description
1	0x01	Clear Display Screen
2	0x28	Configuring LCD as 2 line 5x7 matrix in 4-bit mode
3	0x0E	Display on, cursor blinking
4	0x06	Increment cursor right side
5	0x80	Force cursor to beginning of 1st line, if the number is 0x85 then force the cursor to 5th position
6	0xC0	Force cursor to beginning of 2nd line
7	0x1C	Shift the display to right side
8	0x02	Return Home
9	0x30	Configure LCD as 1-line 5x7 matrix

6. Keil c code for LCD interface with 8051 microcontroller:

/******************************************************************************************************************************/
//http://www.npeducations.com
//LCDwithDelay.c - implementing the 4-bit mode LCD interface with 89s52 microcontroller using delay
// Author - lovakiranvarma, (M.tech)
/******************************************************************************************************************************/
/********************************************** Header Files Declaration ******************************************************/
#include
#include
#include

/********************************************* LCD control signals declaration *************************************************/

sbit RS = P2^0;     // Register Select line
sbit RW = P2^1;  // Read/write line
sbit Enable = P2^2; // Enable line
sbit LED = P2^5;
#define LCD_PORT P1

/********************************************* LCD function prototypes *********************************************************/

void send_cmd(unsigned char);
void send_string(unsigned char*);
void delayms(unsigned int);
void send_Char(unsigned char);
void LCD_Init(void);

/********************************************* Main Funciton declaration *******************************************************/

void main()
{

P1 = 0x00;
P2 = 0x00;
/********************************************* LCD reset Process sequence as per datasheet***************************************/
delayms(15); // wait for more than 15ms after supply rises to 4.5V
send_cmd(0x30);
delayms(4);  // wait more than 4.1ms
send_cmd(0x30);
delayms(1);  // wait more than 100us, but delayms(1) will provide 1ms
send_cmd(0x30);
delayms(1);
send_cmd(0x02); // return to home
delayms(1);

LCD_Init();
   

 while(1)
 {
  send_cmd(0x80);       // Force cursor to beginning of 1st line, if the number is 0x85 then force the cursor to 5th position
  delayms(1);
  //send_Char('A');    // displays at first line
  //delayms(5);
  send_string("npeducations");  
  delayms(50);
  send_cmd(0xC0);       // Force cursor to beginning of 2nd line
  delayms(1);
  send_string("http://www.npeducations.com"); // displays at first line
  delayms(20);
  send_cmd(0x01);       // Force cursor to beginning of 2nd line
                        
 }

}

void LCD_Init()
{

 send_cmd(0x28);       // configuring LCD as 2 line 5x7 matrix in 4-bit mode
 delayms(1);
 send_cmd(0x0C);       // Display on, Cursor blinking
 delayms(1);
 send_cmd(0x01);       // Clear Display Screen
 delayms(1);
 send_cmd(0x06);       // Increment Cursor (Right side)
 delayms(1);

}


/*********************************************LCD Command Sending Function declaration*******************************************/

void send_cmd(unsigned char Command)
{
 unsigned char ch=0;

    LCD_PORT &= 0x00; // make upper bits of port as zero
 LCD_PORT =(Command);    //mask lower nibble and send upper nibble
 RS = 0;      // Select Command Register
 RW = 0;    // write operation
 Enable = 1;      // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
 delayms(1);
 Enable = 0;
 delayms(1);
 
 LCD_PORT &= 0x00; // make upper bits of port as zero
 
 LCD_PORT =(Command<<4); // upper nibble

 RS = 0;    // Select Data Register
 RW = 0;    // write operation
 Enable = 1;      // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
 delayms(1);
 Enable = 0;
 delayms(1);

}
/******************************************* LCD data sending Function declaration************************************************/

void send_string(unsigned char *String)
{
unsigned char i=0, ch=0, temp=0;

while(String[i]!='\0')
{
     
 temp = String[i++];

 LCD_PORT &= 0x00; // make upper bits of port as zero
 LCD_PORT = (temp);    //mask lower nibble and send upper nibble

 RS = 1;    // Select Data Register
 RW = 0;    // write operation
 Enable = 1;      // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
 delayms(1);
 Enable = 0;
 delayms(1);

 
 LCD_PORT &= 0x00; // make upper bits of port as zero
 
 LCD_PORT = ((temp<<4)); // lower nibble

 RS = 1;    // Select Data Register
 RW = 0;    // write operation
 Enable = 1;      // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
 delayms(1);
 Enable = 0;
 delayms(1);

 if(i>=16)
 send_cmd(0x1C);   
 delayms(100); 

}
 
 return;

}
/******************************************* LCD single character sending Function declaration************************************/

void send_Char(unsigned char character)
{
unsigned char ch=0;
             
 LCD_PORT &= 0x00; // make upper bits of port as zero
 LCD_PORT = (character);    //mask lower nibble and send upper nibble

 RS = 1;      // Select Command Register
 RW = 0;    // write operation
 Enable = 1;      // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
 delayms(1);
 Enable = 0;
 delayms(1);

 
 LCD_PORT &= 0x00; // make upper bits of port as zero
 
 LCD_PORT = ((character<<4)); // lower nibble
 RS = 1;    // Select Data Register
 RW = 0;    // write operation
 Enable = 1;      // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
 delayms(1);
 Enable = 0;
 delayms(1);

 delayms(100);
 

}

/******************************************* delayms Function declaration *******************************************************/
void delayms(unsigned int value)
{
 unsigned int i,j;
  
 for(i=0;i<=value;i++)
 {
  for(j=0;j<100;j++)
  _nop_();   // no operation produce 1us time delay
 }
 
}

7. Proteus simulation Circuit:

A Proteus simulation circuit output of LCD interface with 8051 microcontroller without using busy flag is shown in figure 1.3.

Figure 1.3 Proteus simulation circuit output of LCD interface with 8051 microcontroller in 4-bit mode without using busy flag

8. Assembly program:

8051 based 16x2 LCD interfacing in 8-bit mode without using busy status flag

2012-08-27T10:43:00.001-07:00

1. Introduction LCD interface:

Interfacing 16x2 character LCD with 8051 microcontroller is simple and easy. There are two modes that 16x2 LCD can operate. 8-bit mode uses eight data lines and three control lines whereas 4-bit mode uses four data lines and two or three control lines. In this tutorial, 16x2 LCD interfaced with 8051 microcontroller in 8-bit mode without using any hardware busy status check. In 8-bit mode LCD interface, the data or command transferred via 8-bit bus lines of LCD (D0-D7).

2. Hardware interface with 8051 Circuit:

Figure 1.1 Circuit diagram of LCD interface with 8051 in 8-bit mode

In the above figure, the port0 of the 8051 microcontroller is connected to data lines (D0-D7) of the LCD. In 8051 microcontroller, the port0 doesn’t have the internal pull-up resistors and all these port0 pins are open drain configuration. So we need to connect an external pull-up resistor to each port pin to improve the driving capability of the port0.

The control pins (Enable, R/W, RS) of the LCD are connected to port2 of the 8051MCU (P2.2, P2.1, P2.0) respectively.

A 10k preset is connected at 3^rd pin of the LCD to vary the contrast of the LCD. The 10k value is better chosen that not to vary the contrast drastically (If we use 1k or below preset value, the variation of the contrast is very drastic which make the operation of preset sensitive). The 1k resistor is connected in series with 10k preset, which will limit the maximum current flow when the preset value is at its minimum position. A reset circuit made up of resistor and capacitor is connected at 9^th pin of the microcontroller and it is named as power on reset. This reset circuit is used to apply a proper reset pulse after the power supply is settled down. A clock circuit of 12Mhz with two 33pF capacitors are connected at the XTAL1 and XTAL2 pins.

3. LCD interface timing diagrams:

In this tutorial we are not using any busy status flag, means no read operations. Hence only write operation timing diagrams are shown in figure 1.2.

Figure 1.2 Timing diagram of LCD interface without using busy flag shows the wastage of CPU time.

The above timing diagram shows four signals (ENABLE, RS, R/W, D0-D7), with two types of information on the LCD bus lines.

1. Command

2. Data byte

The RS and R/W signals must be low while Command is sent to LCD, whereas during data byte transmission the RS signal must be high and R/W must be low as shown in the figure.

When command or data is sent to the LCD, it takes some time to process it internally. Hence, the microcontroller should wait N milliseconds and then send next command or data, for this purpose a delay of N milliseconds is introduced between each command or data byte transmission. Here, I have taken 100milliseconds time as delay between each byte transmission.

The main disadvantage of this procedure is unnecessary wastage of CPU or MCU time, why because there is no exact time that an LCD will take to process the command or data. This can be solved by using busy status flag which is discussed in next tutorial.

“8051 based 8-bit mode 16x2 LCD interfacing using busy status flag”

4. Description about the LCD functions:

There are two functions are implemented in embedded c (keil c).

Send_cmd() à this function sends command to LCD controller (HD44780U) in hexadecimal. When command is to be written into LCD, the RS and R/W lines both should be at logic low and high to low strobe must be given at enable pin with enable pulse width greater than 450ns. The enable cycle time must be greater than 1000ns.

Send_data() à this function sends string of characters to LCD controller, during which the RS should be at logic high and R/W should be at logic low. A high to low strobe must be given at enable pin (pulse width should be >450ns). This function is written in such a way that, when the number of characters in a string is greater than display size (> 16 characters) then it automatically right shifts the display.

Send_char() à this function sends a single character at a time to LCD controller by making RS=1 and R/W =0. The negative edge (High to Low) triggering should be applied at enable pin.

Delayms(1) à this function generates 1ms delay approximately and it is tested in keil software. It uses a new function _nop_(), which generates 1us time delay and it available in intrins.h header file.

LCD_Init() àby using this function, LCD is configured as 2 line with 5x7 matrix. This function makes the LCD display ON with cursor blinking and also has automatic cursor increment to right side.

5. LCD Commands used:

In this tutorial basic commands are used to display alpha numeric characters on LCD. A list of LCD commands used in this tutorial shown in the table 1.1

S.No	Command	Description
1	0x01	Clear Display Screen
2	0x38	Configuring LCD as 2 line 5x7 matrix
3	0x0E	Display on, cursor blinking
4	0x06	Increment cursor right side
5	0x80	Force cursor to beginning of 1st line, if the number is 0x85 then force the cursor to 5th position
6	0xC0	Force cursor to beginning of 2nd line
7	0x1C	Shift the display to right side

Table 1.1 list of Basic LCD commands

6. Proteus simulation Circuit:

A Proteus simulation circuit output of LCD interface with 8051 microcontroller without using busy flag is shown in figure 1.3

Figure 1.3 Proteus simulation circuit output of LCD interface with 8051 microcontroller without using busy flag

7. Keil c code for LCD interface with 8051 microcontroller:

 
/***************************************************************************************************************************/
// http://www.npeducations.com
// LCDwithDelay.c - implementing the LCD interface in 8-bit mode with 89s52 microcontroller using delay
// Author - lovakiranvarma, (M.tech)
/***************************************************************************************************************************/
/********************************************** Header Files Declaration ***************************************************/
#include
#include
#include
/********************************************* LCD control signals declaration ***************************************************/

sbit RS = P2^0;     // Register Select line
sbit RW = P2^1;  // Read/write line
sbit Enable = P2^2; // Enable line
#define LCD_PORT P0 // define port

/********************************************* LCD function prototypes ************************************************/
void send_cmd(unsigned char);
void send_data(unsigned char*);
void send_char(unsigned char);
void LCD_init(void);
void delayms(unsigned int);
/********************************************* Main Funciton declaration ***********************************************/
void main()
{

LCD_PORT = 0x00; // Make the port as output port
  
 LCD_init();            // LCD initialization
 
 while(1)
 {
  send_cmd(0x83);     // Force cursor to beginning of 1st line, if the number is 0x83 then force the cursor to 53rd position
  delayms(100);    // Delay of 100millisec
  send_data("NPEDUCATIONS");  // Send data string
  delayms(500);    // Delay of 0.5sec
  send_cmd(0xC0);     // Force cursor to beginning of 2nd line
  delayms(100);    // Delay of 100millisec
  send_data("http://www.npeducations.com"); // send data string
  delayms(500);    // Delay of 0.5sec
  send_cmd(0x01);     // Clear display
  delayms(100);    // Delay of 100millisec
  send_cmd(0x80);    // Force cursor to beginning of 1st line
  delayms(100);    // Delay of 100millisec
  send_char('A');    // testing send_char position
  delayms(500);    // Delay of 0.5sec
  send_cmd(0x01);     // Clear display
  delayms(100);    // Delay of 100millisec
                        
 }

}


/********************************************* LCD Initialization Function declaration ********************************/

void LCD_init()
{
 send_cmd(0x38);      // configuring LCD as 2 line 5x7 matrix
 send_cmd(0x0E);      // Display on, Cursor blinking
 send_cmd(0x01);      // Clear Display Screen
 send_cmd(0x06);      // Increment Cursor (Right side)
}

void send_char(unsigned char character)
{
 LCD_PORT = character;
 RS = 1;    // Select Data Register
 RW = 0;    // write operation
 Enable = 1;      // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
 delayms(1);   // 1 millisec delay
 Enable = 0;
 delayms(100);   // 100 millisec delay
 

}


/*********************************************LCD Command Sending Function declaration********************************/

void send_cmd(unsigned char Command)
{
 LCD_PORT = Command;
 RS = 0;      // Select Command Register
 RW = 0;    // write operation
 Enable = 1;      // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
 delayms(1);   // 1 millisec delay
 Enable = 0;

}

/******************************************* LCD data sending Function declaration*************************************/

void send_data(unsigned char *String)
{
unsigned char i=0;

 while(String[i]!='\0')
 {
     
  LCD_PORT = String[i++];
  RS = 1;    // Select Data Register
  RW = 0;    // write operation
  Enable = 1;   // High to Low pulse provided on the enable pin with nearly 1ms(>450ns)
  delayms(1);   // 1 millisec delay
  Enable = 0;
  if(i>=16)   // If the number of characters in the string > 16, then the below command automatically 
  send_cmd(0x1C);  // Shift the display right side 
  delayms(100);   // 100 millisec delay
 }
 
}

/******************************************* delayms Function declaration***********************************************/
void delayms(unsigned int val)
{
 unsigned int i,j;
  
 for(i=0;i<=val;i++)
 {
  for(j=0;j<=100;j++)
  _nop_();   // no operation produce 1us time delay
 }
 
}

OUTPUT on 16x2 LCD:

8051 Serial port debugging and testing without RS 232 cable

2012-08-24T12:45:00.001-07:00

8051 Serial port debugging and testing without RS 232 cable and Microcontroller IC

Make Serial port debugging and testing without any circuit. With the help of keil simulator and any virtual comport software used to test serial port of 8051 microcontroller.

The people (beginners) new to the 8051 microcontroller will face so many problems while dealing with the serial data transfer using serial port in 8051. They will made mistake by preparing the hardware circuit for the serial port using max232 and then they will write program code for serial data transfer by configuring the 8051 serial port. Finally they test the 8051 serial port functionality by changing both the program code and hardware. Generally beginners think that the problem may be in hardware circuit or it may be in the program code, when they don’t have any confidence in the program code or the hardware circuit of 8051 serial port. And they simple waste the time by repeatedly checking the hardware circuit or the program code.

First of all, test your serial port program code by using simulated software like keil and make sure that you don’t have any problem with the program code. By doing so you will have confidence there is no problem with my program code. Therefore you now only concentrate on the hardware circuit testing. This may reduces the debugging time of your application.

In this tutorial, I have introduced a technique to test the serial port of 8051 microcontroller without building the circuit. You don’t need two computers to test the serial data transfer between them. You don’t need any hardware simulated circuit to be design using simulating software like proteus. You can test your program code for 8051 serial port by using your keil debugger software and virtual serial com port software.

The software tools required for this testing are

1) Keil microvision C51 (https://www.keil.com/download/product)

2) Virtual serial port driver(http://download.cnet.com/Virtual-Serial-Port-Driver/3000-2094_4-42473.html)

Step1: Your program code:

Here I have written the 8051 programming for serial port in assembly language. The code itself demonstrates that it receives a character and again the same character is send via serial port using interrupt method.

ORG 0000h
LJMP Main_Label    ;redirect the CPU control to some other location

ORG 0023h
JNB RI, en    ;Check whether the interrupt is occurred on the reception of character,
              ; if not the interrupt is due to transmission of character
             MOV A, SBUF; read received character into A register.
             CLR RI     ; make RI flag to zero
             MOV SBUF,A ; transfer the received character
en:     nop
             CLR TI     ; make TI flag to zero, TI = 1 --> character is transfered,
                       ;TI = 0 --> transmitter buffer is ready to receive next character
             RETI

             ORG 0100h
Main_Label:  MOV SCON, #50h  ; initialize SCON register with reception enable
             MOV TMOD, #20h  ; initialize TMOD register
             MOV TH1, #0FDh  ; load timer 0 with FD for 9600 bits/sec baud rate.
             MOV IE, #90h
             CLR RI          ; make RI flag to zero
             SETB TR1        ; start timer0
Back:        nop             ; nothing will happen
             SJMP Back       ; infinite loop
                                               

END.

Step2: Install virtual com port software and create two virtual com ports by using it. Here I created com1 and com2 as two virtual com ports as shown in figure1.1.

Before installing the software, check your HyperTerminal program that it will not show any of these virtual com ports created by the virtual com port software except available physical com ports. Laptops don’t have any physical com port available outside; therefore you need a USB to RS232 converter. These USB to RS232 drivers will show the physical comports for your laptop. If USB to RS232 drivers are not installed in your laptop then the HyperTerminal will show only TCP/IP port.

Figure 1.1 Show the virtual serial Port Driver window with two virtual ports

Step3: make the keil debugger as one virtual serial com port by using two commands

1. Mode com2 9600,0,8,1

2. Assign com2 <sin> sout

The first command is used to configure the virtual serial com port in keil.

The second is used to assign the input and output register for serial data transfer. SIN and SOUT are two virtual registers representing the SBUF register for transmission and reception.

Here I use com2 as virtual com port in keil. But you people can use any of the virtual comports available in your computer or laptop.

First enter into debugger of keil by pressing ctrl+F5 or go the menuà bebug. The above two commands must be entered one by one in the command window of the keil IDE as shown in the below figure 1.2. You can directly copy the command into the command window or you can type it. While you typing the command you will get help about the command. If you type the first command then press enter and then type the second command as shown in figure 1.2.

Figure 1.2 shows commands are used to make keil simulator work as serial port of 8051.

Step4: open your HyperTerminal with other virtual comport which is not used in the keil debugger. Here I used the com2 for keil debugger; therefore com1 is used to connect the HyperTerminal. Now type the characters on the HyperTerminal will reflected back as shown below figure 1.3.

Figure 1.3 shows that character typed on the HyperTerminal is echoing back due to serial port program is running in keil debugger.