About LCD and Its Interfacing

Electronic Display are important Devices used in the field of Robotics and Embedded System and its devices. the display Seven Segments, LCD (Liquid Crystal Display) can be used to display Data .  The reasons being: LCDs are economical, easily programmable, have no limitation of displaying special & even custom characters (unlike in seven segments), animations and so on. LCD can be easily interfaced with a microcontroller to display a message or status of a device. They are of many types. The ones we commonly use for embedded systems, robotics, etc are of two types – character LCD and graphical LCD. lcd162b-yhy

A 16x2 LCD means it can display 16 characters per line and there are 2 such lines. In this LCD each character is displayed in 5×7 pixel matrix. This LCD has two registers.

  • Command/Instruction Register - stores the command instructions given to the LCD. A command is an instruction given to LCD to do a predefined task like initializing, clearing the screen, setting the cursor position, controlling display etc
  • Data Register - stores the data to be displayed on the LCD. The data is the ASCII value of the character to be displayed on the LCD.

 

lcd cammand

 

Now the Pin Map

rgblcd_pinout

Lcd_0

  •  Data pin8 (DB7) of the LCD is busy flag and is read when R/W = 1 & RS = 0. When busy flag=1, it means that LCD is not ready to accept data since it is busy with the internal operations. Therefore before passing any data to LCD, its command register should be read and busy flag should be checked.
  •  To send data on the LCD, data is first written to the data pins with R/W = 0 (to specify the write operation) and RS = 1 (to select the data register). A high to low pulse is given at EN pin when data is sent. Each write operation is performed on the positive edge of the Enable signal.
  •   To send a command on the LCD, a particular command is first specified to the data pins with R/W = 0 (to specify the write operation) and RS = 0 (to select the command register). A high to low pulse is given at EN pin when data is sent.

 

Arduino Liquid Crystal Library LCD Interface

Requirements :-

  • LCD 16×2
  • 1 Potentiometer
  • Jumperwire
  • Arduino Board
  • Bread board
  • Usb wire
  • Arduino IDE
  • Battery

 

All the product you can Buy From here

In this tutorial you will control a Liquid Crystal Display (LCD) using the Arduino LiquidCrystal library. The library provides functions for accessing any LCD using the common HD44780 parallel interface chipset, such as those available from Sparkfun.It currently implements 8-bit control and one line display of 5×7 characters. Functions are provided to initialize the screen, to print characters and strings, to clear the screen, and to send commands directly to the HD44780 chip. This tutorial will walk you through the steps of wiring an LCD to an Arduino microcontroller board and implementing each of these functions.

Install the Library
For a basic explanation of how libraries work in Arduino read the library page. Download the LiquidCrystal library here. Unzip the files and place the whole LiquidCrystal folder inside your arduino-0004\lib\targets\libraries folder. Start the Arduino program and check to make sure LiquidCrystal is now available as an option in the Sketch menu under “Import Library”.

Connect Pin Out of arduino to LCD

The pinout is as follows:
Arduino                    LCD
2                             Enable
3                             Data Bit 0 (DB0)
4                             (DB1)
5                             (DB2)
6                             (DB3)
7                             (DB4)
8                             (DB5)
9                             (DB6)
10                           (DB7)
11                           Read/Write (RW)
12                           Register Select (RS)

Connect a potentiometer a a voltage divider between 5V, Ground, and the contrast adjustment pin on your LCD.

LCDAR

 

Program

 

#include <LiquidCrystal.h> //include LiquidCrystal library
LiquidCrystal lcd = LiquidCrystal(); //create a LiquidCrystal object to control an LCD
void setup(void){
lcd.init(); //initialize the LCD
digitalWrite(13,HIGH); //turn on an LED for debugging
}
void loop(void){
lcd.clear(); //clear the display
delay(1000); //delay 1000 ms to view change
lcd.print(‘a’); //send individual letters to the LCD
lcd.print(‘b’);
lcd.print(‘c’);
delay(1000);//delay 1000 ms to view change
}

 

