Department of Information Technology

Lab
Manual

16IT612
EMBEDDED SYSTEMS LABORATORY
 [Link] OF ARM EVALUATION SYSTEM
AIM:
To study of ARM processor system and describe the features of architecture.
ARCHITECTURE OF ARM PROCESSOR:
Features of ARM DEVELOPMENT KIT Processor:
 16-bit/32-bit ARM7TDMI-S microcontroller in a tiny LQFP64 package.8 kB to
40 kB of on-chip static RAM and 32 kB to 512 kB of on-chip flash memory. 128-
bit wide interface/accelerator enables high-speed 60 MHz operation. In- System/In-
Application Programming (ISP/IAP) via on-chip boot loader software.
 Single flash sector/full chip erase in 400 ms and programming of 256 bytes in 1
[Link] 2.0 Full-speed compliant device controller with 2 kB of endpoint RAM.
The LPC2146/48 provides 8 kB of on-chip RAM accessible to USB by DMA.
 One or two (LPC2141/42 vs. LPC2144/46/48) 10-bit ADCs provide a total of 6/14
analog inputs, with conversion times as low as 2.44 µs per channel. Single 10-bit
DAC provides variable analog output (LPC2142/44/46/48 only).Two 32-bit
timers/external event counters (with four capture and four compare channels
each), PWM unit (six outputs) and watchdog.
 Low power Real-Time Clock (RTC) with independent power and 32 kHz clock
input. Multiple serial interfaces including two UARTs (16C550), two Fast I2C-
bus (400 kbit/s), SPI and SSP with buffering and variable data length capabilities.
 Vectored Interrupt Controller (VIC) with configurable priorities and vector
[Link] to 45 of 5 V tolerant fast general purpose I/O pins in a tiny LQFP64
[Link] to 21 external interrupt pins available.
 60MHz maximum CPU clock available from programmable on-chip PLL with
settling time of 100µ[Link]-chip integrated oscillator operates with an external
crystal from 1 MHz to 25 [Link] saving modes include Idle and Power-
down.
 Individual enable/disable of peripheral functions as well as peripheral clock
scaling for additional power optimization. Processor wake-up from Power-down
mode via external interrupt or [Link] power supply chip with POR and BOD
circuits:CPU operating voltage range of 3.0 V to 3.6 V (3.3 V ± 10 %) with 5 V
tolerant I/O pads.
 General Block Diagram:

9V Input On-Board JTAG 4 Nos I2C

8 Nos. 2x16 LCD

USB 2.0 DAC Output

Temperature Sensor Relay/Motor

I2C RTC
4X4 Matrix
LPC 2148

40Pin Expansion 128x64 GLCD

Connector

On-Board Analog 4-way Traffic

Inputs

Buzzer / PS/2 Two 8 Nos. 2x RS232

Power Supply:

 The external power can be AC or DC, with a voltage between (9V/12V, 1A output)
at 230V AC [Link] ARM board produces +5V using an LM7805 voltage
regulator, which provides supply to the peripherals.

 LM1117 Fixed +3.3V positive regulator used for processor & processor related
peripherals.

Flash Programming Utility

 NXP (Philips)

NXP Semiconductors produce a range of Microcontrollers that feature both on-chip

Flash memory and the ability to be reprogrammed using In-System Programming technology.
 Pin Configuration:

On-board Peripherals:

 8-Nos. of Point LED’s (Digital Outputs)

 8-Nos. of Digital Inputs (slide switch)
 2 Lines X 16 Character LCD Display
 I2C Enabled 4 Digit Seven-segment display
 128x64 Graphical LCD Display
 4 X 4 Matrix keypad
 Stepper Motor Interface
 2 Nos. Relay Interface
 Two UART for serial port communication through PC
 Serial EEPROM
 On-chip Real Time Clock with battery backup
 PS/2 Keyboard interface(Optional)
 Temperature Sensor
 Buzzer(Alarm Interface)
 Traffic Light Module(Optional)
RESULT:

Thus the study of ARM processor has been done and ensured its composition with internal
 features specifically.
1. Interfacing ADC and DAC

