Arduino 03 Introduction

7/27/2019 Arduino 03 Introduction

http://slidepdf.com/reader/full/arduino-03-introduction 1/23

A GUIDE TO ARDUINO WORKSHOP

For Training Only Page 1


Embedded System

Computing systems are everywhere. It’s probably no surprise that millions of

computing systems are built every year destined for desktop computers (Personal Computers,

or PC’s), workstations, mainframes and servers. What may be surprising is that billions of

computing systems are built every year for a very different purpose: they are embedded

within larger electronic devices, repeatedly carrying out a particular function, often going

completely unrecognized by the device’s user. Creating a precise definition of such

embedded computing systems, or simply embedded systems, is not an easy task. We might try

the following definition: An embedded system is nearly any computing system other than a

desktop, laptop, or mainframe computer. That definition isn’t perfect, but it may be as close

as we’ll get. We can better understand such systems by examining common examples and

common characteristics. Such examination will reveal major challenges facing designers of

such systems. Embedded systems are found in a variety of common electronic devices, such

as:

Consumer Electronics -- cell phones, pagers, digital cameras, camcorders,

videocassette

recorders, portable video games, calculators, and personal digital assistants.

Home Appliances -- microwave ovens, answering machines, thermostat, home

security,

washing machines, and lighting systems.

Office Automation -- fax machines, copiers, printers, and scanners.

Business Equipment -- cash registers, curbside check-in, alarm systems, card readers,

product scanners, and automated teller machines.

Automobiles -- transmission control, cruise control, fuel injection, anti-lock brakes,

andactive suspension.

One might say that nearly any device that runs on electricity either already has, or will

soon have, a computing system embedded within it. It may be surprising to hear that several

billion embedded microprocessor units were sold annually compared to a few hundred

million desktop microprocessor units.

Embedded systems have several common characteristics:

Single-functioned: An embedded system usually executes only one

program, repeatedly.





Reactive and real-time: Many embedded systems must continually

react to changes in the system’s environment, and must compute

certain results in real time without delay.

Tightly constrained: A design metric is a measure of an

implementation’s features such as cost, size, performance, and power.

Embedded systems often must cost just a few dollars, must be sized to

fit on a single chip, must perform fast enough to process data in real-

time, and must consume minimum power to extend battery life or

prevent the necessity of a cooling fan.

In general we can conclude an embedded system as a special-purpose computer

system designed to perform one or a few dedicated functions, often with real-time computing

constraints. It is usually embedded as part of a complete device including hardware and

mechanical parts. The program instructions written for embedded systems are referred to as

firmware.

Microprocessor Vs Microcontroller

Microprocessors are generally utilized for relatively high performance applications

where cost and size are not critical selection criteria. Because microprocessor chips have their

entire function dedicated to the CPU and thus have room for more circuitry to increaseexecution speed, they can achieve very high-levels of processing power. However,

microprocessors require external memory and I/O hardware. Microprocessor chips are used

in desktop PCs and workstations where software compatibility, performance, generality, and

flexibility are important.

By contrast, microcontroller chips are usually designed to minimize the total chip

count and cost by incorporating memory and I/O on the chip. They are often “application

specialized” at the expense of flexibility. In some cases, the microcontroller has enough

resources on-chip that it is the only IC required for a product. The hardware interfaces of both

devices have much in common, and those of the microcontrollers are generally a simplified

subset of the microprocessor. The primary design goals for each type of chip can be

summarized this way:

Microprocessors are most flexible

Microcontrollers are most compact





There are also differences in the basic CPU architectures used, and these tend to

reflect the application. Microprocessor based machines usually have a von Neumann

architecture with a single memory for both programs and data to allow maximum flexibility

in allocation of memory. Microcontroller chips, on the other hand, frequently embody the

Harvard architecture, which has separate memories for programs and data.

(a) von Neumann architecture (b) Harvard architecture

In order to use a generic microprocessor in an embedded application you need to add

some amount of external resource to be attached to it. These may include program memory

(ROM) to save the program, data memory (RAM) to load variables during execution, timers,

I/O ports, and communication ports such as Serial, Parallel etc, PWM, A/D converter etc

which result in complex design. In contrast microcontrollers incorporate most of these in a

single chip leading to fairly simple design. Most of the commonly available microprocessors

today are 32 or 64 bit versions and with a clock speed of few GHz. Microprocessor make use

of powerful instruction set (which need to include more hardware circuit inside the chip to

help the execution of some instructions) and complex addressing modes. But manyapplications do not require the impressive power of the 32/64-bit microprocessor or the

extensive expandability that is available on many microprocessor-based motherboards.

In contrast a microcontroller incorporate most of the resources needed to run a custom

application, including memory and peripheral such as I/O ports, Communication channels,

timers etc. These controllers are available in a vast variety of choices. The designer has the

