final report on gui based device control using matlab

GRAPHICAL USER INTERFACE (G .U. I) BASED DEVICE

CONTROLLER USING MATLAB

MAJOR PROJECT REPORT

Submitted in partial fulfillment of the

Requirement for the award of the degree of

BACHELOR OF TECHNOLOGY

IN

ELECTRICAL AND ELECTRONICS ENGINEERING

(UNDER THE GUIDANCE OF Dr. Y. R. SOOD)

BY

Vandana Sharma (11273)

Rohit Pandey (11236)

Palak Sinha (11234)

Rajan Chauhan (10225)

DEPARTMENT OF ELECTRICAL & ELECTRICAL ENGINEERING

NATIONAL INSTITUTE OF TECHNOLOGY, HAMIRPUR (H.P)

CANDIDATE’S DECLARATION

I hereby certify that the work which is being presented in the major project titled “GUI

Based Device Controller Using MATLAB” in partial fulfillment of the requirements for

the award of the Degree of Bachelor of Technology and submitted in the Electrical and

Electronics Department, National Institute of Technology Hamirpur, is an authentic

record of my own work carried out during a period from August 2014 to DEC 2014

under the supervision of Dr. Y.R. SOOD, Professor, Electrical and Electronics

Department , National Institute of Technology, Hamirpur.

The matter presented in this project report has not been submitted by me for the award of

any other degree of this or any other Institute / University .

VANDANA SHARMA (11273)

ROHIT PANDEY (11236)

PALAK SINHA (11234)

RAJAN CHAUHAN (10225)

This is to certify that the above statement made by the candidates is correct to the best of

my Knowledge.

Dr. Y.R. SOOD

Professor

Project Supervisor

Prof. Ashwani Chandel

HEAD OF DEPARTMENT

ELECTRICAL ENGINEERING DEPARTMENT

National Institute Of Technology Hamirpur, HP

ACKNOWLEDGEMENT

“Preservance ,inspiration and motivation have always played a key role in any venture .

It is not just the brain that matters most , but that which guides them . The character, the

heart , generous qualities and progressive forces. The metamorphosis took endless hours

of toil , had its moments of frustation , but in the end everything seemed to have sense”.

At this level of understanding it is often difficult to understand the wide spectrum of

knowledge without proper guidance and advice. Hence, we take this opportunity to

express our heartfelt gratitude to our project guide “DR .Y.R. SOOD” who had faith in us

and allowed us to work on this project .We would like to thank him for his immense

interest ,valuable guidance, constant inspiration and kind co-operation throughout the

period of word undertaken, which has been instruemnted in the success of our project .

We also acknowledge our profound sense of gratitude to all the teachers who have

been instruemental for providing us the technical knowledge and moral support to

complete the project with full understanding .We thank our friends and family for their

moral support to carve out this project and above all GOD for removing all hurdles in

the way .

VANDANA SHARMA (11273)

ROHIT PANDEY (11236)

PALAK SINHA (11234)

RAJAN CHAUHAN (10225)

ABSTRACT

Within the ambit of wireless technology ,apperance of the remote control based devices

and appliances have become the order of the day. It reduces human affords and

increases the efficiency. Every sector needs the automation, ranging from home to

industries. Automation Systems perform by allowing a number of to communicate with a

central controller which in turn communicates all information to the user or the owner of

the system as per the instructions and the structure of the system.The application of

such automation systems could be in areas such as heating ,lighting , defence , energy

management audio and vedio systems , health monitoring and entertainment .

Keeping all these facts in mind , this project propose a system which based on GUI

controlling through a PC (personal computer ) or LAPTOP. This project propose

automation of appliances like fan , bulb , motor , fire sensor. To automate these

appliances , we can use the different wireless communication media like infrared ,

Bluetooth , Radio Frequency , RFID , GSM, DTMF and GUI-MATLAB and

implemented with the help of microcontroller – 89c51 to compare the robustness and

effeciency of the output . To automate the industries

appliances we have to programme the CPU-89S52 In Embedded C . Being an emerging

area of research, a review of the most recent literature and implementation has been

carried out. Home Automation refers to the use of the computer and information

technology to control home appliances and features ( such as windows or lightning )

. Systems can range from simple remote control of lightning through to complex

computer /micro –controller based networks with varying degrees of intelligence

and automation . Home automation is adopted for reasons of ease , security and

energy efficiency .In modern construction in industrialized nations , most homes have

been wired for electrical power , telephones , TV Outlets (cable or antennas ) and a

doorbell . Many household tasks were automated by the development of

specialized appliances . For instances , automatic washing machines were

developed to reduce the manual labor of cleaning clothes , and the water heaters

reduced the labor necessary for bathing. Other traditional household tasks , like food

preservation and preparation have been automated in large extent by moving them

into factory settings , with the development of pre made , prepackaged foods and in

some countries , such as the UNITED STATES , increased reliance on commercial

food preparation services , such as fast food restuarants . Volume production and

the factory setting allows forms of automation that would be impractical or too

costly in a home setting . Standardize foods enable possible futher automation of handling

the food within the home. The use of gaseous or liquid fuels, and later the use of

electricity enabled increased automation in heating , reducing the labour necessary to

manually refuel heaters and stoves . Development of thermostats allowed more

automated control of heating and ater cooling . As the number of controllable

devices in the home rises , interconnection and communication becomes a useful and

desired feature. For example, a furnace can send an alert message when it needs

cleaning , or a refrigerator when it needs service . Rooms will become

“intelligent” and will send signals to the controller when someone enters . If no one

is supposed to be at home and the alarm system is set , the system is set , the

system could call the owner , or the neighbors , or an emergency number. In simple

installations, domotics may be as straightforward as turning on the lights when a

person enters the room. In advanced installations , rooms can sense not only the

presense of a person inside but know who that person is and perhaps set appropriate

lightining, temperature , music levels or television channels , taking into account

the day of the week , the time of day and other factors . This Project is an

implementation of the MATLAB –ARDUINO serial port communication .This project

will also include an introduction of what an Arduino is - it’s basic design . The pins

that are there on the board etc , Following this we have covered topics on Arduino Setup,

issues faced while installing an Arduino. It’s hardware and software aspects , issues

faced while installing an Arduino , how we have troubles hooted the problems etc .

The final portion of this report includes MATLAB ARDUINO INTERFACING and

serial port communication. The communication is established using the serial ports

that are present on the Arduino Board .

Introduction

A graphical user interface (GUI) is a pictorial interface to a program. A good GUI can

make programs easier to use by providing them with a consistent appearance and with

intuitive controls like pushbuttons, list boxes, sliders, menus, and so forth. The GUI

should behave in an understandable and predictable manner, so that a user knows what to

expect when he or she performs an action. For example, when a mouse click occurs on a

pushbutton, the GUI should initiate the action described on the label of the button. This