Aim:

Develop and verify the interfacing ADC and DAC with Ardunio.

Hardware Required

 Arduino or Genuino Mega Board

 12 Red LEDs
 12 220 ohm resistors
 hook-up wires
 breadboard

Circuit
Program:
const int lowestPin = 2;
const int highestPin = 4;
void setup() {
// set pins 2 through 13 as outputs:
for (int thisPin = lowestPin; thisPin <= highestPin; thisPin++) {
pinMode(thisPin, OUTPUT);
}
}

void loop() {
// iterate over the pins:
for (int thisPin = lowestPin; thisPin <= highestPin; thisPin++) {
// fade the LED on thisPin from off to brightest:
for (int brightness = 0; brightness < 255; brightness++) {
analogWrite(thisPin, brightness);
delay(2);
}
// fade the LED on thisPin from brightest to off:
for (int brightness = 255; brightness >= 0; brightness--) {
analogWrite(thisPin, brightness);
delay(2);
}
// pause between LEDs:
delay(100);
}
}
Output:
The LED’s will be gloved alternatively with different brightness levels.

Result:
Thus the ADC and DAC Interfacing was verified successfully.
 2. Interfacing LED with PWM

Aim:

Develop and verify the interfacing ADC and DAC with Ardunio.

Hardware Required

 Arduino or Genuino Mega Board

 12 Red LEDs
 12 220 ohm resistors
 hook-up wires
 breadboard

Circuit
Program:
const int lowestPin = 2;
const int highestPin = 4;
void setup() {
// set pins 2 through 13 as outputs:
for (int thisPin = lowestPin; thisPin <= highestPin; thisPin++) {
pinMode(thisPin, OUTPUT);
}
}

void loop() {
// iterate over the pins:
for (int thisPin = lowestPin; thisPin <= highestPin; thisPin++) {
// fade the LED on thisPin from off to brightest:
for (int brightness = 0; brightness < 255; brightness++) {
analogWrite(thisPin, brightness);
delay(2);
}
// fade the LED on thisPin from brightest to off:
for (int brightness = 255; brightness >= 0; brightness--) {
analogWrite(thisPin, brightness);
delay(2);
}
// pause between LEDs:
delay(100);
}
}
Output:
The LED’s will be gloved alternatively with different brightness levels.

Result:
Thus the interfacing of LED with PWM was verified successfully.
 4. INTERFACING REMOTE CONTROL WITH ARDUINO
Aim:
To develop and verify interfacing remote control with Arduino.
Hardware Required:
 Ardunio AT Mega 2560
 Infrared Receiver
 1 LED
 1K Resister
 Hookup Wires
Description:
Infrared (IR) communication is a widely used and easy to implement wireless technology that
has many useful applications. The most prominent examples in day to day life are TV/video
remote controls, motion sensors, and infrared thermometers.
WHAT IS INFRARED?
Infrared radiation is a form of light similar to the light we see all around us. The only difference
between IR light and visible light is the frequency and wavelength. Infrared radiation lies outside
the range of visible light, so humans can’t see it:

Because IR is a type of light, IR communication requires a direct line of sight from the receiver
to the transmitter. It can’t transmit through walls or other materials like WiFi or Bluetooth.

IR CODES
Each time you press a button on the remote control, a unique hexadecimal code is generated.
This is the information that is modulated and sent over IR to the receiver. In order to decipher
which key is pressed, the receiving microcontroller needs to know which code corresponds
to each key on the remote.

Different remotes send different codes for the keypresses, so you’ll need to determine the code
generated for each key on your particular remote.

CH- CH CH+ |
| FFA25D FF629D FFE21D |
| |
| |<< >>| |>|| |
| FF22DD FF02FD FFC23D |
| |
| - + EQ |
| FFE01F FFA857 FF906F |
| |
| 0 100+ 200+ |
| FF6897 FF9867 FFB04F |
| |
| 1 2 3 |
| FF30CF FF18E7 FF7A85 |
| |
| 4 5 6 |
| FF10EF FF38C7 FF5AA5 |
| |
| 7 8 9 |
| FF42BD FF4AB5 FF52AD |
|
AR MP3 Remote Control