freedom to select a controller which is suitable for the application to be designed. Since

embedded systems are more cost sensitive, this freedom allows the designer to keep the cost

to minimum by the right selection of controller. One could easily argue that the

microcontrollers currently available do not compare to the powerful 32-bit microprocessors

that can access billions of bytes of memory, have powerful instruction sets that support

multitasking, are optimized for multimedia processing, and run at clock speeds upward from

2 GHz. On the other hand, it would be a waste of technology to put a 32-bit microprocessor

inside a robot arm dedicated to welding frame joints on an assembly line or inside a credit

card machine, microwave oven, or personal computer keyboard. In small, dedicated

applications like these, an 8-bit microcontroller is powerful enough to handle the job with a

Program

MemoryProgram &

Data MemoryCPU Data Memory CPU





minimum of external circuitry. With its built-in EEPROM and RAM, serial I/O and timer

capability, and self-contained operation, why use anything else for a small control

application? It would be too expensive in terms of component count, layout, board space, and

troubleshooting to use anything but a microcontroller .

So which is the best choice a Microcontroller or a Microprocessor? The answer

depends on the application that be designed.

Programming Language

A programming language is an artificial language that can be used to write programs

which control the behavior of a machine, particularly a computer. Programming languages

are defined by syntactic and semantic rules which describe their structure and meaning

respectively. Programming languages are also used to facilitate communication about the task

of organizing and manipulating information, and to express algorithms precisely. Some

authors restrict the term " programming language" to those languages that can express all

possible algorithms; sometimes the term "computer language" is used for more limited

artificial languages.

A low-level programming language is a language that provides little or no abstraction

from the processor or controller which runs the program. The word "low" refers to the small

or nonexistent amount of abstraction between the language and machine language; because of this, low-level languages are sometimes described as being "close to the hardware". A low

level language is one that does not need a compiler or interpreter to run. The processor for

which the language was written would be able to run the code without the use of either of

these. Low-level programming languages are sometimes divided into two categories: first

generation, and second generation.

The first-generation programming language, or 1GL, is machine code. It is the only

language a microprocessor can understand directly. Currently, programmers almost never

write programs directly in machine code, because not only does it (like assembly language)

require attention to numerous details which a high-level language would handle

automatically, but it also requires memorizing or looking up numerical codes for every

instruction that is used. For this reason, second generation programming languages abstract

the machine code one level.

The second-generation programming language, or 2GL, is assembly language. It is

considered a second-generation language because while it is not a microprocessor's native

language, an assembly language programmer must still understand the microprocessor's





unique architecture (such as its registers and instructions). These simple instructions are then

compiled directly into machine code. The assembly code can also be abstracted to another

layer in a similar manner as machine code is abstracted into assembly code.

A high-level programming language is a programming language with strong

abstraction from the details of the computer. In comparison to low-level programming

languages, it may use natural language elements, be easier to use, or more portable across

platforms. Such languages hide the details of CPU operations such as memory access models

and management of scope.

A high level language isolates the execution semantics of a computer architecture

from the specification of the program, making the process of developing a program simpler

and more understandable with respect to a low-level language. The amount of abstraction

provided defines how 'high level' a programming language is. The term "high-level language"

does not imply that the language is always superior to low-level programming languages - in

fact, in terms of the depth of knowledge of how computers work required to productively

program in a given language, the inverse may be true. High-level languages make complex

programming simpler, while low-level languages tend to produce more efficient code.

Abstraction penalty is the barrier preventing applying high level programming techniques in

situations where computational resources are limited. Ada, C, Python, Perl, Ruby, BASIC are

some examples of high level language.

The C

The C programming language is certainly the most influential in the world of

programming. Created at first by Brian Kernighan and Dennis Ritchie in 1972, this language

is characterized by its closeness to the hardware without being architecture dependent. Not

that it is complicated (like Assembly), but you can move generally as you want in the

memory for example, but may crash if you are not permitted to read or write to that memory.

More than any other, C has become the language of embedded programmers. This has

not always been the case, and it will not continue to be so forever. However, at this time, C is

the closest thing there is to a standard in the embedded world. Of course, C is not without

advantages. It is small and fairly simple to learn, compilers are available for almost every

processor in use today, and there is a very large body of experienced C programmers. In

addition, C has the benefit of processor-independence, which allows programmers to

concentrate on algorithms and applications, rather than on the details of a particular processor





architecture. However, many of these advantages apply equally to other high-level languages.

So why has C succeeded where so many other languages have largely failed?

Perhaps the greatest strength of C-and the thing that sets it apart from languages like

Pascal and FORTRAN-is that it is a very "low-level" high-level language. As we shall see

throughout the book, C gives embedded programmers an extraordinary degree of direct