chapter introduces the basic elements of the MATLAB GUIs. The chapter does not

contain a complete description of components or GUI features, but it does provide the

basics required to create functional GUIs for your programs.

How a Graphical User Interface Works

A graphical user interface provides the user with a familiar environment in which to

work. This environment contains pushbuttons, toggle buttons, lists, menus, text boxes,

and so forth, all of which are already familiar to the user, so that he or she can

concentrate on using the application rather than on the mechanics involved in doing

things. However, GUIs are harder for the programmer because a GUI-based program

must be prepared for mouse clicks (or possibly keyboard input) for any GUI element at

any time. Such inputs are known as events, and a program that responds to events is said

to be event driven. The three principal elements required to create a MATLAB Graphical

User Interface are

1. Components. Each item on a MATLAB GUI (pushbuttons, labels, edit boxes, etc is a

graphical component. The types of components include graphical controls(pushbuttons,

edit boxes, lists, sliders, etc.), static elements (frames and text strings), menus, and

axes. Graphical controls and static elements are created by the function ui control, and

menus are created by the functions ui menu and ui context menu. Axes, which are used

to display graphical data, are created by the function axes.

2. Figures. The components of a GUI must be arranged within a figure, which is a

window on the computer screen. In the past, figures have been created automatically

whenever we have plotted data. However, empty figures can be created with the

function figure and can be used to hold any combination of components.

3. Callbacks. Finally, there must be some way to perform an action if a user clicks a

mouse on a button or types information on a keyboard. A mouse click or a key press is

an event, and the MATLAB program must respond to each event if the program is to

perform its function. For example, if a user clicks on a button, that event must cause

the MATLAB code that implements the function of the button to be executed. The

code executed in response to an event is known as a call back. There must be a call

back to implement the function of each graphical component on the GUI. The basic

GUI elements are summarized in Table 1.1, and sample elements are shown in Figure.

We will be studying examples of these elements and then build working GUIs

from them.

Creating And Displaying A Graphical User Interface

MATLAB GUIs are created using a tool called guide, the GUI Development

Environment. This tool allows a programmer to layout the GUI, selecting and aligning

the GUI components to be placed in it. Once the components are in place, the

programmer can edit their properties: name, color, size, font, text to display, and so forth.

When guide saves the GUI, it creates working program including skeleton functions that

the programmer can modify to implement the behavior of the GUI. When guide is

executed, it creates the Layout Editor, shown in Figure 1.2. The large white area with

grid lines is the layout area, where a programmer can layout the GUI. The Layout Editor

window has a palate of GUI components along the left side of the layout area. A user can

create any number of GUI components by first clicking on the desired component, and

then dragging its outline in the layout area. The top of the window has a toolbar with a

series of useful tools that allow the user to distribute and align GUI components, modify

the properties of GUI components, add menus to GUIs, and so on. The basic steps

required to create a MATLAB GUI are:

1. Decide what elements are required for the GUI and what the function of each element

will be. Make a rough layout of the components by hand on a piece of paper.

Figure 1.1 A Figure Window showing examples of MA TLAB GUI elements From top

to bottom and left to right, the elements are: (1) a pushbutton; (2) a toggle button in the

‘on' state; (3) two radio buttons surrounded by a frame; (4) a check box; (5) a text field

and an edit box; (6) a slider; (7) a set of axes; and (8) a list box.

2.Use a MATLAB tool called guide (GUI Development Environment) to layout the

components on a figure. The size of the figure and the alignment and spacing of

components on the figure can be adjusted using the tools built into guide.

3. Use a MATLAB tool called the Property Inspector (built into guide) to give each

component a name (a "tag") and to set the characteristics of each component, such as

its color, the text it displays, and so on.

4. Save the figure to a file. When the figure is saved, two files will be created on disk

with the same name but different extents. The fig file contains the actual GUI that you

have created, and the M-file contains the code to load the figure and skeleton call

backs for each GUI element.

5. Write code to implement the behavior associated with each callback function.

As an example of these steps, let's consider a simple GUI that contains a single

Push button and a single text string. Each time that the pushbutton is clicked, the text

string will be updated to show the total number of clicks since the GUI started.

Figure 1.3 Rough layout for a GUI containing a single pushbutton and a single label field.

Step 1: The design of this Gm is very simple. It contains a single pushbutton and a single

text field. The callback from the pushbutton will cause the number displayed in the text

field to increase by one each time that the button is pressed. A rough sketch of the GUI is

shown in Figure 1.3.

Step 2: To layout the components on the GUI, run the MATLAB function guide. When

guide is executed, it creates the window shown in Figure 1.2

Figure 1.4 The completed GUI layout within the guide window

First, we must set the size of the layout area, which will become the size the final GUI.

We do this by dragging the small square on the lower right corner of the layout area until

it has the desired size and shape. Then, click on the "pushbutton" button in the list of GUI

components, and create the shape of the pushbutton in the layout area. Finally, click on

the "text" button in the list GUI components, and create the shape of the text field in the

layout area. The resulting figure after these steps is shown in Figure 1.4. We could now

adjust the alignment of these two elements using the Alignment Tool, if desired.

Step 3: To set the properties of the pushbutton, click on the button in the layout area and

then select "Property Inspector" from the toolbar. Alternatively, right-click on the button

and select "Inspect Properties" from the popup menu. The Property Inspector window

shown in Figure 1.5 will appear. Note this window lists every property available for the

pushbutton and allows us set each value using a GUI interface. The Property Inspector

performs the same function as the get and set functions, but in a much more convenient

form.

For the pushbutton, we may set many properties such as color, size, font, text alignment,

and so on. However, we must set two properties: the String property, which contains the

text to be displayed, and the Tag property, which is the name of the pushbutton. In this

case, the String property will be set to 'click Here', and the Tag property will be set to

MyFirstButton. For the text field, we must set two properties: the String property, which

contains the text to be displayed, and the Tag property, which is the name of the text

field. This name will be needed by the callback function to locate and update the text

field. In this case, the String property will be set to 'Total clicks: 0', and the Tag property

defaulted to 'MyFirstText'. The layout area after these steps is shown in Figure 1.6. It is

possible to set the properties of the figure itself by clicking on a clear spot in the Layout

Editor, and then using the Property Inspector to examine and set the figure's properties.

Although not required, it is a good idea to set the figure's Name property. The string in

the Name property will be displayed in the title bar of the resulting GUI when it is

executed.

Figure 1.5 The Property Inspector showing the properties of the pushbutton. Note that the

String is set to 'Click Here', and the Tag is set to 'MyFirstButton'.

Step 4: We will now save the layout area under the name MyFirstGUI. Select the

"File/SaveAs" menu item, type the name MyFirstGUI as the file name, and click "Save".

This action will automatically create two files, MyFirstGUI.fig and MyFirstGUI.m. The

figure file contains the actual GUI that we have created. The M-file contains code that

loads the figure file and creates the GUI, plus a skeleton callback function for each active

GUI component.

At this point, we have a complete Gm, but one that does not yet do the job it was

designed to do. You can start this Gm by typing MyFirstGUI in the Command Window,

as shown in Figure 1.7. If the button is clicked on this GUI, the following message will

appear in the Command Window: MyFirstButton Callback not implemented yet. A

portion of the M-file automatically created by guide is shown in Figure 1.8. This file

contains function MyFirstGUI, plus dummy sub functions implementing the callbacks for

each active GUI component. If function MyFirstGUI is called without arguments, then

the function displays the Gm contained in file.

Figure 1.6 The design area after the properties of the pushbutton and the text field have

been modified.

MyFirstGUI.fig. If function MyFirstGUI is called with arguments, then the function

assumes that the first arguments the name of a sub function, and it calls that function

using feval, passing the other arguments on to that function. Each callback function

handles events from a single GUI component. If a mouse click (or keyboard input for

Edit Fields) occurs on the GUI component, then the component's callback function will

be automatically called by MATLAB. The name of the callback function will be the

value in the Tag property of the GUI component plus the characters "_Callback". Thus,

the callback function for MyFirstButton will be named MyFirstButton_Callback. M-files

created by guide contain callbacks for each active GUI component, but these callbacks

simply display a message saying that the function of the callback has not been

implemented yet.

Step 5: Now, we need to implement the callback sub function for the pushbutton. This

function will include a persistent variable that can be used to count the number of clicks

that have occurred. When a click occurs on the pushbutton, MATLAB will call the

function MyFirstGUI with MyFirstButton_callback as the first argument. Then function

MyFirstGUI will call sub function MyFirstButton_callback, as shownin Figure 1.9. This

function should increase the count of clicks by one, create a new text string containing

the count, and store the new string in the String property of the text field MyFirstText.

Figure 1.7 Typing MyFirstGUI in the Command Window starts the GUI

.

Figure 1.8 The M-file forMyFirstGUI, automatically created by guide.

A function to perform this step is shown below:

Figure 1.9 Event handling in program MyFirstGUI.

When a user clicks on the button with the mouse, the function MyFirstGUI is cal1ed

automatically with the argument MyFirstButton_callback. Function MyFirstGUI in turn

calls sub function. MyFirstButton_Callback. This function increments count, and then

saves the new count in the text field on the GUI.

Figure 1.10 The resulting program after three button pushes.

Note that this function declares a persistent variable count and initializes it to zero. Each

time that the function is called, it increments count by 1 and creates a new string

containing the count. Then, the function updates the string displayed in the text field

MyFirstText. The resulting program is executed by typing MyFirstGUI in the Command

Window. When the user clicks on the button, MATLAB automatically calls function

MyFirstGUI with MYFirstButton_Callback as the first argument, and function

MyFirstGUI calls sub function MyFirstButton_Callback. This function increments

variable count by one and updates the value displayed in the text field. The resulting GUI

after three button pushes is shown in Figure 1.10.

Good Programming Practice

Store GUI application data in the handles structure, so that it will automatically be

available to any callback function.

If you modify any of the GUI application data in the handles structure, be sure to save the

structure with a call to guidata before exiting the function where the modifications

occurred.

Graphical user Interface Components

This section summarizes the basic characteristics of common graphical user interface

components. It describes how to create and use each component, as well as the types of

events each component can generate. The components discussed in this section are

• Text Fields

• Edit Boxes

• Frames

• Pushbuttons

• Toggle Buttons

• Checkboxes

• Radio Buttons

• Popup Menus

• List Boxes

• Slide

Text Fields

A text-field is a graphical object that displays a text string. You can specify how the text

is aligned in the display area by setting the horizontal alignment property. By default, text

fields are horizontally centered. A text field is created by creating a uicontrol whose style

property is 'edit'. A text field may be added to a GUI by using the text tool in the Layout

Editor. Text fields do not create callbacks, but the value displayed in the text field can be

updated in a callback function by changing the text field's String property.

Edit Boxes

An edit box is a graphical object that allows a user to enter a text string. The edit box

generates a callback when the user presses the Enter key after typing a string into the

box. An edit box is created by creating a uicontrol whose style property is 'edit'. An

edit box may be added to a GUI by using the edit box tool in the Layout Editor. Figure

l.l1a shows a simple GUI containing an edit box named, ‘Edit Box’ and a text field

named 'TextBox' .When a user types a string into the edit box, it automatically calls

the function EditBox_Callback, which is shown in Figure 1.11b. This function locates

the edit box using the handles structure and recovers the string typed by the user.

Then, it locates the text field and displays the string in the text field. Figure 1.12 shows

this GUI just after it has started and after the user has typed the word "Hello" in the edit

box.

3. Frames

A frame is a graphical object that displays a rectangle on the GUI. You can use frames

to draw boxes around groups of logically related objects. For example, a frame is used

to group the radio buttons together on Figure 1.1. A frame is created by creating a

uicontrol whose style property is 'frame'. A frame maybe added to a GUI by using the

frame tool in the Layout Editor. Frames do not generate callbacks.

4. Pushbuttons

A pushbutton is a component that a user can click on to trigger a specific action. The

pushbutton generates a callback when the user clicks the mouse on it. A pushbutton is

created by creating a uicontrol whose style property is 'pushbutton'. A pushbutton may

be added to a GUI by using the pushbutton tool in the Layout Editor. Function

MyFirstGUI in Figure 1.10 illustrated the use of pushbuttons.

Figure 1.11 (a) Layout of a simple GUI with an edit box and a text field. (b) The callback

functions for this GUI.

Figure 1.12 (a) The GUI produced by program test edit. (b) The GUI after a user types

Hello into the edit box and presses Enter.

5. Toggle Buttons

A toggle button is a type of button that has two states: on (depressed) and off (not

depressed). A toggle button switches between these two states whenever the mouse clicks

on it, and it generates a callback each time. The 'Value' property of the toggle button is

set to max (usually 1) when the button is on, and min (usually 0) when the button is off.

A toggle button is created by creating a uicontrol whose style property is toggle button. A

toggle button may be added to a GUI by using the toggle button tool in the Layout Editor.

Figure 1.13a shows a simple GUI containing a toggle button named 'ToggleButton' and a

text field named' TextBox'. When a user clicks on the toggle button, it automatically calls

the function ToggleButton Callback, which is shown in Figure 1.13b. This function

locates the toggle button using the handles structure and recovers its state from the' Value'

property. Then, the function locates the text field and displays the state in the text field.

Figure 1.14 shows this GUI just after it has started, and after the user has clicked on the

toggle button for the first time.

6. Checkboxes and radio buttons

Checkboxes and radio buttons are essentially identical to toggle buttons except that they

have different shapes. Like toggle buttons, checkboxes and radio buttons have two states:

on and off. They switch between these two states whenever the mouse clicks on them,

generating a callback each time. The 'Value' property of the checkbox or radio button is

set to max (usually 1) when they are on, and min (usually 0) when they are off. Both

checkboxes and radio buttons are illustrated in Figure 1.1.

A checkbox is created by creating a uicontrol whose style property is 'checkbox', and a

radio button is created by creating a uicontrol whose style property is 'radiobutton'. A

checkbox may be added to a GUI by using the checkbox tool in the Layout Editor, and a

radio button may be added to a GUI by using the radio button tool in the Layout Editor.

Checkboxes are traditionally used to display on/off options, and groups of radio buttons

are traditionally used to select among mutually exclusive options. Figure 1.l5a shows an

example of how to create a group of mutually exclusive options with radio buttons. The

GUI in this figure creates three radio buttons, labeled "Option 1," "Option 2," and

"Option 3." Each radio button uses the same callback function, but with a separate

parameter. The corresponding callback functions are shown in Figure l.l5b. When the

user clicks on a radio button, the corresponding callback function is executed.That

function sets the text box to display the current option, turns on that radio button, and

turns off all other radio buttons. Note that the GUI uses a frame to group the radio buttons

together, making it obvious that they are a set. Figure 1.16 shows this GUI after Option 2

has been selected.

Figure 1.13 (a) Layout of a simple GUI with a toggle button and a text field. (b) The call

back function for this GUI.

Figure 1.14 (a) The GUI produced by program testto gglebutton when the toggle button

is off. (b) The GUI when the toggle button is on.

7. Popup menus

Popup menus are graphical objects that allow a user to select one of a mutually exclusive

list of options. The list of options that the user can select among is specified by a cell

array of strings, and the 'Value' property indicates which of the strings is currently

selected. A popup menu may be added to a GUI by using the popup menu tool in the

Layout Editor. Figure 1.14a shows an example of a popup menu. The GUI in this figure

creates a popup menu with five options, labeled "Option I," "Option 2," and so forth. The

corresponding callback function is shown in Figure 1.14b. The call back function

recovers the selected option by checking the' Value' parameter of the popup menu, and

creates and displays a string containing that value in the text field. Figure 1.15 shows this

Gm after Option 4 has been selected.

8. List Boxes

List boxes are graphical objects that display many lines of text and allow a user to select

one or more of those lines. If there are more lines of text than can fit in the list box, a

scroll bar will be created to allow the user to scroll up and down within the list box. The

lines of text that the user can select among are specified by a cell array of strings, and the'

Value' property indicates which of the strings are currently selected. A list box is created

by creating a uicontrol whose style property is 'listbox'. A list box may be added to a GUI

by using the listbox tool in the Layout Editor. List boxes can be used to select a single

item from a selection of possible choices. In normal GUI usage, a single mouse click on a

list item selects that item but does not cause an action to occur. Instead, the action waits

on some external trigger, such as a pushbutton. However, a mouse double-click causes an

action to happen immediately. Single-click and double-click events can be distinguished

using the Selection Type property of the figure in which the clicks occurred. A single

mouse click will place the string 'normal' in the Selection Type property, and a double

mouse click will place the string' open' in the Selection Type property.

Figure 1.14 (a) Layout of a simple GUI with a popup menu and a text field to display the

current selection. (b) The callback functions for this GUI.

Figure 1.15 The GUI produced by program test popup.

It is also possible for a list box to allow multiple selections from the list. If the difference

between the max and min properties of the list box is greater than one, then multiple

selections is allowed. Otherwise, only one item may be selected from the list.

This function will check the figure producing the callback (using function gebf) to see if

the selecting action was a single-click or a double-click. If it was a single-click, the

function does nothing. If it was a double-click, then the function gets the selected value

from the listbox, and writes an appropriate string into the text field. If the pushbutton is

selected, then functionButton1_Callbaekwill be executed. This function gets the selected

value from the listbox, and writes an appropriate string into the text field.

9. Sliders

Sliders are graphical objects that allow a user to select values from a continuous range

between a specified minimum value and a specified maximum value by moving a bar

with a mouse. The 'Value' property of the slider is set to a value between min and max

depending on the position of the slider.

A slider is created by creating a uicontrol whose style property is 'slider'. A slider may be

added to a GUI by using the slider tool in the Layout Editor.

MICROCONTROLLERS

Microcontrollers are used in the industrial world to control many types of equipments

ranging from customers to specialized devices . Furthermore , there is a growing need

for offline support of a computers main processor . The demand will grow as

more eqipment uses more intelligence . One of the most popular is MOTOROLA

68HC11 MICROCONTROLLER is relatively easy to work with , yet they have most

of the features essential for a complete control system .Thus student of control

automation can use them to work with control systems at the component level.The

intersted person can also use them as tools to understand and experiment with the

computer and data communications systems. As time passed engineers have developed a

better microcontroller to perform the specific task. For example, : ATMEL8051 family ,

ATMEL 8052 family , ATmega AVR family , TI-MSP430 , ARM family and many

more. These all controllers are present in the market for development such types of

specific task . As per the application we need to choose one of them. The crtiteria for

choosing the microcontroller are by their features , cost and power consumption, area ,

available memory inside the chip etc. Controller 89S52 from ATMEL 8052 Family .

It has 8 KB of on chip ROM and 256 bytes of RAM , 32 I/O PINS and easy to

program .

Industrial Automation meant for a system which monitor the input points (sensors and

signals generated by the GSM , BLUETOOTH , RF TRANSMITTER , RFID , DTMF)

and respond as per their described behaviour after crossin a threshold limit set by the

user.So far many scientists have done lots of research in the field of automation. For

example :There is automation using IR SENSOR . In addition some of them have

improved their communication medium to robust and effeicient their system. Morever,

due to the advancement in computer era , it facilitates the development of electronic

devices such as digital camera, digital images have been widely used in many era.

Therefore security is also an important issue.

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 enviornment 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 softwares running on your computer ( eg Flash , Processing

, MaxMSP ) . The boards can be assembled by hand or purchased preassembled , the

open source IDE can be downloaded for free .

The Arduino programming language is an implementation of Wiring , a similar physical

computing platform which is based on the Processing multimedia programming

enviornment .

There are many other microcontrollers and microcontroller platforms , available for

physical computing. Parallax Basic Stamp , Netmedia’s BX-24 , PHIDGETS , MIT’s

Handyboard and many other offer similar functionality. 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 . The least expensive version of the Arduino module can be

assembled by hand and even the pre-assembled Arduino modules cost less than $ 50.

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

Linux operating systems. Most microcontroller systems are limited to Windows .

Simple, clear programming enviornment : The Arduino programming enviornment is

easy -to–use for beginners, yet flexible enough for advanced users to take advantage of

as well. For teachers, it’s conveniently based on the Processing programming

enviornment , so students learning to program in that enviornment will be familiar

with the look and feel of Arduino .

Open source and extensible software : The Aurdino software 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 Common license , so experienced circuit

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

it . Even relatively inexperienced users can build the breadboard version of the

module in order to understand how it works and save money .

Setting up an Arduino:

To setup an Arduino we need the board, a cable to connect plug A and B. Cable is used to

interface/connect between PC and Arduino. Connect it to PC. COM port (Communication

port is the name of the serial port interfacing on the common PC’s. After plugging in the

Arduino gets connected to COM port. A software called arduinocc is downloaded (open

source software). It is the IDE (Integrated Development Environment).

PIN Configurations:

The Arduino Digital Pins can be configured as either input/output pins. By default they

are input pins.

PinMode(pin, mode)

There are pin modes. The number of pin whose mode is to be changed is represented by

pin. Mode can be input, output or input pull-up.

Checking if the Arduino works:

After setting up, the debugging LED is made to blink by writing the following code:

int led = 13;

// the setup routine runs once when you press reset:

void setup() {

// initialize the digital pin as an output.

pinMode(led, OUTPUT);

}

// the loop routine runs over and over again forever:

Serial Port communication:

The concept of serial communication is simple, in serial communication data is sent one

bit at a time. Although this is slower than parallel communication, which allows the

transmission of an entire byte at once, it is simpler and can be used over longer distances.

Possible troubleshooting for issues that may arise:

Issues are:

1. Right clicking on COM Port and updating drivers did not work.

2. Incompatibility of the software. It did not function at all.

3. The board was not able to connect to the PC.

Troubleshooting:

1.The issue was troubles hooted when the unzipped folder was put on desktop.

2. Following quite a few instructions found on a supportive blog and the official Arduino

Forum proved helpful to solve the rest of the issues.

void loop() {

digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)

delay(1000); // wait for a second

digitalWrite(led, LOW); // turn the LED off by making the voltage LOW

delay(1000); // wait for a second }

MATLAB code to generate a pulse:

clc; clear all; close all;

t=-5:0.0001:5;

D=input('Enter the Ton percentage');

y=square(t,D);

plot(t,y);

% This code shows a pulse on the MATLAB plotter window

But a problem with the code is that I was not able to change the frequency of the pulse.

How did I solve this problem?

I have used a Simulink block called pulse generator. I can vary the sampling time of the

pulse using this block. The below is the block diagram of a pulse generator. It can be

found in the Simulink Library.

Pulse generator block:

Pulse generator output graph:

The Pulse Generator block generates square wave pulses at regular intervals. The block's

waveform parameters, Amplitude, Pulse Width, Period, and Phase delay, determine the

shape of the output waveform. The above diagram shows how each parameter affects the

waveform.

The Pulse Generator can emit scalar, vector, or matrix signals of any real data type. To

cause the block to emit a scalar signal, use scalars to specify the waveform parameters.

To cause the block to emit a vector or matrix signal, use vectors or matrices, respectively,

to specify the waveform parameters. Each element of the waveform parameters affects

the corresponding element of the output signal. For example, the first element

of a vector amplitude parameter determines the amplitude of the first element of a vector

output pulse. All the waveform parameters must have the same dimensions after scalar

expansion. The data type of the output is the same as the data type of the

Amplitude parameter.

Use the Pulse type parameter to specify whether the block's output is time-based or

sample-based. If you select sample-based, the block computes its outputs at fixed

intervals that you specify. If you select time-based, Simulink software computes the

block's outputs only at times when the output actually changes. This choice can result in

fewer computations for computing the block's output over the simulation time period.

A time-based configuration using parameters Pulse Width and Period that results in a

constant output signal is not supported. Simulink returns an error if these parameters

satisfy either of the following conditions:

If you select time-based as the block's pulse type, you must specify the pulse's phase

delay and period in units of seconds. If you specify sample-based, you must specify the

block's sample time in seconds, using the Sample time parameter, then specify the block's

phase delay and period as integer multiples of the sample time. For example, suppose that

you specify a sample time of 0.5 second and want the pulse to repeat every two seconds.

In this case, you would specify 4 as the value of the block's Period parameter.

Tweaking with the properties of a pulse generator:

To tweak with the properties of a pulse generator the following information can be used:

Pulse type- The pulse type for this block: time-based or sample-based. The default is

time-based.

Time- It specifies whether to use simulation time or an external signal as the source of

values for the output pulse's time variable. If you specify an external source, the block

displays an input port for connecting the source. The output pulse differs as follows:

If you select Use simulation time, the block generates an output pulse where the time

variable equals the simulation time.If you select Use external signal, the block generates

an output pulse where the time variable equals the value from the input port, which can

differ from the simulation time.

Amplitude:

It is the pulse amplitude. The default is 1.

Period:

The pulse period specified in seconds if the pulse type is time-based or as number of

sample times if the pulse type is sample-based. The default is 10 seconds.

Pulse Width:

The duty cycle specified as the percentage of the pulse period that the signal is on if time-

based or as number of sample times if sample-based. The default is 5 percent.

Phase delay:

The delay before the pulse is generated specified in seconds if the pulse type is time-

based or as number of sample times if the pulse type is sample-based. The default

is 0 seconds.

Sample time:

It is the length of the sample time for this block in seconds. This parameter appears only

if the block's pulse type is sample-based. See Specify Sample Time in the Simulink User's

Guide for more information.

MATLAB and ARDUINO Interfacing:

This is the function:

Serial: 0 (RX) and 1 (TX). Used to receive (RX) and transmit (TX) TTL serial data.

These pins are connected to the corresponding pins of the FTDI USB-to-TTL Serial chip.

How to Communicate:

The Arduino Duemilanove has a number of facilities for communicating with a computer,

another Arduino, or other microcontrollers. The ATmega168 and ATmega328 provide

UART TTL (5V) serial communication, which is available on digital pins 0 (RX) and 1

(TX). An FTDI FT232RL on the board channels this serial communication over USB and

the FTDI drivers (included with Windows version of the Arduino software) provide a

virtual com port to software on the computer. The Arduino software includes a serial

monitor which allows simple textual data to be sent to and from the Arduino board. The

RX and TX LEDs on the board will flash when data is being transmitted via the FTDI

chip and USB connection to the computer (but not for serial communication on pins 0 and

1). A SoftwareSerial library allows for serial communication on any of the Duemilanove's

digital pins. The ATmega168 and ATmega328 also support I2C (TWI) and SPI

communication. The Arduino software includes a Wire library to simplify use of

the I2C bus; see the documentation for details. For SPI communication, use the SPI

library.

SoftwareSerial Library:

The Arduino hardware has a built-in support for serial communication on pins 0 and 1

(which also goes to the computer via the USB connection). The native serial support

happens via a piece of hardware (built into the chip) called a UART. This hardware

allows the Atmega chip to receive serial communication even while working on other

tasks, as long as there room in the 64 byte serial buffer. The SoftwareSerial library has

been developed to allow serial communication on other digital pins of the

Arduino, using software to replicate the functionality (hence the name "SoftwareSerial").

It is possible to have multiple software serial ports with speeds up to 115200 bps. A

parameter enables inverted signaling for devices which require that protocol. The version

of SoftwareSerial included in 1.0 and later is based on the NewSoftSerial library by Mikal

Hart.

MATLAB support package for Arduino:

In serial port communication information transfers one bit at a time. MATLAB Support

Package for Arduino (also referred to as "ArduinoIO Package") allows you to

communicate with an Arduino Uno or Duemilanove over a serial port. It consists of a

MATLAB API on the host computer and a server program that runs on the Arduino.

Together, they allow you to access Arduino analog I/O, digital I/O, operate servo

motors, read encoders, and even handle dc and stepper motors using the adafruit motor

shield, all from the MATLAB command line.

Setting Up serial port object:

>> s = serial (’COM1’);

Serial Port Object : Serial-COM1

Communication Settings

Port: COM1

BaudRate: 9600

Terminator: ’LF’

Communication State

Status: closed

RecordStatus: off

Read/Write State

TransferStatus: idle

BytesAvailable: 0

ValuesReceived: 0

ValuesSent: 0

Baud rate:

>> set(s, ’BaudRate’, 4800);

>> s.BaudRate = 4800;

The above progam helps us to establish a serial communication between matlab and

arduino.

Our project:

There is an arduino support package which works with Matlab. The code is written below

that links arduino with Matlab and further we are able to control the output that is

explained further.

/* Analog and Digital Input and Output Server for MATLAB */

/* Giampiero Campa, Copyright 2012 The MathWorks, Inc */

/* This file is meant to be used with the MATLAB arduino IO

package, however, it can be used from the IDE environment

(or any other serial terminal) by typing commands like:

0e0 : assigns digital pin #4 (e) as input

0f1 : assigns digital pin #5 (f) as output

0n1 : assigns digital pin #13 (n) as output

1c : reads digital pin #2 (c)

1e : reads digital pin #4 (e)

2n0 : sets digital pin #13 (n) low

2n1 : sets digital pin #13 (n) high

2f1 : sets digital pin #5 (f) high

2f0 : sets digital pin #5 (f) low

4j2 : sets digital pin #9 (j) to 50=ascii(2) over 255

4jz : sets digital pin #9 (j) to 122=ascii(z) over 255

3a : reads analog pin #0 (a)

3f : reads analog pin #5 (f)

5j : reads status (attached/detached) of servo on pin #9

5k : reads status (attached/detached) of servo on pin #10

6j1 : attaches servo on pin #9

8jz : moves servo on pin #9 of 122 degrees (122=ascii(z))

7j : reads angle of servo on pin #9

6j0 : detaches servo on pin #9

E0cd : attaches encoder #0 (0) on pins 2 (c) and 3 (d)

E1st : attaches encoder #1 on pins 18 (s) and 19 (t)

E2vu : attaches encoder #2 on pins 21 (v) and 20 (u)

G0 : gets 0 position of encoder #0

I0u : sets debounce delay to 20 (2ms) for encoder #0

H1 : resets position of encoder #1

F2 : detaches encoder #2

R0 : sets analog reference to DEFAULT

R1 : sets analog reference to INTERNAL

R2 : sets analog reference to EXTERNAL

X3 : roundtrip example case returning the input (ascii(3))

99 : returns script type (0 adio.pde ... 3 motor.pde ) */

#include <Servo.h>

/* define internal for the MEGA as 1.1V (as as for the 328) */

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)

#define INTERNAL INTERNAL1V1

#endif

/* define encoder structure */

typedef struct { int pinA; int pinB; int pos; int del;} Encoder;

volatile Encoder Enc[3] = {{0,0,0,0}, {0,0,0,0}, {0,0,0,0}};

/* create servo vector */

Servo servo[70];

void setup() {

/* initialize serial */

Serial.begin(115200);

}

void loop() {

/* variables declaration and initialization */

static int s = -1; /* state */

static int pin = 13; /* generic pin number */

static int enc = 0; /* generic encoder number */

int val = 0; /* generic value read from serial */

int agv = 0; /* generic analog value */

int dgv = 0; /* generic digital value */

/* The following instruction constantly checks if anything

is available on the serial port. Nothing gets executed in

the loop if nothing is available to be read, but as soon

as anything becomes available, then the part coded after

the if statement (that is the real stuff) gets executed */

if (Serial.available() >0) {

/* whatever is available from the serial is read here */

val = Serial.read();

/* This part basically implements a state machine that

reads the serial port and makes just one transition

to a new state, depending on both the previous state

and the command that is read from the serial port.

Some commands need additional inputs from the serial

port, so they need 2 or 3 state transitions (each one

happening as soon as anything new is available from

the serial port) to be fully executed. After a command

is fully executed the state returns to its initial

value s=-1 */

switch (s) {

/* s=-1 means NOTHING RECEIVED YET ******************* */

case -1:

/* calculate next state */

if (val>47 && val<90) {

/* the first received value indicates the mode

49 is ascii for 1, ... 90 is ascii for Z

s=0 is change-pin mode;

s=10 is DI; s=20 is DO; s=30 is AI; s=40 is AO;

s=50 is servo status; s=60 is aervo attach/detach;

s=70 is servo read; s=80 is servo write;

s=90 is query script type (1 basic, 2 motor);

s=210 is encoder attach; s=220 is encoder detach;

s=230 is get encoder position; s=240 is encoder reset;

s=250 is set encoder debounce delay;

s=340 is change analog reference;

s=400 example echo returning the input argument;

*/

s=10*(val-48);

}

/* the following statements are needed to handle

unexpected first values coming from the serial (if

the value is unrecognized then it defaults to s=-1) */

if ((s>90 && s<210) || (s>250 && s!=340 && s!=400)) {

s=-1;

}

/* the break statements gets out of the switch-case, so

/* we go back and wait for new serial data */

break; /* s=-1 (initial state) taken care of */

/* s=0 or 1 means CHANGE PIN MODE */

case 0:

/* the second received value indicates the pin

from abs('c')=99, pin 2, to abs('¦')=166, pin 69 */

if (val>98 && val<167) {

pin=val-97; /* calculate pin */

s=1; /* next we will need to get 0 or 1 from serial */

}

else {

s=-1; /* if value is not a pin then return to -1 */

}

break; /* s=0 taken care of */

case 1:

/* the third received value indicates the value 0 or 1 */

if (val>47 && val<50) {

/* set pin mode */

if (val==48) {

pinMode(pin,INPUT);

}

else {

pinMode(pin,OUTPUT);

}

}

s=-1; /* we are done with CHANGE PIN so go to -1 */


/* s=10 means DIGITAL INPUT ************************** */

case 10:



if (val>98 && val<167) {


dgv=digitalRead(pin); /* perform Digital Input */

Serial.println(dgv); /* send value via serial */

}

s=-1; /* we are done with DI so next state is -1 */


/* s=20 or 21 means DIGITAL OUTPUT ******************* */

case 20:



if (val>98 && val<167) {



}

else {


}


case 21:

/* the third received value indicates the value 0 or 1 */

if (val>47 && val<50) {

dgv=val-48; /* calculate value */

digitalWrite(pin,dgv); /* perform Digital Output */

}

s=-1; /* we are done with DO so next state is -1 */


/* s=30 means ANALOG INPUT *************************** */

case 30:


from abs('a')=97, pin 0, to abs('p')=112, pin 15 */

if (val>96 && val<113) {


agv=analogRead(pin); /* perform Analog Input */

Serial.println(agv); /* send value via serial */

}

s=-1; /* we are done with AI so next state is -1 */


/* s=40 or 41 means ANALOG OUTPUT ******************** */

case 40:



if (val>98 && val<167) {


s=41; /* next we will need to get value from serial */

}

else {


}


case 41:

/* the third received value indicates the analog value */

analogWrite(pin,val); /* perform Analog Output */

s=-1; /* we are done with AO so next state is -1 */


/* s=50 means SERVO STATUS (ATTACHED/DETACHED) ******* */

case 50:

/* the second value indicates the servo attachment pin


if (val>98 && val<167) {


dgv=servo[pin].attached(); /* read status */

Serial.println(dgv); /* send value via serial */

}

s=-1; /* we are done with servo status so return to -1*/


/* s=60 or 61 means SERVO ATTACH/DETACH ************** */

case 60:



if (val>98 && val<167) {



}

else {

s=-1; /* if value is not a servo then return to -1 */

}


case 61:

/* the third received value indicates the value 0 or 1

0 for detach and 1 for attach */

if (val>47 && val<50) {

dgv=val-48; /* calculate value */

if (dgv) servo[pin].attach(pin); /* attach servo */

else servo[pin].detach(); /* detach servo */

}

s=-1; /* we are done with servo attach/detach so -1 */


/* s=70 means SERVO READ ***************************** */

case 70:



if (val>98 && val<167) {


agv=servo[pin].read(); /* read value */

Serial.println(agv); /* send value via serial */

}

s=-1; /* we are done with servo read so go to -1 next */


/* s=80 or 81 means SERVO WRITE ******************** */

case 80:



if (val>98 && val<167) {


s=81; /* next we will need to get value from serial */

}

else {


}


case 81:

/* the third received value indicates the servo angle */

servo[pin].write(val); /* write value */

s=-1; /* we are done with servo write so go to -1 next*/


/* s=90 means Query Script Type:

(0 adio, 1 adioenc, 2 adiosrv, 3 motor) */

case 90:

if (val==57) {

/* if string sent is 99 send script type via serial */

Serial.println(2);

}

s=-1; /* we are done with this so next state is -1 */


/* s=210 to 212 means ENCODER ATTACH ***************** */

case 210:

/* the second value indicates the encoder number:

either 0, 1 or 2 */

if (val>47 && val<51) {

enc=val-48; /* calculate encoder number */

s=211; /* next we need the first attachment pin */

}

else {

s=-1; /* if value is not an encoder then return to -1*/

}


case 211:

/* the third received value indicates the first pin


if (val>98 && val<167) {


Enc[enc].pinA=pin; /* set pin A */

s=212; /* next we need the second attachment pin */

}

else {


}


case 212:

/* the fourth received value indicates the second pin


if (val>98 && val<167) {


Enc[enc].pinB=pin; /* set pin B */

/* set encoder pins as inputs */

pinMode(Enc[enc].pinA, INPUT);

pinMode(Enc[enc].pinB, INPUT);

/* turn on pullup resistors */

digitalWrite(Enc[enc].pinA, HIGH);

digitalWrite(Enc[enc].pinB, HIGH);

/* attach interrupts */

switch(enc) {

case 0:

attachInterrupt(getIntNum(Enc[0].pinA), isrPinAEn0, CHANGE);

attachInterrupt(getIntNum(Enc[0].pinB), isrPinBEn0, CHANGE);

break;

case 1:



break;

case 2:



break;

}

}

s=-1; /* we are done with encoder attach so -1 */


/* s=220 means ENCODER DETACH *********************** */

case 220:


either 0, 1 or 2 */

if (val>47 && val<51) {


/* detach interrupts */

detachInterrupt(getIntNum(Enc[enc].pinA));

detachInterrupt(getIntNum(Enc[enc].pinB));

}

s=-1; /* we are done with encoder detach so -1 */


/* s=230 means GET ENCODER POSITION ****************** */

case 230:


either 0, 1 or 2 */

if (val>47 && val<51) {


/* send the value back */

Serial.println(Enc[enc].pos);

}



/* s=240 means RESET ENCODER POSITION **************** */

case 240:


either 0, 1 or 2 */

if (val>47 && val<51) {


/* reset position */

Enc[enc].pos=0;

}



/* s=250 and 251 mean SET ENCODER DEBOUNCE DELAY ***** */

case 250:


either 0, 1 or 2 */

if (val>47 && val<51) {


s=251; /* next we need the first attachment pin */

}

else {

s=-1; /* if value is not an encoder then return to -1*/

}


case 251:

/* the third received value indicates the debounce

delay value in units of approximately 0.1 ms each

from abs('a')=97, 0 units, to abs('¦')=166, 69 units*/

if (val>96 && val<167) {

Enc[enc].del=val-97; /* set debounce delay */

}



/* s=340 or 341 means ANALOG REFERENCE *************** */

case 340:

/* the second received value indicates the reference,

which is encoded as is 0,1,2 for DEFAULT, INTERNAL

and EXTERNAL, respectively. Note that this function

is ignored for boards not featuring AVR or PIC32 */

#if defined(__AVR__) || defined(__PIC32MX__)

switch (val) {

case 48:

analogReference(DEFAULT);

break;

case 49:

analogReference(INTERNAL);

break;

case 50:

analogReference(EXTERNAL);

break;

default: /* unrecognized, no action */

break;

}

#endif



/* s=400 roundtrip example function (returns the input)*/

case 400:

/* the second value (val) can really be anything here */

/* This is an auxiliary function that returns the ASCII

value of its first argument. It is provided as an

example for people that want to add their own code */

/* your own code goes here instead of the serial print */

Serial.println(val);

s=-1; /* we are done with the aux function so -1 */


/* ******* UNRECOGNIZED STATE, go back to s=-1 ******* */

default:

/* we should never get here but if we do it means we

are in an unexpected state so whatever is the second

received value we get out of here and back to s=-1 */

s=-1; /* go back to the initial state, break unneeded */

} /* end switch on state s */

} /* end if serial available */

} /* end loop statement */