There are several different types of IR receivers, some are stand-alone, and some are mounted on
a breakout board.

However, all IR receivers will have three pins: signal, ground, and Vcc.

Lets get started with the hardware connections. The pin layout on most breakout boards looks like this:
The pinout of most stand-alone diodes is like this:

Circuit:
 Program:
#include <IRremote.h>
const int receiver = 11;
const int led = 9;
IRrecv ir_receiver(receiver);
decode_results results;
void setup()
{
[Link](9600);
ir_receiver.enableIRIn();
pinMode(led, OUTPUT);
}
void loop()
{
if (ir_receiver.decode(&results))

{
[Link]([Link], HEX);
translateIR();
ir_receiver.resume();
delay(200);
}
}
void translateIR()
{
int sensorValue=0;
sensorValue = digitalRead(led);

switch([Link]){

case 0xC1AA51AE:
 if (sensorValue==0){
[Link](" ON ");
digitalWrite(led, HIGH);
break;
}
if (sensorValue==1){

[Link](" OFF ");

digitalWrite(led, LOW);
break;
}

case 0x20DFD02F:
if (sensorValue==0){
[Link](" BLINK ");
for(int i=1;i<5;i++){
digitalWrite(led, HIGH);
delay(500);
digitalWrite(led, LOW);
delay(500);
}
break;
}
default:
[Link](" other button ");
}
}
Output:

Result:
Thus the Interfacing of Remote Control with IR was verified successfully.
 5. Interfacing EPROM and Interrupt
Aim:
Write a C Program to generate random numbers between 0 and 255, store them in the
EEPROM, then retrieve and display them on the serial monitor.
Hardware Required:
 ARDUNIO AT MEGA 2560

Description:
EEPROM is an Electrically Erasable Programmable Read-Only Memory. It is a form of non-
volatile memory that can remember things with the power being turned off, or after resetting the
Arduino. The beauty of this kind of memory is that we can store data generated within a sketch
on a more permanent basis.
Why would you use the internal EEPROM?
For situations where data that is unique to a situation needs a more permanent home. For
example, storing the unique serial number and manufacturing date of a commercial Arduino-
based project – a function of the sketch could display the serial number on an LCD, or the data
could be read by uploading a ‘service sketch’. Or you may need to count certain events and not
allow the user to reset them – such as an odometer or operation cycle-counter.
What sort of data can be stored?
Anything that can be represented as bytes of data. One byte of data is made up of eight bits of
data. A bit can be either on (value 1) or off (value 0), and are perfect for representing numbers in
binary form. In other words, a binary number can only uses zeros and ones to represent a value.
Thus binary is also known as “base-2″, as it can only use two digits.
How can a binary number with only the use of two digits represent a larger number? It uses a lot
of ones and zeros. Let’s examine a binary number, say 10101010. As this is a base-2 number,
each digit represents 2 to the power of x, from x=0 onwards:

See how each digit of the binary number can represent a base-10 number. So the binary number
above represents 85 in base-10 – the value 85 is the sum of the base-10 values. Another example
– 11111111 in binary equals 255 in base 10.

Now each digit in that binary number uses one ‘bit’ of memory, and eight bits make a byte. Due
to internal limitations of the microcontrollers in our Arduino boards, we can only store 8-bit
numbers (one byte) in the EEPROM. This limits the decimal value of the number to fall between
zero and 255. It is then up to you to decide how your data can be represented with that number
range
Program:
#include <EEPROM.h>
int zz;
int EEsize = 1024; // size in bytes of your board's EEPROM

void setup()
{
[Link](9600);
randomSeed(analogRead(0));
}
void loop()
{
[Link]("Writing random numbers...");
for (int i = 0; i < EEsize; i++)
{
zz=random(255);
[Link](i, zz);
}
[Link]();
for (int a=0; a<EEsize; a++)
{
zz = [Link](a);
[Link]("EEPROM position: ");
[Link](a);
[Link](" contains ");
[Link](zz);
delay(25);
}
}
Output:

Result:
Thus the Interfacing with EEPROM for generating random numbers between 0 and 255 was
done successfully and output was verified.
 [Link] of LED’s

Aim:

Develop the application for Flashing of LED’s with Ardunio.

Hardware Required

 Arduino ATMEGA 2560

 5 Red LEDs
 5 220 ohm resistors
 hook-up wires
 breadboard

Circuit
Program:
const int lowestPin = 2;
const int highestPin = 4;
void setup() {
// set pins 2 through 13 as outputs:
for (int thisPin = lowestPin; thisPin <= highestPin; thisPin++) {
pinMode(thisPin, OUTPUT);
}
}

void loop() {
// iterate over the pins:
for (int thisPin = lowestPin; thisPin <= highestPin; thisPin++) {
// fade the LED on thisPin from off to brightest:
for (int brightness = 0; brightness < 255; brightness++) {
analogWrite(thisPin, brightness);
delay(2);
}
// fade the LED on thisPin from brightest to off:
for (int brightness = 255; brightness >= 0; brightness--) {
analogWrite(thisPin, brightness);
delay(2);
}
// pause between LEDs:
delay(100);
}
}
Output:
The LED’s will be gloved alternatively with different brightness levels.

Result:
Thus the Flashing of LED was done successfully and the output was verified.
 7. Stepper Motor Interfacing with Ardunio
Aim:
To develop and verify interfacing unipolar stepper motor with ardunio.
Hardware Required:
 Ardunio AT Mega 2560
 Stepper Motor
 ULN2003 Drive
 Hook Up Wires
Description:
Stepper motor is a brushless DC motor that divides the full rotation angle of 360° into a number
of equal steps.

The motor is rotated by applying a certain sequence of control signals. The speed of rotation can
be changed by changing the rate at which the control signals are applied.

A stepper motor is a brushless and synchronous motor, which divides the complete rotation into
the number of steps. Each stepper motor will have some fixed step angle and motor rotates at this
angle. Stepper motor is widely used in industrial, medicals, consumer electronics application.
Stepper Motors uses in normal Surveillance camera to a complicated CNC machine, Robot these
Stepper Motors are used everywhere as actuators since they provide accurate controlling. In this
project, the Stepper motor 28-BYJ48 can be interfaced with Ardunio Uno using ULN2003
Device.
The stepper motor 28-BYJ48 has five terminal, it has the different colors to indicate the lead coil
connected inside the motor. It has the rated voltage of 5v DC, no of phase 4, its speed ratio is
1/64
The ULN2003 module as stepper motor driver, there are many types of motor drivers are
available but the applications-oriented rating based it chosen. The primary principle for all driver
modules will be to source/sink enough current for the motor to operate.
It is important to know the steps per revolution for the stepper motor, in Arduino will be
operating the stepper motor in four steps sequence the 28-BYJ48 datasheet starts from 5.625 so
for 5.624*8=[Link] per Revolution=360/Step angle. So Here 360/11.25=32 steps per
revolution
Circuit:

As said earlier we will be using 4-step sequence method so we will have four steps to perform
for making one complete rotation.
Step Pin Energized Coils Energized
Step 1 8 and 9 A and B
Step 2 9 and 10 B and C
Step 3 10 and 11 C and D
Step 4 11 and 8 D and A

The Driver module will have four LED using which we can check which coil is being energised
at any given time.
Program:
#include <Stepper.h>
const int stepsPerRevolution = 200; // change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

void setup() {
 // set the speed at 60 rpm:
[Link](60);
// initialize the serial port:
[Link](9600);
}

void loop() {
// step one revolution in one direction:
[Link]("clockwise");
[Link](stepsPerRevolution);
delay(500);

// step one revolution in the other direction:

[Link]("counterclockwise");
[Link](-stepsPerRevolution);
delay(500);
}
Output:
Stepper Motor was rotated in clockwise and counter clock wise.
Result:
Thus the above interfacing unipolar stepper motor with ardunio was successfully
completed and the output was verified.
 8. INTERFACING TEMPARATURE SENSOR