hardware control without sacrificing the benefits of high-level languages. The "low-level"

nature of C was a clear intention of the language's creators. In fact, Kernighan and Ritchie

included the following comment in the opening pages of their book The C Programming

Language:

“C is a relatively "low level" language. This characterization is not pejorative; it

simply means that C deals with the same sort of objects that most computers do. These may

be combined and moved about with the arithmetic and logical operators implemented by real

machines”.

Few popular high-level languages can compete with C in the production of compact,

efficient code for almost all processors. And, of these, only C allows programmers to interact

with the underlying hardware so easily.

Other Embedded Languages

Of course, C is not the only language used by embedded programmers. At least threeother languages-assembly, C++, and Ada-are worth mentioning in greater detail.

In the early days, embedded software was written exclusively in the assembly

language of the target processor. This gave programmers complete control of the processor

and other hardware, but at a price. Assembly languages have many disadvantages, not the

least of which is higher software development costs and a lack of code portability. In

addition, finding skilled assembly programmers has become much more difficult in recent

years. Assembly is now used primarily as an adjunct to the high-level language, usually only

for those small pieces of code that must be extremely efficient or ultra-compact, or cannot be

written in any other way.

C++ is an object-oriented superset of C that is increasingly popular among embedded

programmers. All of the core language features are the same as C, but C++ adds new

functionality for better data abstraction and a more object-oriented style of programming.

These new features are very helpful to software developers, but some of them do reduce the

efficiency of the executable program. So C++ tends to be most popular with large





development teams, where the benefits to developers outweigh the loss of program

efficiency.

Ada is also an object-oriented language, though it is substantially different than C++.

Ada was originally designed by the U.S. Department of Defense for the development of

mission-critical military software. Despite being twice accepted as an international standard

(Ada83 and Ada95), it has not gained much of a foothold outside of the defense and

aerospace industries. And it is losing ground there in recent years. This is unfortunate because

the Ada language has many features that would simplify embedded software development if

used instead of C++.

Arduino

Arduino is a tool for making computers that can sense and control more of the

physical world than your desktop computer. It's an open-source physical computing platform

based on a simple microcontroller board, and a development environment for writing

software for the board. Arduino can be used to develop interactive objects, taking inputs from

a variety of switches or sensors, and controlling a variety of lights, motors, and other physical

outputs. Arduino projects can be stand-alone, or they can communicate with software running

on your computer (e.g. Flash, Processing, and MaxMSP).

Why should we go for Arduino? There are many other microcontrollers andmicrocontroller platforms available for physical computing. There are available so many

development / training kit for different microcontrollers like PIC, 8051, AVR etc. in the

market. All of these tools take the messy details of microcontroller programming and wrap it

up in an easy-to-use package. Arduino also simplifies the process of working with

microcontrollers, but it offers some advantage for teachers, students, and interested amateurs

over other systems:

Inexpensive - Arduino boards are relatively inexpensive compared to other

microcontroller platforms.

Cross-Platform - The Arduino software runs on Windows, Macintosh OSX,

and Linux operating systems. Most microcontroller systems are limited to

Windows

Simple, Clear Programming Environment - The Arduino programming

environment is easy-to-use for beginners, yet flexible enough for advanced

users to take advantage of as well





Open Source and Extensible Software- The Arduino software and is published

as open source tools, available for extension by experienced programmers.

The language can be expanded through C++ libraries, and people wanting to

understand the technical details can make the leap from Arduino to the AVR C

programming language on which it's based. Similarly, you can add AVR-C

code directly into your Arduino programs if you want to.

Open Source and Extensible Hardware - The Arduino is based on Atmel's

ATMEGA8 and ATMEGA168 microcontrollers. The plans for the modules

are published under a Creative Commons license, so experienced circuit

designers can make their own version of the module, extending it and

improving it.

Arduino Programming Structure

Like all other programming language Arduino programming also has a structure. The

program can be divided in to three sections. In the first section we declare pins and other

variables which are needed for the program. The second section is the setup section in which

we configure the device pins and other peripherals. This section is handled by a function void

setup (). The third and final section contains all our conditional logic that is going to be

executed indefinitely until you turn the Arduino board off. The logic should be enclosed in

the void loop () function. The following lines give you a better view of the structure. The

syntax followed is same as that of C.

Arduino programming is assisted with a set of built in functions for each of the

controller specific activity. The rest part is common C. The following sections give you a

better awareness of the programming of Arduino.

Blink an LEDIn most programming languages, the first program you write prints "hello world" to

the screen. Since an Arduino board doesn't have a screen, we blink an LED instead. The

boards are designed to make it easy to blink an LED using digital pin 13. To connect an LED

to another digital pin, you should use an external resistor. LEDs have polarity, which means

they will only light up if you orient the legs properly. The long leg is typically positive, and