/* auxiliary function to handle encoder attachment */

int getIntNum(int pin) {

/* returns the interrupt number for a given interrupt pin

see http://arduino.cc/it/Reference/AttachInterrupt */

switch(pin) {

case 2:

return 0;

case 3:

return 1;

case 21:

return 2;

case 20:

return 3;

case 19:

return 4;

case 18:

return 5;

default:

return -1;

}

}

/* auxiliary debouncing function */

void debounce(int del) {

int k;

for (k=0;k<del;k++) {

/* can't use delay in the ISR so need to waste some time

perfoming operations, this uses roughly 0.1ms on uno */

k = k +0.0 +0.0 -0.0 +3.0 -3.0;

}

}

/* Interrupt Service Routine: change on pin A for Encoder 0 */

void isrPinAEn0(){

/* read pin B right away */

int drB = digitalRead(Enc[0].pinB);

/* possibly wait before reading pin A, then read it */

debounce(Enc[0].del);

int drA = digitalRead(Enc[0].pinA);

/* this updates the counter */

if (drA == HIGH) { /* low->high on A? */

if (drB == LOW) { /* check pin B */

Enc[0].pos++; /* going clockwise: increment */

} else {

Enc[0].pos--; /* going counterclockwise: decrement */

}

} else { /* must be high to low on A */

if (drB == HIGH) { /* check pin B */


} else {


}

} /* end counter update */

} /* end ISR pin A Encoder 0 */