This is all great fun, but who really wants to type out each letter of a message indivually? Enter the printIn() function. Simply initialize a string, pass it to printIn(), and now we have ourselves a proper hello world program.
#include <LiquidCrystal.h> //include LiquidCrystal library
LiquidCrystal lcd = LiquidCrystal(); //create a LiquidCrystal object to control an LCD
char string1[] = “Hello!”; //variable to store the string “Hello!”
void setup(void){
lcd.init(); //initialize the LCD
digitalWrite(13,HIGH); //turn on an LED for debugging
}
void loop(void){
lcd.clear(); //clear the display
delay(1000); //delay 1000 ms to view change
lcd.printIn(string1); //send the string to the LCD
delay(1000); //delay 1000 ms to view change
} //repeat forever
Finally, you should know there is a lot of functionality in the HD44780 chip interface that is not drawn out into Arduino functions. If you are feeling ambitious glance over the datasheet and try out some of the direct commands using the commandWrite() function. For example, commandWrite(2) tells the board to move the cursor back to starting position. Here
is an example:
#include <LiquidCrystal.h> //include LiquidCrystal library
LiquidCrystal lcd = LiquidCrystal(); //create a LiquidCrystal object to control an LCD
char string1[] = “Hello!”; //variable to store the string “Hello!”
void setup(void){
lcd.init(); //initialize the LCD
digitalWrite(13,HIGH); //turn on an LED for debugging
}
void loop(void){
lcd.commandWrite(2); //bring the cursor to the starting position
delay(1000); //delay 1000 ms to view change
lcd.printIn(string1); //send the string to the LCD
delay(1000); //delay 1000 ms to view change
} //repeat forever

Using DC Gear Motor

Whenever a robotics we talk about making a robot, the first thing comes to our mind is how Robot will move (How its motion part work).  there are always three options in front of the us, one is to  use a DC Gear motor , second is to use a stepper motor and third one is to use servo motors. When we think about  speed, weight, size, cost… DC motors are always preffered over stepper motors and servo motors. There are many things which we can do with  DC motor when we interfacing it with a microcontroller.

DC-Geared-Motor

 

  •  Control the speed of motor.
  •  Control the direction of rotation
  •  Using encoder, keeping track of how many turns are made by  motors.

Here we will work on interfacing a DC motor with a microcontroller. we will use H-bridge in interfacing a DC moto with microcontroller. Some Ic that are used to interface a DC motor with microcontroller are-

H-bridge can also be made with the help of trasistors and MOSFETs etc. rather of being cheap, they only increase the size of the design board, which is somtimes not required so using a small 16 pin IC is preffered for this purpose.

Why we are using Motor Driver for controlling motor. the perfect Ans of thing question is As microcontroller is running with small current and to run a motor need high current in compare to microcontroller  for that purpose we are using Motor Driver.

Most DC motors are normally very easy to reverse. By simply changing the polarity of the DC input, the direction of the drive shaft reverses. This property makes DC motors very popular among enthusiast people involved in robotics. In most cases, DC geared motors are used.

motor driver block

 

As in diagram shown we can run two motors with the help of 1 L293D Driver.

the following Features are available in a L293D

  •  two enable (EN) pins, pin 1 and pin 9. Pin 1 EN enables the motor Channel  M1 whereas pin 9 EN enables motor Channel M2.
  • Connect motor M1 across OUTPUT1 and OUTPUT2 i.e. across pins 3 and 6.
  • Connect motor M2 across OUTPUT3 and OUTPUT4 i.e. across pins 11 and 14.
  • The inputs for motor M1 is given across INPUT1 and INPUT2 i.e. across pins 2 and 7.
  • The inputs for motor M2 is given across INPUT3 and INPUT4 i.e. across pins 10 and 15.
  • Connect GROUND pins 4, 5, 12 and 13 to ground also work for heat sink.
  • Connect pin 16 to Vcc (=5V For Running Driver) and pin 8 to Vs (battery, 4.5V~36V)(Motor Operating voltage).

 

l293d pin diagram

 

  • If Input A1 = 0V and input A2 = 5V the motor1 will run Forward
  • If Input A1 = 5V and input A2 = 0V the motor1 will run Reverse
  • If Input A1 = 0V and input A2 = 0V Or  Input A1 = 5V and input A2 = 5V  the motor will Stop(0V) Or Breaking(5V).

motor clock

Same Situation will be occur for second channel

DC Gear Motor Using With Arduino

The Motor drive’s channel one is connected to pin 6 ,  9 to motor control and pin 8 for enable motor. and a potentiometer is connected to Analog 0 Pin for controlling the speed of motor.diy-servo-wiring

Program

int motor1Pin = 6;    // H-bridge leg 1 (pin 6, 1A)
int motor2Pin = 9;    // H-bridge leg 2 (pin 9, 2A)
int enablePin = 8;    // H-bridge enable pin
int switchPin = A0;
int Motor_speed = 0;

 void setup()                                                                    {   // set the switch as an input:

    pinMode(switchPin, INPUT);
    // set all the other pins you're using as outputs:
    pinMode(motor1Pin, OUTPUT);
    pinMode(motor2Pin, OUTPUT);
    pinMode(enablePin, OUTPUT);
    // set enablePin high so that motor can turn on:
    digitalWrite(enablePin, HIGH);
  }