should connect to pin 13. The short leg connects to GND; the bulb of the LED will also

typically have a flat edge on this side. If the LED doesn't light up, trying reversing the legs.

The following code can be used to light the LED connected to pin 13. pinMode () is a built in





function used to declare the mode of a pin as input or output. digitalWrite () function will set

a pin specified to one of the following states: HIGH, LOW.

# Program 1

//************** Blink an LED connected to pin 13 **************

int ledPin = 13; // LED connected to digital pin13

void setup()

pinMode(ledPin, OUTPUT); // sets the digital pin as output

void loop()

digitalWrite(ledPin, HIGH); // sets the LED on

while(true); // stay here infinitely

//***************************************************************

while (1) is used in a program to tell the controller to keep executing the statement

indefinitely. This is particularly useful in the troubleshooting of the program code.

This program is the first code to run to test that your Arduino board is working and

configured correctly. Type the code into your Arduino editor. Now that the code is in your

IDE we need to verify it and upload it to the board. Press the “Verify” button and if

everything is correct you’ll see the message “Done compiling” appear at the bottom of the

program text.

At this point we can upload it into the board: press the reset button on the Arduino

board, this forces the board to stop what it is doing and listen for instructions coming from

the serial port. Now we have about 6 or 7 seconds to press the “Upload to I/O Board” button.

this sends the current program to the board that will store it in its memory and eventually run

it. You will see a few messages appear in the black area at the bottom of the window, these

are messages that make it easier to understand if the process has completed correctly.

Blink an LED using Delay

This program will show you how to turn an LED on and off periodically. For this we

use the built in function delay (). The delay function takes an integer value corresponds to

millisecond value. To get a delay of 1 second we have to use a value of 1000 in delay (). The

program is an extension of the above program.





# Program 2//************** Blink an LED using delay **********************


void setup()


void loop()

digitalWrite(ledPin, HIGH); // sets the LED ondelay(1000); // waits for a second digitalWrite(ledPin, LOW); // sets the LED offdelay(1000); // waits for a second while(true); // stay here

//**************************************************************

If we remove the while statement at the end of the loop section will be executed

indefinitely and so the LED will blink infinitely in 1 second interval.

Control an LED using Pushbutton Switch

The pushbutton is a component that connects two points in a circuit when you press it.

The example turns on an LED when you press the button. We connect three wires to the

Arduino board. The first goes from one leg of the pushbutton through a pull-up resistor to the

5 volt supply. The second goes from the corresponding leg of the pushbutton to ground. The

third connects to a digital I/O pin (here pin 2) which reads the button's state. When the

pushbutton is open (un pressed) there is no connection between the two legs of the

pushbutton, so the pin is connected to 5 volts (through the pull-up resistor) and we read a

HIGH. When the button is closed (pressed), it makes a connection between its two legs,

connecting the pin to ground, so that we read a LOW. (The pin is still connected to 5 volts,

but the resistor in-between them means that the pin is "closer" to ground.)

# Program 3//************** Control LED using Pushbutton switch ***********

int ledPin = 13; // choose the pin for the LEDint inPin = 2; // choose the input pin (for a pushbutton)int val = 0; // variable for reading the pin status

void setup() pinMode(ledPin, OUTPUT); // declare LED as output





pinMode(inPin, INPUT); // declare pushbutton as input

void loop()

val = digitalRead(inPin); // read input valueif (val == HIGH) // check if the input is

HIGHdigitalWrite(ledPin, LOW); // turn LED OFF

elsedigitalWrite(ledPin, HIGH); // turn LED ON

//**************************************************************

You can also wire this circuit the opposite way, with a pull-down resistor keeping the

input LOW, and going HIGH when the button is pressed. If so, the behavior of the program

will be reversed, with the LED normally on and turning off when you press the button.

If you disconnect the digital I/O pin from everything, the LED may blink erratically.

This is because the input is "floating" - that is, it will more-or-less randomly return either

HIGH or LOW. That's why you need a pull-up or pull-down resister in the circuit.

Loop

Suppose we want to blink the LED for a pre defined number of times, how can we do

that?

Let us consider that we want to blink an LED for three times. The following code will show

you how to achieve this. The program uses the same code for blinking an LED using delay.

# Program 4//************** Blink an LED using delay **********************


void setup()


void loop()

digitalWrite(ledPin, HIGH); // sets the LED ondelay(1000); // waits for a second digitalWrite(ledPin, LOW); // sets the LED offdelay(1000); // waits for a second

digitalWrite(ledPin, HIGH); // sets the LED ondelay(1000); // waits for a second digitalWrite(ledPin, LOW); // sets the LED off





delay(1000); // waits for a second

digitalWrite(ledPin, HIGH); // sets the LED ondelay(1000); // waits for a second digitalWrite(ledPin, LOW); // sets the LED offdelay(1000); // waits for a second