/* Interrupt Service Routine: change on pin B for Encoder 0 */

void isrPinBEn0(){

/* read pin A right away */


/* possibly wait before reading pin B, then read it */




if (drB == HIGH) { /* low->high on B? */

if (drA == HIGH) { /* check pin A */


} else {


}

} else { /* must be high to low on B */

if (drA == LOW) { /* check pin A */


} else {


}


} /* end ISR pin B Encoder 0 */


void isrPinAEn1(){










} else {


}




} else {


}




void isrPinBEn1(){










} else {


}




} else {


}




void isrPinAEn2(){










} else {


}




} else {


}




void isrPinBEn2(){










} else {


}




} else {


}



As the program is uploaded in Arduino we open the Matlab window and go for the

instrument tool box. As we find the GUI tool we use it to create push buttons so as to

control the leds connected to the arduino. As the progam is uploaded in matlab command

window we need to make declaration for the controller whose program is described as

below:

clear all;

global a;

a= arduino(‘com 1’);

a= pinMode(4,’output’);

a= pinMode(8,’output’)

The name of push buttons can be changed by changing string name.

In simple control of two leds , two pushbuttons are being created in the gui tool then the

codes to be written to control the output of arduino through pushbutton is given as

For pushbutton 1

a=digitalwrite(4,0);