Aim:
To develop and verify interfacing Temperature Sensor using Ardunio.
Description:
The Temperature Sensor LM35 series are precision integrated-circuit temperature devices with
an output voltage linearly proportional to the Centigrade temperature.
The LM35 device has an advantage over linear temperature sensors calibrated in Kelvin, as the
user is not required to subtract a large constant voltage from the output to obtain convenient
Centigrade scaling. The LM35 device does not require any external calibration or trimming to
provide typical accuracies of ±¼°C at room temperature and ±¾°C over a full −55°C to 150°C
temperature range.

Hardware Required

 1 × Breadboard
 1 × Arduino Uno R3
 1 × LM35 sensor

Figure:

Circuit
Connecting Details:

Code to Note
LM35 sensor has three terminals - Vs, Vout and GND. We will connect the sensor as follows −

 Connect the +Vs to +5v on your Arduino board.

 Connect Vout to Analog0 or A0 on Arduino board.
 Connect GND with GND on Arduino.
The Analog to Digital Converter (ADC) converts analog values into a digital approximation
based on the formula ADC Value = sample * 1024 / reference voltage (+5v). So with a +5 volt
reference, the digital approximation will be equal to input voltage * 205.
Program:
float temp;
int tempPin = 0;
void setup() {
[Link](9600);
}
void loop() {
temp = analogRead(tempPin);
// read analog volt from sensor and save to variable temp
temp = temp * 0.48828125;
// convert the analog volt to its temperature equivalent
[Link]("TEMPERATURE = ");
[Link](temp); // display temperature value
[Link]("*C");
[Link]();
delay(1000); // update sensor reading each one second
}
O/P:

Result
Thus the temperature display on the serial port monitor which is updated every second.
 9. Seven Segment Display with Arduino

Aim:
To develop and verify interfacing Seven Segment Display with arduino.
Hardware Required:
 ARDUINO UNO ,
 power supply (5v),
 HDSP5503 seven segment display
 2 - 220Ohm resister
Circuit Diagram:

Connection Details:

The connections which are done for 7 segment display are given below:
PIN1 or E to PIN 6 of ARDUINO UNO
PIN2 or D to PIN 5
PIN4 or C to PIN 4
PIN5 or H or DP to PIN 9 ///not needed as we are not using decimal point
PIN6 or B to PIN 3
PIN7 or A to PIN 2
PIN9 or F to PIN 7
PIN10 or G to PIN 8
PIN3 or PIN8 or CC to ground through 100Ω resistor.
 Now to understand the working, consider a seven segment display is connected to a port, so say
we have connected “A segment of display to PIN0”, “B segment of display to PIN1”, “A
segment of display to PIN3”, “A segment of display to PIN4”, “A segment of display to PIN5”,
“A segment of display to PIN6”. And is common ground type as shown in figure.