while(true); // stay here

//**************************************************************

The while statement limit the blinking to three. If you examine the code you can

notice that the same code is repeated three times in the loop section. If the count is

comparatively less this method is useful but it still consume useful controller memory. If the

count is high what will be the solution? Loops solves this problem to some extend. Some of

the commonly used loops in programming are for and do while. Now we can examine how to

rewrite the program to make use of for loop.

# Program 5 //************** Blink an LED using delay **********************


int i; // an integer variable

void setup()


void loop()

for (i=1; i<=10; i++)

digitalWrite(ledPin, HIGH); // sets the LED ondelay(1000); // waits for a second

digitalWrite(ledPin, LOW); // sets the LED off delay(1000); // waits for a second

while(true); // stay here

//**************************************************************

Q. Try to modify the program using do while.

Blinking Multiple LED





This example make use of 6 LEDs connected to pin 2 -7 on the board using 220Ω

resister. The code will blink the LED in a sequential manner starting with the one connected

to pin number 2. the code uses a for loop.

# Program 6//************** Blinking multiple LEDs ************************

int ms_time = 1000; // delay time in millisecond int pins[] = 2, 3, 4, 5, 6, 7 ; // an array of pin numbersint num_pins = 6; // the number of pins (array

length)

void setup()

int i;for (i = 0; i < num_pins; i++)

pinMode(pins[i], OUTPUT); // set each pin as an O/P

void loop()

int i;

for (i = 0; i < num_pins; i++) // loop through each pin

digitalWrite(pins[i], HIGH); // turning it on,delay(ms_time); // wait for 1 second digitalWrite(pins[i], LOW); // and turning it off.

//**************************************************************

Q. Try to blink the LED in reverse order by editing the program.

Delay Control Using Potentiometer

A potentiometer is a simple knob that provides a variable resistance, which we can

read into the Arduino board as an analog value. In this example, that value controls the rate at

which an LED blinks. We connect three wires to the Arduino board. The first goes to ground

from one of the outer pins of the potentiometer. The second goes from 5 volts to the other

outer pin of the potentiometer. The third goes from analog input 2 to the middle pin of the

potentiometer. By turning the shaft of the potentiometer, we change the amount of resistance

on either side of the wiper which is connected to the center pin of the potentiometer. This

changes the relative "closeness" of that pin to 5 volts and ground, giving us a different analog

input. When the shaft is turned all the way in one direction, there are 0 volts going to the pin,

and we read 0. When the shaft is turned all the way in the other direction, there are 5 volts





going to the pin and we read 1023. In between, analogRead() returns a number between 0 and

1023 that is proportional to the amount of voltage being applied to the pin.

# Program 7//************** Blinking control using potentiometer **********

int potPin = 2; // input pin for the potentiometerint ledPin = 13; // pin for the LEDint val = 0; // variable to store the potentiometer value

void setup()

pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT

void loop()

val = analogRead(potPin); // read the value from the sensor

digitalWrite(ledPin, HIGH); // turn the ledPin ondelay(val); // stop the program for some timedigitalWrite(ledPin, LOW); // turn the ledPin offdelay(val); // stop the program for some time

//**************************************************************

The analogRaed function automatically configure the pin as input so there is no need

to include it in setup phase.

Brightness control using Potentiometer

For brightness control, we know that an analog signal is needed. But how can we

generate an analog signal using a microcontroller. We all know that a microcontroller can

only produce a digital value. The solution is to use a PWM signal. Pulse width modulation

(PWM) is a powerful technique for controlling analog circuits with a processor's digital

outputs. PWM is employed in a wide variety of applications, ranging from measurement and

communications to power control and conversion. By controlling analog circuits digitally,system costs and power consumption can be drastically reduced.

PWM is a way of digitally encoding analog signal levels. Through the use of high-

resolution counters, the duty cycle of a square wave is modulated to encode a specific analog

signal level. The PWM signal is still digital because, at any given instant of time, the full DC

supply is either fully on or fully off. The voltage or current source is supplied to the analog

load by means of a repeating series of on and off pulses. The on-time is the time during which

the DC supply is applied to the load, and the off-time is the time during which that supply is

switched off. Given a sufficient bandwidth, any analog value can be encoded with PWM.





One of the advantages of PWM is that the signal remains digital all the way from the

processor to the controlled system; no digital-to-analog conversion is necessary. By keeping

the signal digital, noise effects are minimized. Noise can only affect a digital signal if it is

strong enough to change a logic-1 to a logic-0, or vice versa.

Increased noise immunity is yet another benefit of choosing PWM over analog

control, and is the principal reason PWM is sometimes used for communication. Switching

from an analog signal to PWM can increase the length of a communications channel