For pushbutton 2



By executing this program a GUI is created for arduino such that by clicking on the

pushbuttons we can control our leds.

Conclusion and Future Scope of Work:

The above project is a simple demonstration of the real time home automation system that

we wish to control using microcontrollers. In this project we have demonstrated to link

the Matlab to control arduino output. Here only pushbuttons are to be used by the user so

no need to write the program again and again once the declaration has been done.

This project doesn’t need exceptional coding skills for arduino and matlab. A simple

knowledge to both can work help the user fulfill his basic home and office tasks. Now this

can be extended for home automation, industrial automation, vehicle automation and

numerous fields using gsm module/ bluetooth/ android application/ dtmf .

For eg if we use gsm module we can connect with arduino via transmitter and receiver

pins then by programming the gsm module using AT commands we can control the basic

home appliances just by dialing the phone no. associated with the gsm module .

References:

[1]O.González, M. Rodríguez, A. Ayala, J. Hernández & S. Rodríguez, “Application of

PIC and microcontrollers in the measurement and control of parameters in industry” in

International Journal of Electrical Engineering Education, 41/3, 2004, pp. 266-274.

[2]M.R. Frankowiak, R.I. Grosvenor, and P.W. Prickett, “Microcontroller- Based Process

Monitoring Using Petri-Nets”, EURASIP Journal on Embedded Systems, vol. 2009,