Program:
#define segA 2//connecting segment A to PIN2
#define segB 3// connecting segment B to PIN3
#define segC 4// connecting segment C to PIN4
#define segD 5// connecting segment D to PIN5
#define segE 6// connecting segment E to PIN6
#define segF 7// connecting segment F to PIN7
#define segG 8// connecting segment G to PIN8
int COUNT=0;//count integer for 0-9 increment
void setup()
{
for (int i=2;i<9;i++)
{
pinMode(i, OUTPUT);// taking all pins from 2-8 as output
}

}
void loop()
{
switch (COUNT)

case 0://when count value is zero show”0” on disp

digitalWrite(segA, HIGH);
digitalWrite(segB, HIGH);
digitalWrite(segC, HIGH);
digitalWrite(segD, HIGH);
digitalWrite(segE, HIGH);
digitalWrite(segF, HIGH);
digitalWrite(segG, LOW);

break;
case 1:// when count value is 1 show”1” on disp
digitalWrite(segA, LOW);
digitalWrite(segB, HIGH);
digitalWrite(segC, HIGH);
digitalWrite(segD, LOW);
digitalWrite(segE, LOW);
digitalWrite(segF, LOW);
digitalWrite(segG, LOW);
 break;
case 2:// when count value is 2 show”2” on disp
digitalWrite(segA, HIGH);
digitalWrite(segB, HIGH);
digitalWrite(segC, LOW);
digitalWrite(segD, HIGH);
digitalWrite(segE, HIGH);
digitalWrite(segF, LOW);
digitalWrite(segG, HIGH);
break;
case 3:// when count value is 3 show”3” on disp
digitalWrite(segA, HIGH);
digitalWrite(segB, HIGH);
digitalWrite(segC, HIGH);
digitalWrite(segD, HIGH);
digitalWrite(segE, LOW);
digitalWrite(segF, LOW);
digitalWrite(segG, HIGH);
break;
case 4:// when count value is 4 show”4” on disp
digitalWrite(segA, LOW);
digitalWrite(segB, HIGH);
digitalWrite(segC, HIGH);
digitalWrite(segD, LOW);
digitalWrite(segE, LOW);
digitalWrite(segF, HIGH);
digitalWrite(segG, HIGH);
break;
case 5:// when count value is 5 show”5” on disp
digitalWrite(segA, HIGH);
digitalWrite(segB, LOW);
digitalWrite(segC, HIGH);
digitalWrite(segD, HIGH);
digitalWrite(segE, LOW);
digitalWrite(segF, HIGH);
digitalWrite(segG, HIGH);

break;
case 6:// when count value is 6 show”6” on disp
digitalWrite(segA, HIGH);
digitalWrite(segB, LOW);
digitalWrite(segC, HIGH);
digitalWrite(segD, HIGH);
digitalWrite(segE, HIGH);
digitalWrite(segF, HIGH);
digitalWrite(segG, HIGH);
 break;
case 7:// when count value is 7 show”7” on disp
digitalWrite(segA, HIGH);
digitalWrite(segB, HIGH);
digitalWrite(segC, HIGH);
digitalWrite(segD, LOW);
digitalWrite(segE, LOW);
digitalWrite(segF, LOW);
digitalWrite(segG, LOW);
break;
case 8:// when count value is 8 show”8” on disp
digitalWrite(segA, HIGH);
digitalWrite(segB, HIGH);
digitalWrite(segC, HIGH);
digitalWrite(segD, HIGH);
digitalWrite(segE, HIGH);
digitalWrite(segF, HIGH);
digitalWrite(segG, HIGH);
break;
case 9:// when count value is 9 show”9” on disp
digitalWrite(segA, HIGH);
digitalWrite(segB, HIGH);
digitalWrite(segC, HIGH);
digitalWrite(segD, HIGH);
digitalWrite(segE, LOW);
digitalWrite(segF, HIGH);
digitalWrite(segG, HIGH);
break;
break;
}
if (COUNT<10)
{

COUNT++;

delay(1000);///increment count integer for every second

}
if (COUNT==10)
{
COUNT=0;// if count integer value is equal to 10, reset it to zero.
delay(1000);

}
Result:
Thus the interfacing of Seven Segment Display with Arduino was done successfully and the
result was verified.
 10. Interfacing LCD with Keyboard
Aim:
Develop and Interfacing LCD with Keyboard in Arduino.
Description:

The LCDs have a parallel interface, meaning that the microcontroller has to manipulate several
interface pins at once to control the display. The interface consists of the following pins:

A register select (RS) pin that controls where in the LCD's memory you're writing data to. You
can select either the data register, which holds what goes on the screen, or an instruction register,
which is where the LCD's controller looks for instructions on what to do next.

A Read/Write (R/W) pin that selects reading mode or writing mode

An Enable pin that enables writing to the registers

8 data pins (D0 -D7). The states of these pins (high or low) are the bits that you're writing to a
register when you write, or the values you're reading when you read.

There's also a display constrast pin (Vo), power supply pins (+5V and Gnd) and LED Backlight
(Bklt+ and BKlt-) pins that you can use to power the LCD, control the display contrast, and turn
on and off the LED backlight, respectively.

The process of controlling the display involves putting the data that form the image of what you
want to display into the data registers, then putting instructions in the instruction register. The
LiquidCrystal Library simplifies this for you so you don't need to know the low-level
instructions.