dramatically. At the receiving end, a suitable RC (resistor-capacitor) or LC (inductor-

capacitor) network can remove the modulating high frequency square wave and return the

signal to analog form.

The controller used in the Arduino is ATMEGA8 from ATMEL. The controller offers

a PWM module. The function analogWrite() take care of the module and the following code

shows the usage.

# Program 8//************** Brightness control using potentiometer *********

int potPin = 2; // input pin for the potentiometerint ledPin = 13; // pin for the LEDint val = 0; // variable to store the potentiometer value

void setup()

pinMode(ledPin, OUTPUT); // declare the ledPin as an O/P

void loop()

val = analogRead(potPin); // read analog valueanalogWrite(ledPin, val); // write the valuedelay(50); // wait to see the effect

//**************************************************************

Q. Write a program to automatically fade in and fade out an LED.Q. Write a program to control the speed of automatic fading using two push button switches, one

for increasing and other for decreasing speed.

Serial Communication

Serial communication is a way enables different equipments to communicate with

their outside world. It is called serial because the data bits will be sent in a serial way over a

single line. A personal computer has a serial port known as communication port or COM Port

used to connect other device. Serial ports are controlled by a special chip called UART

(Universal Asynchronous Receiver Transmitter). Different applications use different pins on





the serial port and this basically depend of the functions required. If you need to connect your

PC for example to some other device by serial port, then you have to read instruction manual

for that device to know how the pins on both sides must be connected and the setting

required.

Serial communication has some advantages over the parallel communication. One of

the advantages is transmission distance, serial link can send data to a remote device more far

then parallel link. Also the cable connection of serial link is simpler then parallel link and

uses less number of wires. Serial link is used also for Infrared communication, now many

devices such as laptops & printers can communicate via inferred link.

There are two methods for serial communication, Synchronous & Asynchronous. In

Synchronous serial communication the receiver must know when to “read” the next bit

coming from the sender, this can be achieved by sharing a clock between sender and receiver.

Asynchronous transmission allows data to be transmitted without the sender having to send a

clock signal to the receiver. Instead, special bits will be added to each word in order to

synchronize the sending and receiving of the data.

Most microcontroller communication implements asynchronous serial communication

method with PC. This is because the standard serial communications hardware in the PC does

not support Synchronous operations. We will now discuss this in detail. When a word is

given to the UART for Asynchronous transmissions, a bit called the "Start Bit" is added tothe beginning of each word that is to be transmitted. The Start Bit is used to alert the receiver

that a word of data is about to be sent, and to force the clock in the receiver into

synchronization with the clock in the transmitter. After the Start Bit, the individual bits of the

word of data are sent, each bit in the word is transmitted for exactly the same amount of time

as all of the other bits. When the entire data word has been sent, the transmitter may add a

Parity Bit that the transmitter generates. The Parity Bit may be used by the receiver to

perform simple error checking. Then at least one Stop Bit is sent by the transmitter. If the

Stop Bit does not appear when it is supposed to, the UART considers the entire word to be

garbled and will report a Framing Error.

Baud Rate

Baud rate is a measurement of transmission speed in Asynchronous Communication.

It represents the number of bits that are actually being sent over the serial link. The Baud

count includes the overhead bits Start, Stop and Parity that are generated by the sending

UART and removed by the receiving UART.





ASCII

ASCII stands for American Standard Code for Information Interchange. It is a

character encoding based on the English alphabet. ASCII codes represent text in computers,

communications equipment, and other devices that work with text. ASCII includes

definitions for 128 characters encoded in 7 bits. The ASCII character encoding or a

compatible extension (Unicode) is used on nearly all common computers, especially personal

computers and workstations.

ASCII reserves the first 32 codes (0x00 to 0x1F) for control characters: codes

originally intended not to carry printable information, but rather to control devices. Code 32,

the "space" character, denotes the space between words, as produced by the space-bar of a

keyboard. The "space" character is considered an invisible graphic rather than a control

character. Codes 33 to 126, known as the printable characters, represent letters, digits,

punctuation marks, and a few miscellaneous symbols.

Hello World

We have seen at the beginning of the booklet that Arduino has a serial connection that

is used by the IDE to upload code into the processor. The good news is that this connection

can also be used by the programs that we write in Arduino to send data back to the computer

or receive commands from it. For this purpose we are going to use the Serial object. This

object contains all the code we need to send and receive data .

The following example shows the basic command required for establishing serial

communication. The program will send “Hello World!!!” to the serial terminal of the IDE.

# Program 9//************** Serial communication – Hello World!!! **********

void setup()

Serial.begin(9600); // open the serial port to send data @ 9600 Baud

void loop()

Serial.print(“Hello World!!!”); //Print Hello World!!! to terminal

while(true);

//**************************************************************





Now that we have the program running you should press the “Serial Monitor” button