Article ID 282708, 2009.

[3]S. R. D. Kalingamudali et al., “Remote Controlling and Monitoring System to Control

Electric Circuitry through SMS using a Microcontroller”, Industrial and Information

Systems, First International Conference on Industrial and Information Systems:

Peradeniya, Sri Lanka, 8-11 August, 2006. pp. 378-382.

[4]M. L. Glaze, “The Design and Implementation of a GUI-Based Control Allocation

Toolbox in the MATLAB® Environment”, Msc. Thesis, Virginia Polytechnic Institute

and State University, Blacksburg, 85 p. 2008.

[5] A. Delgado, R. Picking and V. Grout, “Remote-Controlled Home Automation

Systems with Different”,Centre for Applied Internet Research (CAIR), 2006.

[6] A. Alkar and U. Buhur, “An Internet Based Wireless Home Automation System for

Multifuntional Devices”,2005.

[7] N. Sriskanthan, F.Tan and A. Karande, “Bluetooth based home automation system”

ELSEVIER - Microprocessors and Microsystems, Vol. 26, pp. 281-289, 2002.

[8] R. Piyare and M. Tazil, “BLUETOOTH BASED HOME AUTOMATION SYSTEM

USING CELL PHONE”, IEEE International Symposium on Consumer Electronics, Vol.