The Hitachi-compatible LCDs can be controlled in two modes: 4-bit or 8-bit. The 4-bit mode
requires seven I/O pins from the Arduino, while the 8-bit mode requires 11 pins. For displaying
text on the screen, you can do most everything in 4-bit mode, so example shows how to control a
2x16 LCD in 4-bit mode.

Hardware Required

 Arduino AT MEGA 2560

 LCD Screen (compatible with Hitachi HD44780 driver)
 pin headers to solder to the LCD display pins
 10k ohm potentiometer
 220 ohm resistor
 hook-up wires
 breadboard
Circuit

To wire your LCD screen to your board, connect the following pins:

 LCD RS pin to digital pin 12

 LCD Enable pin to digital pin 11
 LCD D4 pin to digital pin 5
 LCD D5 pin to digital pin 4
 LCD D6 pin to digital pin 3
 LCD D7 pin to digital pin 2

Additionally, wire a 10k pot to +5V and GND, with it's wiper (output) to LCD screens VO pin
(pin3). A 220 ohm resistor is used to power the backlight of the display, usually on pin 15 and 16
of the LCD connector .

Program:
#include <LiquidCrystal.h>
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
void setup()
{
[Link](16, 2);
[Link]("hello, world!");
}

void loop() {
[Link](0, 1);
[Link](millis() / 1000);
}
Result:
Thus the LCD with Keyboard interfacing was done successfully and the result was verified.
[Link] 11: Active Buzzer
Aim
Develop and Implement simple active buzzer using arduino.
Components:
1 * Arduino AT MEGA 2560
1 * USB Cable
1 * Active Buzzer (Has a white sticker on top of the buzzer )
1 * Breadboard
2 * Jumper Wires

Principle:
Active Buzzer Arduino module, it produces a single-tone sound when signal is high.
Circuit:

Code:
intbuzzerPin = 9;
voidsetup ()
{
pinMode (buzzerPin, OUTPUT);
}
voidloop ()
{
digitalWrite (buzzerPin, HIGH);
delay (500);
digitalWrite (buzzerPin, LOW);
delay (500);
}
Result:
Thus the above code will continually turn the buzzer on and off generating a series of short high-
pitched beeps.
[Link] :12 PASSIVE BUZZER
Aim
Develop and Implement simple active buzzer using arduino.
Components:
1 * Arduino AT MEGA2560
1 * USB Cable
1 * Passive Buzzer
1 * Breadboard
2 * Jumper Wires
Principle:
Passive piezoelectric buzzer can generate tones between 1.5 to 2.5 kHz by switching it on and off
at different frequencies either using delays or PWM.
Circuit:

Code:
int buzzer = 9; // set the buzzer control digital IO pin
void setup() {
pinMode(buzzer, OUTPUT); // set pin 9 as output
}
void loop() {
for (inti = 0; i< 80; i++) { // make a sound
digitalWrite(buzzer, HIGH); // send high signal to buzzer
delay(1); // delay 1ms
digitalWrite(buzzer, LOW); // send low signal to buzzer
delay(1);
}
delay(50);
for (int j = 0; j < 100; j++) { //make another sound
digitalWrite(buzzer, HIGH);
delay(2); // delay 2ms
digitalWrite(buzzer, LOW);
delay(2);
}
delay(100);
}

Result
Thus the above code will generate two different tones by turning on and off the buzzer at
different frequencies using a delay.
[Link] :13 VIBRATION SENSOR

Aim:
To develop and verify interfacing Vibration Sensor using Ardunio.

Requirements:
 Arduino uno
 Breadboard (or breadboard shield)
 Buzzer
 Vibration/shake sensor

Circuit Diagram:

 Connect one pin of vibration sensor to Arduino Analog pin A0 and the other to 5V

pin.

 Now connect the buzzer, one pin to Arduino pin 8 and the other to GND.