on the Arduino IDE and you’ll see Hello World!!! printed at bottom part of the window. Now

any software that can read from the serial port can talk to Arduino.

Character Handling

For reading a character available at serial port Arduino provide a built in function

called Serial.read (). This function will read a character available at serial buffer of Arduino

board. For checking whether a character is available there is another function Serial.available

(). The function will check if a character is available in the serial buffer or not. If there is a

character it will return a non zero value else zero. The following program will receive a

character pressed in the keyboard and display it on the serial terminal program like

HyperTerminal.

# Program 10//************** Character Echoing Serial Rx an Tx **************

char value; //variable for saving keyboard character

void setup()

Serial.begin(9600); // open the serial port to send data @ 9600 Baud

void loop()

Serial.print(“ Character Echoing Program \n“);

while(1)

if(Serial.available()) // check character availability

Value = Serial.read(); //if available copy to value

Serial.print(value); // print the char to terminal

//**************************************************************

Hardware / Sensor Interface

Interfacing the LCD

It’s very simple to interface an LCD module with Arduino. The only thing we need to

know is the controlling and data pins of LCD. Let’s take a look in to the 2x16 LCD module,

which is very commonly available in the market. 2x16 means that the LCD module has 2lines of 16 characters each. The module will have 14 pins. The pin description is as follows.





Pin Symbol I/O Description

1 GND - Ground

2 Vcc - +5V Power Supply

3 VEE - Contrast Control

4 RS I Command / Data Register Selection

5 R/W I Write / Read selection

6 E I/O Enable Pin

7 DB0 I/O Data pin 0






13 DB6 I/O Data pin 614 DB7 I/O Data pin 7

There are also instructions command codes that can be sent to the LCD to clear the

display or force the cursor to the home position or blink the cursor. Table below lists the

instruction command codes.

Code (hex) Command to LCD Instruction Register

1 Clear display screen

2 Return home4 Shift cursor to left

5 Shift display right

6 Shift cursor to right

7 Shift display left

8 Display off, Cursor off

A Display off, Cursor on

C Display on, cursor off

E Display on, cursor blinking

F Display on, cursor blinking

10 Shift cursor position to left

14 Shift cursor position to right

18 Shift the entire display to the left

1C Shift the entire display to the right

80 Force cursor to beginning of 1st line

C0 Force cursor to beginning of 2nd line

38 2 lines and 5x7 matrix

We also use RS = 0 to check the busy flag bit to see if the LCD is ready to receive

information. The busy flag is D7 and can be read when R/W =1 and RS = 0, as follows: if

R/W =1, RS =0. When D7 = 1(busy flag = 1), the LCD busy taking care of internal





operations and will not accept any new information. When D7 = 0, the LCD is ready to

receive new information. Note: It is recommended to check the busy flag before writing any

data to the LCD.

The good thing is that for an Arduino user, he or she doesn’t need to take in to

account these things since there available library built for LCD for this platform. The

programmer can directly use this library and only need to know the LCD pins used by the

library (i.e., the data and control lines necessary for interfacing which are DB0-DB7, RS,

R/W and E ).

Library using 8 data lines and 4 data lines are available. Using 8 data pins for an LCD

reduces the Arduino digital pins available for other use. For an interface using 8 data lines

which required 11 Arduino pins. So we go ahead with a 4 bit interface library which requires

only 7 Arduino pins. The library is already added to the distribution given to you. Some of

the functions in the library are

init() : initialize the LCD

print(string) : print a string on LCD

clear() : Clear LCD display

cursorTo(line no, position) : Move the cursor to the specified position

leftScroll(no of positions, delay) : Scroll characters to left with specified delay.

# Program 11//************** Interfacing LCD with Arduino - 4 Bit Version **

#include <LCD4Bit.h>

LCD4Bit LCD = LCD4Bit(1); //number of lines in display=1

char msg[] = "Arduino..."; //message to display on the LCD

void setup()

LCD.init(); // initialize LCD

void loop()

LCD.clear();

LCD.print(msg);

delay(1000);

LCD.leftScroll(20, 300);// scroll entire display to left

//**************************************************************





• all functions are written in a format LCD.function() where LCD is an

object of constructor LCD4Bit

Driving a DC Motor

Now we will try to drive a DC motor. The DC motor requires 9V supply. The motor will have two lines. Suppose to drive the motor clockwise we provide 9V to one line and 0V

to the other line. If we reverse the line voltages the motor will reverse the running direction.

We cannot connect a DC motor directly to Arduino board since the motor require 9V but the

Arduino can output only 5V and also the current consumption of motor is high. If the current

is allowed to sink from the Arduino board the controller may get damaged. So we use a driver

IC instead connecting directly. The driver IC takes the control from Arduino and converts the

voltage level to a level required to drive the motor. Now the current for the motor is supplied