15, 2011.

[9] I. Petrov, S. Seru, and S. Petrov, “HOME AUTOMATION SYSTEM”, School of

Engineering Science, 2011.

[10] A. Jadhav, and P. Gadhari, “Interactive Voice Response (IVR) and GSM Based

Control System”. Proceedings of the National Conference "NCNTE-2012". Mumbai.

2012

[11] S. Neng, et al., “ integrated, flexible, and Internet-based control architecture for

home automation system in the internet era”. Proceedings ICRA `02. IEEE International

Conference on Robotics and Automation, Vol. 2,pp.1101-1106, 2002.

[12] E. Yavuz, et al., “Safe and Secure PIC Based Remote Control Application for

Intelligent Home”. International Journal of Computer Science and Network Security,

Vol. 7, No. 5, May 2007.

[13] B. Koyuncu, “PC remote control of appliances by using telephone lines”. IEEE

Transaction on Consumer Electronics, Vol. 41, No. 1, pp.201-209, 1995

[14]M. AL-Rousan, et al., “Java-Based Home Automation System”. IEEE Transaction on

Consumer Electronics,Vol. 50, No. 2, May 2004.

[15]B. Myers, et al., “Taking handheld devices to the next level”. IEEE Computer

Society, December, pp. 36-45,2004.

AAs the