void loop() {

    Motor_speed = analogRead(sensorPin);
       analogWrite(motor1Pin, Motor_speed );   // For motor run clockwise with speed //adjusted by potentiometer
        digitalWrite(motor2Pin,0);
       delay(10000);
     analogWrite(motor2Pin, Motor_speed );     // For motor run Anticlockwise with speed //adjusted by potentiometer
        digitalWrite(motor1Pin,0);
  }
DC Gear Motor Using With AVR Microcontroller
Generating Signals for controlling the direction of motor using Port A
Motot is connected to Port A at Pin PA0, PA1, PA2 and PA3.
                               Port A Avr

#include <avr/io.h>
#include <util/delay.h>          // for _delay_ms()

int main(void)
{
DDRA = 0x0F; // initialize port A
// motors connected across PA0…PA3
while(1)
{
// clockwise rotation
PORTA = 0b00000101; // PA0 = High = Vcc
// PA1 = Low = 0
// PA2 = High = Vcc
// PA3 = Low = 0

_delay_ms(500); // wait 0.5s

// counter-clockwise rotation
PORTA = 0b00001010; // PA0 = Low = 0
// PA1 = High = Vcc
// PA2 = Low = 0
// PA3 = High = Vcc

_delay_ms(500); // wait 0.5s
}
}

Here a Video of a Robot that is developed by using DC Gear Motor

[https://www.youtube.com/watch?v=lhk7XxzQQtY]

Avr Tutorial

AVR-Studio-6-Splash

Avr Studio is IDE is used for programming Avr and Arm two different architectures. Atmel has been manufacturing a lot of ARM Cortex-M and wanted to give its users seamless and easy-to-use environment to write, build and debug their applications written in C/C++ or assembly code. the introduction and creating a new project is describe in this Video.

[https://www.youtube.com/watch?v=iTTZUpzAjKc]

Before going to programming part we should learn about Pin configuration of microcontrollers. First thing is that we need to know that which microcontroller we used. in this tutorial we will use Atmega 8, Atmega 16, Atmega 32, Atmega 168, Atmega 328.  below there is pin map of   Atmega 16 and Atmega 32 microcontroller. both microntroller are 8 bit microcontroller with 40 pin configuration.

ATMEGA32-pinout

As we can see from PinMap image there are 4 Ports named asPortA, PortB, PortC and PortD. The Datasheet of Atmega16_32

atmega

Note:-  ATMEGA16 and ATMEGA32 MCUs are completely similar, except the fact that ATMEGA16 has 16KB Flash, 1KB RAM and 512B EEPROM whereas ATMEGA32 has 32KB Flash, 2KB RAM and 1KB EEPROM.

Each port consist of 8 Pin 0-7. these are 8 digital Input and output pins.with this port A can also be used as analog to digital convertors pinsnamed as ADC0 – ADC7.

There are Three registers DDRx , PINx and PORTx that are important for digital input / Output operation of AVR microcontrllers.

Selecting the direction of pin:-  DDRx bit  selects the direction of this pin.

  • DDRx =1, Portx nth pin is configured as an output pin (since there are eight pins in all in a particular port so ‘n’ can be any number between 0-7).
  • DDRx=0, Portx nth is configured as an input pin.

DDRA

The ‘x’ in DDRx is just for representation. It is replaced by the corresponding port i.e. x = A, B, C, D. Say for the example shown in the diagram above.

DDRA = (1<<DDA2) | (1<<DDA4) | (1<<DDA5);

Same as  DDRA = 0b00110100;

Now we had done with declaration of Port A pin 2, 4 and 5 as output.

PORTx Register -: This port determine the status of output pins of Port x. if the pin x of a port is defined as output pin than this register tell the value of that pin.PIN

this register declare same as DDR

PORTA = (1 << PA1) | (1 << PA3) | (1 << PA6) ;

PORTA = (1 << 1) | (1 << 3) | (1 << 6) ;

PORTA = 0b01001010;

PINx Register: this register is used for reading data from microcontroller pins.

PINx

 

Note : By default all pins of microcontroller declare as input pins.

DDRC = 0b01001000;

PINC = 0b10110111;

Sample code :

#include <avr/io.h>                                      // Includes all the definition of register port etc  #ifndef F_CPU                                                                                                                  #define F_CPU 16000000UL      //Need to include it before <util/delay.h>                            #endif                              //Change 16000000 with your crystal freq. In my case its16 MHz  #include <util/delay.h>    //includes delay functions delay_ms and delay_us                      int main(void)                                                                                                                           {                                                                                                                                   DDRD|= 0xFF; //Configured Port D as Output                                                                    while (1)                                                                                                                                    {                                                                                                                                                 PORTD |= 0xFF; //Output logic 1 on all the pins of Port D

_delay_ms(1000);//1 sec delay

PORTD &= 0×00; //Output logic 0 on all the pins of Port D

_delay_ms(1000); //1 sec delay

}

}