by the driver IC. In our case we use L293D as driver which is a push pull four channel driver

with diode. The supply voltage for this driver is taken from the 9V option of Arduino board.

L293D needs an enable signal to activate the Driver module. We permanently tie this pin to

supply voltage. Now two lines are required from Arduino to drive the motor using software.

Connect these two lines to the input stage to the driver and take the signal from

corresponding output pins to drive the motor.

Let’s write a program to drive a DC motor. It is assumed that a switch is connected to

digital pin 2 and the function of this switch is to change the motor state. Initially the motor is

OFF. The motor will run in one direction when the switch is pressed. It will change the

direction and will finally reach the initial state which is OFF in subsequent switch presses. A

switch press produces a HIGH state to Arduino.

# Program 12//*********Interfacing a DC motor with Arduino *****************

int motorPin_1=12;

int motorPin_2=13;int switchPin =2;

int inputState=0;

void setup()

pinMode(motorPin_1,OUTPUT);

pinMode(motorPin_2,OUTPUT);

pinMode(switchPin,INPUT);

void loop()





while(digitalRead(switchPin)==LOW); //waiting switch press

while(digitalRead(switchPin)==HIGH); //waiting for de bounce

digitalWrite(motorPin_1, HIGH); //run the motor

digitalWrite(motorPin_2, LOW); //in one direction



digitalWrite(motorPin_1, LOW); //run the motor

digitalWrite(motorPin_2, HIGH); //in opposite direction



digitalWrite(motorPin_1, LOW); //stop the motor

digitalWrite(motorPin_2, LOW);

while(true); // the action is done only once

//**************************************************************

Sensors – Light Dependent Resistor (LDR)

A photo resistor or Light Dependent Resistor is a resistor whose resistance decreases

with increasing incident light intensity. It can also be referred to as a photoconductor. It is

made of a high resistance semiconductor. If light falling on the device is of high enough

frequency, photons absorbed by the semiconductor give bound electrons enough energy to

jump into the conduction band. The resulting free electron (and its hole partner) conduct

electricity, thereby lowering resistance. LDR find applications in many electronic items such

as camera light meters, clock radios, security alarms, street lights and outdoor clocks.

The following program demonstrates how an LDR is interfaced with Arduino. The

objective of the program is to control the brightness of an LED using LDR. One PIN of LDR

is connected to 5V and the other pin is connected to Arduino’s input pin. This pin is

connected to a 4.7k resistance which is connected to ground forming a voltage divider. The

Arduino measure the change in voltage created by LDR due to change in light intensity.

# Program 13//********* Interfacing a LDR with Arduino *********************

int ledPin = 9; // LED connected to digital pin 9

int inPin = 2;void setup()




F T i i O l P 23

// I/O configuration is needed only for Digital functions

// Analog functions automatically set the direction

void loop()

value = analogRead(inPin) / 4;

analogWrite(ledPin, value);

//**************************************************************

The ADC module of Arduino has a resolution of 10 bits this means that there are 1024

levels between 0V and 5V analog signal. Since the register set of Arduino is only 8 bit wide a

value 0xFF will saturate the register. Hence to accommodate the 1024 values we divide the

read analog signal value by 4 (256*4 =1024). Now the brightness of LED is now depend on

the intensity of light detected by LDR

References

1. http://arduino.cc/

2. Embedded Controller Hardware Design by Ken Arnold, LLH Technology Publishing.

3. Embedded System Design - A Unifide Hardware Software Approach by Frank Vahid

and Tony Givargis, Department of Computer Science and Engineering,University of California.

4. Programming Embedded Systems in C and C++by Michel Barr, O’Reilly.

5. http://www.netrino.com/Embedded-Systems/Glossary.

6. http://en.wikipedia.org/wiki/Embedded_system.

7. http://en.wikipedia.org/wiki/Microprocessor .

8. http://en.wikipedia.org/wiki/Microcontroller .

9. http://en.wikipedia.org/wiki/Programming_language.

10. http://en.wikipedia.org/wiki/Light_Dependent_Resistor

11. http://www.electrofriends.com/articles/lcd/index.html

http://arduino.cc/

http://www.netrino.com/Embedded-Systems/Glossary

http://en.wikipedia.org/wiki/Embedded_system

http://en.wikipedia.org/wiki/Microprocessor

http://en.wikipedia.org/wiki/Microcontroller

http://en.wikipedia.org/wiki/Programming_language

http://en.wikipedia.org/wiki/Programming_language

http://en.wikipedia.org/wiki/Microcontroller

http://en.wikipedia.org/wiki/Microprocessor

http://en.wikipedia.org/wiki/Embedded_system

http://www.netrino.com/Embedded-Systems/Glossary

http://arduino.cc/

Documents

Arduino 03 Introduction