Program:
const int buzzer = 8; //Buzzer connected to pin 8 of Arduino uno / mega
int sensor; //Variable to store analog value (0-1023)
void setup()
{
[Link](9600); //Only for debugging
pinMode(buzzer, OUTPUT);
}
void loop()
{
sensor = analogRead(A0);
//While sensor is not moving, analog pin receive 1023~1024 value
if (sensor<1022)
{
tone(buzzer, 500);
[Link]("Sensor Value: ");
[Link](sensor);
}
else
{
noTone(buzzer);
[Link]("Sensor Value: ");
[Link](sensor);
}

Result:
Thus the Vibration Sensor Interfacing was completed and the output was verified.
 [Link] OF MAILBOX
Aim:
To study about Mailbox functions and features in Arduino.
Description:
Mailbox is the base class for all Bridge based calls that use the mailbox interface for
communicating between the two processors on the Yun.

The Yún has two processors on board. One is an ATmega32U4 like on the Leonardo. The other
is an Atheros 9331, running Linux and the OpenWRT wireless stack, which enables the board to
connect to WiFiand Ethernet networks. It is possible to call programs or custom scripts on the
Linux system through the Arduino to connect with various internet services. The Yún
Shield shares the same architecture and features, but it is a shield and needs to be attached to a
board, where the microcontroller is interfaced with the Atheros processor through hardware
Serial port.

The Bridge library simplifies communication between the ATmega32U4- or the board attached if
you use the shield - and the AR9331. Bridge commands from the board microcontroller are
interpreted by Python on the AR9331. Its role is to execute programs on the GNU/Linux side
when asked by Arduino, provide a shared storage space for sharing data like sensor readings
between the Arduino and the Internet, and receiving commands from the Internet and passing
them directly to the Arduino.

Bridge allows communication in both directions, acting as an interface to the the Linux
command line. For a brief explanations of the terminal and executing commands on Linux see
here.

To become familiar with the Yún family boards please see the Yúngetting started page and the or
the Yún Shield getting started page.

Process

Process is used to launch processes on the Linux processor, and other things like shell scripts.

Console

Console can be used to communicate with the network monitor in the Arduino IDE, through a
shell. Functionally, it is very similar to Serial.

FileIO

An interface to the Linux file system. Can be used to read/write files on the SD card, or on the
USB memory if you are using the Yún Shield.

HttpClient
 Creates a HTTP client on Linux. Acts as a wrapper for common CURL commands, by extending
Process.
Mailbox
An asynchronous, session-less interface for communicating between Linux and Arduino.
BridgeClient
An Arduino based HTTP client, modeled after the EthernetClient class.
BridgeServer
An Arduino based HTTP server, modeled after the EthernetServer class.
Temboo
An interface to Temboo making it easy to connect to a large variety of online tools
Examples
 Bridge: Access the pins of the board with a web browser.
 Console ASCII Table: Demonstrates printing various formats to the Console.
 Console Pixel: Control an LED through the Console.
 Console Read: Parse information from the Console and repeat it back.
 Datalogger: Store sensor information on a SD card.
 File Write Script: Demonstrates how to write and execute a shell script with Process.
 HTTP Client: Create a simple client that downloads a webpage and prints it to the serial monitor.
 HTTP Client Console: Create a simple client that downloads a webpage and prints it to the serial
monitor via WiFi using Console.
 Mailbox Read Messages: Send text messages to the Arduino processor using REST API through
a browser.
 Process: Demonstrates how to use Process to run Linux commands.
 Remote Due Blink: Demonstrates how to upload remotely a sketch on DUE boards.
 Shell Commands: Use Process to run shell commands.
 SpacebrewYun: See the Spacebrew documentation pages for more infos on the Examples listed
in the Arduino Software.
 Temboo: See the Temboo documentation section for more infos on the Examples listed in the
Arduino Software.
 Temperature Web Panel: Post sensor data on a webpage when requested by a browser.
 Time Check: Get the time from a network time server and print it to the serial monitor.
 WiFi Status: Runs a pre-configured script that reports back the strength of the current WiFi
network.
 Yun First Config: Connect your Yun product to the WiFi networks in a breeze using the Serial
Monitor and answering a few simple questions within it.
 Yun Serial Terminal: Access the Linux Terminal through the serial monitor.

Result:
Thus the study of mailbox has been done and ensured its composition with internal features
specifically.