An Internet Based Interactive Data Acquisition System

An Internet Based
Interactive Real –Time
Data Acquisition
System
A Data Acquisition Sytem with Internet
connectivity for better Connectivity and
Controllability on a Move

Index .........
1.Introduction.................................................................................. 1
Embedded systems

Data Acquisition System

Internet Enabled Embedded Systems

Internet Data Acquisition System

Benefits

Limitations

2. An Internet Based Data Acquisition System for Real Time Applications....... 2
Tools and Components

Microcontroller ATMEGA168

ENC28J60 Ethernet Controller

MAC

PHY

RJ45 MagJack

LM35 Temperature Sensor

Power Supply

Motor Driver L293D

3.Softwares Used ............................................................................................. 13
Arduino

Processing

4. External third-party server used .................................................................. 14
Google :Google Docs

Pachube

5. Methods of Building a Data Acquisition System............................................16

6. Using the ENC28J60 Ethernet Controller Node connected to a router to
upload the sensor value .................................................................... 17

2

Methodology

Program’s structure

7. using PC to save sensor data in Google Spreadsheet ............................... 26
Methodology


8. A Full Duplex communication over the internet , between the third party
server (Pachube) and an Embedded device connected to PC directly............30

Methodology


9. Conclusion .................................................................................................................................... 34

10. Reference ....................................................................................................................................34

3

The Entire Setup of my the Internet Based Data Acquisition System

4

Introduction
Embedded Systems

Embedded systems is a computer system designed for specific control functions within a larger
system often with real time computing constraints .It is embedded as part of a complete device
often including hardware and mechanical parts whereas a desktop PC is designed to be a general-
purpose computer, such as a personal computer (PC), is designed to be flexible and to meet a wide
range of end-user needs but are quite expensive . Embedded systems control many devices in
common use today and are usually build dedicated to perform a specific task . Design engineers can
optimize it to reduce the size and cost of the product and increase the reliability and performance.
Some embedded systems are mass-produced and reducing the cost still further. Embedded systems
are especially suited for use in transportation, fire safety, military, security, medical applications in
form of alarm system monitoring abnormal activity or Data acquisition system monitoring a patient’s
heart beat for further analysing of the patient’s health. Other consumer electronics like handheld
computer , Personal Digital Assistant (PDA) , GPS , Home automation system ,Temperature
monitoring system in homes etc

Data Acquisition system
A typical Data acquisition system (DAS) consists of individual sensors with the necessary signal
conditioning , data conversion , data processing , multiplexing , data handling and associated
transmission , storage and display data. DAS is very useful in keeping track of data from sensors
recording values from the environment in real time .In order to optimise the characteristics of the
system in terms of handling capacity and cost .Analog data is generally acquired and converted ito
digital form for the purpose of processing , transmission , display and storage.

The data collected from the sensor may be transmitted over long distances from
the test center to the controlling authority , Some of the main objective of data acquisition system
are :

Use of all data efficiency to inform the operator to inform the operator about the state of
the plant.
It must monitor the complete plant operation to maintain on-line optimum and safe
operation.
It must be flexible and capable of being expanded for future requirements.
It must be able to compute unit performance indices using on-line , real time data.
It must be able to collect , summarise and store data for diagonosis of operation and record
purpose.
It must provide an effective human communication system and be able to identify problem
areas , thereby minimising unit availability and maximising unit through point at minimum
cost.

5

Processing may consist of a large variety of operations , ranging from simple comparison to
complicated mathematical manipulations. It can be for such a purpose as collection of
information(averages,satistics) ,converting the data into useful forms (eg calculations of efficiency of
motor speed , torque and power input developed), using data for controlling a process ,performing
repeated calculation to separate signals buried in the noise , generating information for display ,and
various other purpose.

Data may be transmitted over long distances or short distance . Both wired or wireless transmission
is used for transmission of data from test centre to a nearby PC , display panel or CRO .In wireless
transmission the data is send from test centre to the display unit either through infrared , Bluetooth
or Zigbee protocol . Wireless transmission tends to be more flexible , but expensive and complex as
there is a need for connecting external transmission/receiver modules between the test centre and
display unit and then to provide necessary calibration between them.

Internet Enabled Embedded Systems
Industry analysts see embedded Internet systems as poised for rapid growth in the manufacturing
sector in the next few years. To date, much of the research work pertaining to the Internet in
construction, has focused on person to person, or computer to computer communication.
Embedded Internet systems allow users to communicate with other items such as plant, machinery,
and manufactured components delivered to site. This communication may range from passive
remote monitoring to direct control or resetting. Intel terms this as the fourth phase in the evolution
of internet ; The first being connection to main frames (external server ; Primary example on what
this project is based on ) , The second being e- commerce and e-mail revolution , and the third being
social networking . With Embedded systems getting more advanced and so many devices waiting to
be connected to the internet
Generally used embedded systems like PDA, MP3 Players , Mobile phones have
already started to get connected to the internet for reasons like accessing the social networking sites
, Mobile banking (also known as M-Banking, mbanking, SMS Banking) is a term used for
performing balance checks, account transactions, payments, credit applications and other banking
transactions through a mobile device such as a mobile phone or Personal Digital Assistant (PDA),
Downloading media files like songs and video through internet to be played on PDA or MP3 players.
Popular digital camera manufacturers like Canon and Samsung are developing Cameras that can
have direct internet access using a WI-Fi connection , and directly upload images to popular photo
sharing websites like Flickr , Picasa or social networking websites like facebook .Televisions too are
also getting connected to internet . Some modern day television also have a Ethernet port to access
and play content from the internet like videos from popular video sharing websites like Youtube ,
Metacafe , Other consumer goods like Home thermostat could also be able to get connected to the
internet so that the consumer may set it to start cooling or heating the room moments before
leaving for home from their workplace .Other examples of general consumer electronics products
needed to be connected to the internet for either of the three reasons mentioned above are just too
many to be mentioned .

Internet Based Data Acquisition System
The Primary goal of building a Internet connected Data Acquisition system is to build a DAS which
would be able to acquire the necessary data from sensors , at correct speed and at a correct time
and upload and record the values up on an external server through internet . So that a system values
can be monitored from anywhere without the need of special equipments to receive and display
information in condensed , understandable and legible manner. A user may also be able to diagnose

6

the problem and could even set it right .The information can easily be accesed and controlled by PC
or PDA with internet access , which in turn can be connected to a local low cost local area network
(LAN) to transfer sensor values directly to a data logger or computer. The accessibility of this
information is significantly curtailed by this need for proximity. However, developments in the
Internet protocol, TCP/IP, which is the universal communication standard, looks set to change all of
this. In order to allow communications to be directed, every physical location on the Internet (server
or client) requires an IP address. Softwares have been designed to run in PDA or PC that passes
messages received on an IP network to the logger hardware via a serial port or USB.
Or through GPRS , Bluetooth , Zigbee etc.

Benefits : The Benefits of an internet based DAS are

Display information instantly in condensed , understandable and legible manner so that
it can be easily assimilated.
Provide a series of recorded event saved in the server , to the operator’s PDA on demand
Send an e-mail or SMS to the operator’s PC or mobile phone in case an emergency occurs
Provide the operator with necessary guidance message and options to perform secure
operation of control systems remotely in case an emergency occurs eg switching on a
cooler in case the temperature rises to an alarming level , switch on a pump to water the
plants when the moisture in soil has dropped to a very low value etc
Produce a hard copy record of all plant operationg events and various plant logs on
demand.
Internet based DAS provide the flexibility for handling embedded systems which
requires real time demands like traffic monitoring , precision agriculture , water
resources management etc

Limitation: Although few of the biggest drawback in building Internet based DAS (IDAS) are

The biggest limitation is “Security” , An IDAS with internet connectivity and an external
server acting as primary memory , Crucial information of plant operation and real-time
sensor reading might fall in wrong hands (Hackers), which could led to disastrous result
both financially and to Human life.
Power Management: Current internet enabled embedded devices (IEED)employ high
end peripherals and heavy software stacks leading to the increased consumption of
power and consequent reduction in battery life.
Full usage of Channel: Most of the Internet enabled embedded devices (IEED) available
are capable of supporting communication over fast Ethernet or even gigabit Ethernet ,
Though the communication is over the internet , they are not capable of using the
channels to the full extent. On an average , most of the IEED are capable of transferring
only a few bytes of data .
Current Internet technologies do not feature predictable delays in data delivery .Most
IEED are real time and hence predictable time delay is a basic requirement . eg In case
of A/D conversion an IDAS need some time delay (conversion time), any packets of data
through internet to the IDAS during this time interval demanding the real-time sensor
reading from IDAS could disturb the entire apparatus set-up.

7

An Internet Based Interactive Data Acquisition System for Real-time
Applications
The primary aim of building this project is to build an Microcontroller ATMega168 enabled
embedded system which could able to read analog values from temperature sensors Processes it ,
connects to a web server, and submits the values through as arguments in the URL to be stored or
processed by a script on the server. And can be accesed on demand by internet enabled PC ,PDA and
mobile phones , A application would also be running in the PDA or PC which would be able to display
the reading from the sensors in a legible and understandable manner along with the time variations.
The application should also provide options for operating other peripherals that is connected to the
embedded device like LCD, Motor ,Pump etc.

Fig 1: System Architecture of the Internet Based Data Acquisition system

The System consists of two nodes one is the microcontroller board which consists of microcontroller
ATmega168 , Temperature sensor LM35 , Potentiometer (for testing purpose) ,Motor Driver L293D
(for operating actuators like pump, fan) 3v3 volt regulator for powering the Ethernet module and
The second node is the Ethernet controller which consists of Ethernet Controller ENC28j60 from
Microchip and RJ45 Jack with Integrated magnetic and integrated LEDS (LEDA and LEDB : Depicting
Transmission and Reception of Packets through the cable)

The Microcontroller board node communicates with the Ethernet controller node using the SPI
(Serial peripheral Interface) protocol. Hence , Four cables are used for Chip Select (CS), Shift
Clock(SCLK) , SDI (Din) and SDO (Dout) to maintain SPI communication between the two nodes.

8

Tools and Components
The Major off the shelf component used in the project has been listed below. The Microcontroller ,
Temperature sensors were available from hobbyist store , The Ethernet controller and RJ45 jack with
internal magnetic however were not typically available from ordinary hobbyist stores . But are
obtained from international online stores.

Atmega168 Microcontroller
Microchip’s Ethernet controller ENC28J60
LM35 (Temperature Sensor)
RJ45 Jack
RJ45 Plug/Cable
L293D Motor Driver
LM7805 (5V regulator)
3.3V voltage regulator

Microcontroller Atmega168

Fig 2 : Pin Diagram of Microcontroller ATMEGA168

Microcontroller ATMEGA 168 is a 8 bit 28 pin microcontroller from ATMEL corporation , Some of the
prime feature of this Microcontroller because of which this microcontroller has been selected for
this project are :-

Memory Details
 1K bytes of internal SRAM
 512 bytes of EEPROM

9

 32x8 general purpose resistors (GPRs)
 Write/ Erase Cycles : 10,000 flash / 100,000 EEPROM

Peripheral Features
 8 channel 10 bit ADC
 6 PWM channels
 Two 8 bit timer/counter with separate prescaler and compare mode
 Dual programmable Serial USART
 On chip analog Comparator
 Master Slave SPI Serial Interface
 Programmable Watch Dog Timer with separate On chip Oscillator

All these features are sufficient , for building the IDAS . Pheripheral features like 8 channel ADC can
be used for reading the sensor values , PWM channels are used for operating external peripherals
like servo motors , motor etc , Serial USART is used to serially transfer data like sensor reading ,
Unexpected errors etc , On chip Analog comparator is used for comparing the sensor reading with a
reference voltage (and then to take necessary operation) , SPI Serial interface : to communicate
with the ENC28j60 ethernet controller and Watch Dog Timer to reset itself in case of unexpected
error in absence of the operator, Small size and low cost gives an extra advantage.

ENC28J60 Ethernet Controller
ENC28J60 Ethernet controller from Microchip Corporation. The ENC28J60 is a stand-alone Ethernet
controller with an industry standard Serial Peripheral Interface (SPI). It is designed to serve as an
Ethernet network interface for any controller equipped with SPI. The ENC28J60 meets all of the IEEE
802.3 specifications.
It incorporates a number of packet filtering schemes to limit incoming packets. It also provides an
internal DMA module for fast data throughput. Communication with the host controller is
implemented via two interrupt pins and the SPI, with data rates of up to 10 Mb/s. Two dedicated
pins are used for LED link and network activity indication.

Fig 3: A pin diagram of the ENC28j60 IC is shown below :

10

The Ethernet controller may be a separate, standalone device, or it may be integrated with the host
microcontroller (MCU). The Ethernet controller transmits and receives data from the Ethernet cable
and manages Ethernet protocol. Ethernet controllers are often separated into two pieces, the Media
Access Control (MAC) and the Physical Layer (PHY).

Media Access Control (MAC)

The MAC provides addressing and channel access control mechanisms for several terminals or
network nodes to communicate within a multi-point network, typical a local area network (LAN). As
part of the channel access control, it provides multiple access protocol that allows for an automatic
retransmission when a collision occurs. It also emulates a full-duplex logical communication channel
in a multi-point network. This channel may provide unicast, multicast or broadcast communication
service.

Physical Layer (PHY)

The PHY provides the means of transmitting raw bits over a physical data link (i.e. twisted pair
cable). The PHY module interfaces to a signal transformer, which in turn connects to the RJ-45
Ethernet socket. The host controller receives data from the Ethernet controller and applies the
necessary protocol rules. The host controller also formats outgoing data and places it into the
Ethernet controller transmit buffer.

Fig 4: ENC28J60 Interface with MCU and RJ45 jack

The ENC28J60 is designed to operate at 25 MHz with a crystal connected to the OSC1 and OSC2 pins.
The ENC28J60 design requires the use of a parallel cut crystal. Use of a series cut crystal may give a
frequency out of the crystal manufacturer specifications. Thus the crystal, has to be 25.000 MHz, not
24 not 26, 25 MHz no more or no less and as specified in the datasheet . This has to do with the
timing specifications of the IEEE 802.3 (Ethernet) standard, if the ENC28J60 oscillator is running at a
different frequency, it will have a very hard time to communicate with other IEEE 802.3 compliant
devices.

11

RJ45 Ethernet MAGJACK
MAGJACK is a RJ45 cable jack with an in built Ethernet transformer , Status LEDs and Sheilding

Fig 5 : RJ45 Magjack

The Yellow and the Green LEDs in the figure above indicates the Reception and Transmission of
Packets respectively.

LM35 temperature sensor
The LM35 series are precision integrated-circuit temperature sensors, whose output voltage is
linearly proportional to the Celsius (Centigrade) temperature. The LM35 thus has an advantage over
linear temperature sensors calibrated in ° Kelvin, as the user is not required to subtract a large
constant voltage from its output to obtain convenient Centigrade scaling. The LM35 does not require
any external calibration or trimming to provide typical accuracies of ±¼°C at room temperature and
±¾°C over a full -55 to +150°C temperature range. Low cost is assured by trimming and calibration at
the wafer level. The LM35's low output impedance, linear output, and precise inherent calibration
make interfacing to readout or control circuitry especially easy. It can be used with single power
supplies, or with plus and minus supplies. As it draws only 60 µA from its supply, it has very low self-
heating, less than 0.1°C in still air. The LM35 is rated to operate over a -55° to +150°C temperature
range

Fig 6 : LM35 temperature sensor pin details

12

Power Supply
The apparatus requires dual power supply of 5V and 3.3V for powering Microcontroller and
ENC28J60 respectively , The microcontroller is powered by a 5V voltage regulator LM7805 and a
Zener diode is used to regulate power provided to the ENC28J60.

Motor Driver L293D
L293D is a dual H-Bridge motor driver, So with one IC we can interface two DC motors which can be
controlled in both clockwise and counter clockwise direction. Thishelps in controlling actuators like
pump , cooler etc and if you have motor with fix direction of motion the you can make use of all the
four I/Os to connect up to four DC motors. L293D has output current of 600mA and peak output
current of 1.2A per channel. Moreover for protection of circuit from back EMF ouput diodes are
included within the IC. The output supply (VCC2) has a wide range from 4.5V to 36V, which has
made L293D a best choice for DC motor driver. Motor driver is used in the DAS to control actuators
like pump,lever,cooler etc.

A simple schematic for interfacing a DC motor using L293D is shown below.

Fig 7: L293D connection with Microcontroller

13

Fig 8: The Microcontroller Board’s schemetic with serial port, motor driver and voltage regulator

14

Fig 9: Ethernet controller ENC28J60 and MAGJACK interface Schematic

15

Fig 10 (a): The Microcontroller module with sensor(potentiometer) , motor driver and power
regulator

Fig 10(b): the Ethernet module with ENC28J60 and MagJack

16

Software used
The System requires two different set of different computer Programs one for generating a .hex file
which is to be burned inside the microcontroller ROM And the second is a interactive program with
Graphical User interface (GUI) running in PC /PDA. The program built for this project would only run
on PC. The microcontroller on the board is programmed using the Arduino programming
language (based on Wiring) and the Arduino development environment (GUI program running in PC
: Processing).

Arduino
Arduino is an open-source single-board AVR microcontroller programming software , descendant of
the open-source Wiring platform, designed to make the process of using electronics in
multidisciplinary projects more accessible. The hardware consists of a simple open hardware design
for the Arduino board with an Atmel AVR processor and on-board input/output support. The
software consists of a standard programming language compiler and the boot loader that runs on
the board. Arduino (or Wiring) programming instructions are much like that of C++ , it even supports
object oriented programming and have several pre defined library functions including for interfacing
with Ethernet modulus like Wiznet and ENC28j60 , The arduino library for ENC28J60 used in this
project was developed by Andy Lindsay and was downloaded from his blog.

Arduino has a different view of the AVR microcontroller ATMEGA168 as shown

Fig 11 : Pin’s function of AVR ATMEGA168 when used with Arduino software

Processing
Processing too is an open source programming language and integrated development
environment (IDE) built for the electronic arts and visual design communities with the purpose of
teaching the basics of computer programming in a visual context, and to serve as the foundation for
electronic sketchbooks. The project was initiated in 2001 by Casey Reas and Benjamin Fry, both
formerly of the Aesthetics and Computation Group at the MIT Media Lab. One of the stated aims of

17

“Processing” is to act as a tool to get non-programmers started with programming, through the
instant gratification of visual feedback. The language builds on the Java programming language, but
uses a simplified syntax and supports rich graphics. Other features of processing like its platform
independent and takes low memory space makes it an ideal programming tool to built GUI for
interfacing with microcontroller (sending sensor value ) , PC and external server (where the sensor
values are being recorded)

A mobile version of “processing” is available called “Mobile Processing” allows software written
using the Processing language and environment to run on Java powered mobile devices. Which can
be used to build IDAS software for mobile devices also. The Processing serial library allows for easily
reading and writing data to and from external machines. It allows two computers to send and
receive data and gives the flexibility to communicate with custom microcontroller devices, using
them as the input or output to Processing programs.

Firmata
Firmata is a generic protocol for communicating with microcontrollers from software on a host
computer. It is intended to work with any host computer software package. Right now there is a
matching object in a number of languages. It is easy to add objects for other software to use this
protocol. Basically, this firmware establishes a protocol for talking to the Arduino from the host
software , Firmata can also be used with other microcontroller like PIC microcontroller series of
Microchip . The aim is to allow people to completely control the Embedded device from software
running on the host computer. The Firmata acts as a bridge between the AVR ATMEGA168
microcontroller and the host software running on PC or PDA.

Third Party Server Sevices
When we are planning to build an embedded device which is able to collect a sensor data and
upload the sensor values in to that remotely located server. And should also be able to display the
reading back on demand by any internet enabled PC/PDA , in a legible and understandable format.
So that the sensor reading could be browsed from any geographical location or else the sensor
reading will only be available to the local clints in the LAN in which the IEED is connected. The two
third party Server used in this project are of Google and Pachube.

Google : Google Docs
Google Docs is a free, Web-based office suite, and data storage service offered by Google. It allows
users to create and edit documents online while collaborating in real-time with other users. Google
Docs originated from two separate products, Writely and Google Spreadsheets. Writely was a web
based word processor created by the software company Upstartle and launched in August
2005. Spreadsheets, launched as Google Labs Spreadsheets on June 6, 2006, originated from the
acquisition of the XL2Web product by 2Web Technologies. We would only be using the Google
Spreadsheet in our project. Where the sensor readings from the Microcontroller to PC through

18

USART protocol would be uploaded to the Google Spreadsheet feature of the user or operator’s
Google Account directly.

Pachube
Pachube is an on-line database service provider especially designed for allowing embedded system
developers to connect sensor data (energy and environment data from objects, devices & buildings)
to the Web[1] and to build their own applications on it.
It was created in 2007 by architect Usman Haque

Pachube is a realtime data infrastructure platform for the , Internet of Things (A network of
Internet enabled embedded devices )managing millions of datapoints per day from thousands of
individuals, organisations & companies around the world. Pachube's powerful and scalable
infrastructure enables you to build 'Internet of Things' products and services, and store, share &
discover realtime sensor, energy and environment data from objects, devices & buildings around the
world. Pachube enables things to "plug-in" to other things in real time so that, for example,
buildings, weather stations, interactive environments, air quality monitors, networked energy
monitors, virtual worlds and mobile sensor devices can all "talk" and "respond" to each other in
realtime

Pachube's scalable infrastructure helps you...

Manage realtime sensor & environment data:
Pachube is a data brokerage platform for the IEED, managing millions of datapoints per day from
thousands of individuals, organisations & companies around the world. Convenient, secure &
economical, Pachube stores, converts & serves data in multiple data formats, which makes it
interoperable with both established web protocols & existing construction industry standards. All
feeds include contextual metadata (timestamps, geolocation, units, tags) that actually make
datastreams valuable.

Graph, monitor & control remote environments:
Embed realtime graphs & widgets in your own website. Analyse & process historical data pulled
from any public Pachube feed. Send realtime alerts from any datastream to control scripts,
devices & environments. Out-of-the-box configurable tools include a zoomable graph,
a mapping/tracking widget, anaugmented reality viewer, SMS alerts & apps for various
smartphones. As soon as something is plugged into Pachube, you're ready to monitor & control it.

Fig 12: Pachube’s Infrastructure Architecture

19

Build mobile & web apps that create value:
With a rapid development cycle & dozens of code examples & libraries, Pachube's simple yet
sophisticated'physical-to-virtual' API makes it quick & easy to build applications that add value to
networked objects & environments. That's because real value-creation comes from the
applications that are built on top of sensor systems. Pachube handles the scalability & high-
availability required for complex data management, so as to develop applications that make
decision-making more sophisticated.

Methods of building an Internet Enabled Embedded
Systems
There are many method of building internet enabled embedded systems (IEED). Only three
methods of building an IEED has been demonstrated in this project :-

Connect the Ethernet node (already communicating with a Microcontroller) to the Router
through RJ45 cable, Assign an IP address to that Ethernet node. And then enter that IP
address in the web browser of a PC connected in the same LAN in which the Ethernet node
is connected.

Use a Internet Enabled Desktop PC (running a “Processing” code) to communicate with a
embedded device through USART protocol and uploading the sensor values to Google
Spreadsheet

Maintain a Full Duplex communication over the internet , between the third party server
(Pachube) and the Embedded device connected to PC directly. To drive actuators like cooler
and pump ; After sending the request to do so by the operator through the server.

20

Using the ENC28J60 Ethernet Controller Node connected to a
router to upload the sensor value
As already mentioned the entire hardware is divided into two parts the microcontroller Sensor
board and the Ethernet node with the Ethernet router and MAGJACK. The Microcontroller and the
Ethernet node communicates through SPI protocol. And Ethernet node sends over those values
received from microcontroller to the internet by using the Ethernet (IEEE 802.3).

Fig 13: Mode 1: Ethernet controller and Router Setup

Methodology

In this method the Microcontroller works as a simple web server that responds to web requests with
a page containing the current sensor readings. The program can be modified to change the format of
the web page that is sent, but before getting into the details of the code there are a few limitations
of this method .
Because this program is based on the etherShield library , it doesn’t implement a full TCP/IP stack.
One of the major limitations is that the etherShield library doesn’t support packet fragmentation,
which means the size of the response that can be sent is strictly limited. A full TCP/IP
implementation breaks up large messages into packets, each of which is transmitted independently
across the network and reassembled at the other end to reconstruct the complete message. Packets
are, as a major generalization, limited to between 64 and 1518 bytes in size including all the headers.
Because the TCP/IP header and the checksum eat into that you actually end up with somewhat less
than 1518 bytes as the upper size. Another and the biggest limitation of this method is The other
limitation is that the etherShield library doesn’t have any provision for specifying a gateway or
netmask, so it has no concept of routing. You can’t configure a gateway address in your program and
have it initiate a TCP/IP connection to a host outside your network because it simply won’t
understand where to send the packet. Note, however, that you can have it respond to requests from
outside your network if your gateway does source-NAT (network address translation).

In the C program written in Arduino Programming tool for microcontroller ATMEGA168, First we
need to download the EtherSheild library from the developer’s website (The EtherSheild library is

21

not available by default in the Pre defined arduino library). After which we have to call the library
from the program using the header file

#include "etherShield.h"

We then have to define a MAC address which has to be an unique in your network. Usually the MAC
address is hard programmed into the equipments firmware. However with the Arduino
programming tool we can define the MAC address ourselves. Likewise, the IP address needs to be
unique on your network, and you need to enter it twice: once as the four elements in the myIp array
and then as a string in baseurl. These values are different because the TCP/IP stack needs to use the
actual local IP address in the headers, but the web page that is created also needs to display a form
that submits to itself, and the address used in your browser may be different to the actual IP address
if your device is behind a NAT (network address translation) device such as as firewall.


// configuration. The MAC and IP address have to be unique on your LAN:
static uint8_t myMac[6] = {0x54,0x55,0x58,0x10,0x00,0x24};
static uint8_t myIp[4] = {192,168,1,15};
static char baseurl[] = "http://192.168.0.77/";
static uint16_t myPort = 80; // Listen to values coming from port 80 by default

where unit8_t is an unsigned integer of length 8 bits and unit16_t is an unsigned integer of length 16
bits. The myPort value can be changed if you want your device to listen on a port other than the
default port 80. However, if you change it make sure you also change the baseurl variable to include
the port number or the form won’t work. For example, if you wanted to listen on port 81, you could
change those lines to the following:

static char baseurl[] = "http://192.168.0.77:81/";
static uint16_t myPort = 81; // Listen port for tcp/www

The program then creates two buffers used in creating the TCP/IP packet, and creates an instance of the EtherShield
object called “es” as follows:

// Set up variables for the TCP/IP buffer
#define BUFFER_SIZE 500
static uint8_t buf[BUFFER_SIZE+1];
#define STR_BUFFER_SIZE 22
static char strbuf[STR_BUFFER_SIZE+1];
// Create an instance of the EtherShield object named "es"
//EtherShield es=EtherShield();
// Prepare the web page by writing the data to the TCP send buffer
uint16_t print_webpage(uint8_t *buf);
int8_t analyse_cmd(char *str);

After which we define the pin to which the Sensor is connected which is pin 26 of the controller and
which is pin 3 if viewed from Arduino environment. Thus we define -> #define SENSOR 3.

The setup function does some setup of the Ethernet connection, and then sets the sensor data pins
to be inputs. SFR’s of ENC28J60 used for initialization the Ethernet connections are

void setup()
{
/*initialize enc28j60*/

22

es.ES_enc28j60Init(myMac);
// Change clkout from 6.25MHz to 12.5MHz
es.ES_enc28j60clkout(2);
delay(10);
// Magjack leds configuration
// LEDA=green LEDB=yellow
// 0x880 is PHLCON LEDB=on, LEDA=on
es.ES_enc28j60PhyWrite(PHLCON, 0x880); // Values taken from the ENC28J60 datasheet
delay(500);
// 0x990 is PHLCON LEDB=off, LEDA=off
es.ES_enc28j60PhyWrite(PHLCON, 0x990);
delay(500);
delay(500);
delay(500);
// 0x476 is PHLCON LEDA=links status, LEDB=receive/transmit
delay(100);
//init the ethernet/ip layer:
es.ES_init_ip_arp_udp_tcp(myMac, myIp, myPort); //init the ethernet/ip layer:
// Set up the data pins from LM35 sensor
digitalWrite(SENSOR, LOW);
pinMode(SENSOR , INPUT);

After which the ENC28j60 would monitor the RJ45 cable to check for valid packets , using the
instruction

plen = es.ES_enc28j60PacketReceive(BUFFER_SIZE, buf);

After which we need to check the “plen” contains a valid packet, by using the instructions

if(plen!=0) {
// arp is broadcast if unknown but a host may also verify the mac address by
sending it to a unicast address( the sending of messages to a single network destination identified by a
unique address. )
if (es.ES_eth_type_is_arp_and_my_ip (buf,plen))
{
es.ES_make_arp_answer_from_request (buf);
return;
}

After these instructions we need to check where the received wether the ip address are for us , By
comparing the destination ip address in the packet with our ip address defined in the beginning of
the program which is 198.168.0.77

if (es.ES_eth_type_is_ip_and_my_ip (buf,plen) == 0)

and

if (buf[IP_PROTO_P]==IP_PROTO_ICMP_V && buf[ICMP_TYPE_P]==ICMP_TYPE_ECHOREQUEST_V)

if both the ip address match either one of the above instructions would be a valid one .

Hence the complete code to check if the ip address match :-

// check if ip packets are for us:
if (es.ES_eth_type_is_ip_and_my_ip (buf,plen) == 0) {
return;

23

}
if (buf[IP_PROTO_P]==IP_PROTO_ICMP_V && buf[ICMP_TYPE_P]==ICMP_TYPE_ECHOREQUEST_V)
{
es.ES_make_echo_reply_from_request (buf,plen);
return;
}

The main program loop is quite complex because it checks the Ethernet receive buffer each time
through and manages the appropriate responses.

// tcp port www start, compare only the lower byte
if (buf[IP_PROTO_P] == IP_PROTO_TCP_V && buf[TCP_DST_PORT_H_P] == 0 &&
buf[TCP_DST_PORT_L_P] == myPort) {
if (buf[TCP_FLAGS_P] & TCP_FLAGS_SYN_V) {
es.ES_make_tcp_synack_from_syn (buf); // make_tcp_synack_from_syn does already
send the syn,ack
return;
}

if (buf[TCP_FLAGS_P] & TCP_FLAGS_ACK_V) {
es.ES_init_len_info (buf); // init some data structures
dat_p = es.ES_get_tcp_data_pointer();
if (dat_p==0) { // we can possibly have no data, just ack:
if (buf[TCP_FLAGS_P] & TCP_FLAGS_FIN_V) {
es.ES_make_tcp_ack_from_any (buf);
}

checks are both done using a call to analyse_cmd(), which processes the request header to find
the value of the cmd (content management database) variable passed through in the request. If the
value is 1 it responds with the default page , if the cmd value is 2 it goes into the About page and like
wise. This check is not strictly necessary because if you only want your program to return the page
with the sensor data on it.
This is one of the two most important functions in the program here we can analyse the
value of cmd and point to the web page we want to display in the browser of the local client.

if (cmd==1){ .... became
if ((cmd==1)||(cmd==2)){
if (cmd==1)
{
Goto Webpage 1 //Run Function “uint16_t print_webpage (uint8_t *buf)”
}
else
{ Goto Webpage 2 // Run Function “uint16_t print_webpage_2(uint8_t *buf)”
};

}
if (strncmp ("GET ", (char *) & (buf[dat_p]), 4) != 0) {
// head, post for possible status codes

plen = es.ES_fill_tcp_data_p (buf,0,PSTR ("HTTP/1.0 200 OKrnContent-Type:
text/htmlrnrn<h1>200 OK</h1>"));
goto SENDTCP;
}

24

if (strncmp("/ ", (char *) & (buf[dat_p+4]), 2) == 0){
plen = print_webpage (buf);
goto SENDTCP;
}
cmd = analyse_cmd ((char *) & (buf[dat_p+5]));
if (cmd == 1){
plen = print_webpage (buf); // Send the "Data" page
}
if (cmd == 2){
plen = print_webpage_2 (buf); // Send a different page (if Needed )
}
SENDTCP: es.ES_make_tcp_ack_from_any(buf); // send acknowledge for http
es.ES_make_tcp_ack_with_data(buf,plen); // send data
}
}
}

The next function is a subroutine program , used to find the memory address of the The returned
value which is stored in the global var strbuf

uint8_t find_key_val(char *str,char *key)
{
uint8_t found=0;
uint8_t i=0;
char *kp;
kp=key;
while(*str && *str!=' ' && found==0){
if (*str == *kp){
kp++;
if (*kp == '0'){
str++;
kp=key;
if (*str == '='){
found=1;
}
}
}else{
kp=key;
}
str++;
}
if (found==1){
// copy the value to a buffer and terminate it with '0'
while(*str && *str!=' ' && *str!='&' && i<STR_BUFFER_SIZE){
strbuf[i]=*str;
i++;
str++;
}
strbuf[i]='0';
}
return(found);
}

The analyse_cmd() function looks specifically for a request argument called “cmd,” and returns the
value if it’s a number.

int8_t analyse_cmd (char *str)
{
int8_t r = -1;

25

if (find_key_val (str,"cmd")) {
if (*strbuf < 0x3a && *strbuf > 0x2f) {
// is a ASCII number, return it
r = (*strbuf-0x30);
}
}
return r;
}

The next function is the main function which is to be used by the arduino code to make a HTML web
page in the local clients browser

uint16_t print_webpage (uint8_t *buf)
{
// Arrays to hold the temperature reading from each sensor
char temp_sensor[10];

float tempC;

tempC=AnalogRead(sensor);

tempC=(5.0 * tempC*100.0)/1024.0 // this equation converts the analog value from lm35 into the temperature reading
// and store the value in variable TEMPC

plen=es.ES_fill_tcp_data_p(buf,plen,PSTR("<html><head><title>Arduino ENC28J60 Ethernet Shield : Made by Saptarshi
Nag : Mem no:193965</title></head><body>"));

plen=es.ES_fill_tcp_data_p(buf,plen,PSTR("<center><h1> ENC28j60 Ethernet controller </h1>"));

plen = es.ES_fill_tcp_data_p (buf, plen, PSTR ("Temprature value is"));
for (i=0;i<10;i++)
{
buf[TCP_CHECKSUM_L_P+3+plen]=temp_sensor[i++];
plen++; }
return plen;
}

There is a need to convert your data to a string, and then use of instruction


to add those characters on to the buffer.

The main program to be burned in the microcontroller for interface with the Ethernet controller
connected to a Router :-

/*

Web based Temperature monitoring system

Created by Saptarshi – Dec 2011

*/


26

#define SENSOR 0 // pin 28 of ATMEGA is pin 0 when programmed in Arduino
//Programming Environment

static uint8_t mymac[6] = {0x54,0x55,0x58,0x10,0x00,0x24};
static uint8_t myip[4] = {192,168,0,77};
static char baseurl[] = "http://192.168.0.77/";
static uint16_t mywwwport = 80; // listen port 80 by default for tcp/www
(max range 1-254)

#define BUFFER_SIZE 500
static uint8_t buf[BUFFER_SIZE+1];
#define STR_BUFFER_SIZE 22
static char strbuf[STR_BUFFER_SIZE+1];

EtherShield es=EtherShield();

// prepare the webpage by writing the data to the tcp send buffer
uint16_t print_webpage(uint8_t *buf, byte* on_off);
int8_t analyse_cmd(char *str);

void setup()
{
/*initialize enc28j60*/
es.ES_enc28j60Init(mymac);
es.ES_enc28j60clkout(2); // change clkout from 6.25MHz to 12.5MHz
delay(10);
/* Magjack leds configuration, from enc28j60 datasheet
// LEDA=greed LEDB=yellow
// enc28j60PhyWrite(PHLCON,0b0000 1000 1000 00 00);
es.ES_enc28j60PhyWrite(PHLCON,0x880);
delay(500);
//
delay(500);
//
delay(500);
//
delay(500);
//
// 0x476 is PHLCON LEDA=links status, LEDB=receive/transmit
delay(100);
//init the ethernet/ip layer:
es.ES_init_ip_arp_udp_tcp(mymac,myip,80);
uint16_t plen, dat_p;
int8_t cmd;
char buft[64];
char dbg[64];

27

plen = es.ES_enc28j60PacketReceive(BUFFER_SIZE, buf);
/*plen will ne unequal to zero if there is a valid packet (without crc
error) */
if(plen!=0){
// arp is broadcast if unknown but a host may also verify the mac
address by sending it to a unicast address.
if(es.ES_eth_type_is_arp_and_my_ip(buf,plen)){
es.ES_make_arp_answer_from_request(buf);
return;
}
// check if ip packets are for us:
if(es.ES_eth_type_is_ip_and_my_ip(buf,plen)==0){
return;
}
if(buf[IP_PROTO_P]==IP_PROTO_ICMP_V &&
buf[ICMP_TYPE_P]==ICMP_TYPE_ECHOREQUEST_V){
es.ES_make_echo_reply_from_request(buf,plen);
return;
}
// tcp port www start, compare only the lower byte
if
(buf[IP_PROTO_P]==IP_PROTO_TCP_V&&buf[TCP_DST_PORT_H_P]==0&&buf[TCP_DST_POR
T_L_P]==mywwwport){
if (buf[TCP_FLAGS_P] & TCP_FLAGS_SYN_V){
es.ES_make_tcp_synack_from_syn(buf); // make_tcp_synack_from_syn
does already send the syn,ack
return;
}
if (buf[TCP_FLAGS_P] & TCP_FLAGS_ACK_V){
es.ES_init_len_info(buf); // init some data structures
dat_p=es.ES_get_tcp_data_pointer();
if (dat_p==0){ // we can possibly have no data, just ack:
if (buf[TCP_FLAGS_P] & TCP_FLAGS_FIN_V){
es.ES_make_tcp_ack_from_any(buf);
}
return;
}
if (strncmp("GET ",(char *)&(buf[dat_p]),4)!=0){
// head, post and other methods for possible status codes

plen=es.ES_fill_tcp_data_p(buf,0,PSTR("HTTP/1.0 200
OKrnContent-Type: text/htmlrnrn<h1>200 OK</h1>"));
goto SENDTCP;
}
if (strncmp("/ ",(char *)&(buf[dat_p+4]),2)==0){
plen=print_webpage(buf, on_off);
goto SENDTCP;
}

cmd = analyse_cmd ((char *) & (buf[dat_p+5]));
if (cmd == 1){
plen = print_webpage (buf); // Send the "Data" page
}
if (cmd == 2){
plen = print_webpage_2 (buf); // Send a different page (if Needed )
}
SEND TCP: es.ES_make_tcp_ack_from_any(buf); // send ack for http
es.ES_make_tcp_ack_with_data(buf,plen); // send data
}
}

28

// The returned value is stored in the global var strbuf
uint8_t find_key_val(char *str,char *key)
{
uint8_t found=0;
uint8_t i=0;
char *kp;
kp=key;
while(*str && *str!=' ' && found==0){
if (*str == *kp){
kp++;
if (*kp == '0'){
str++;
kp=key;
if (*str == '='){
found=1;
}
}
}else{
kp=key;
}
str++;
}
if (found==1){
// copy the value to a buffer and terminate it with '0'
while(*str && *str!=' ' && *str!='&' &&
i<STR_BUFFER_SIZE){
strbuf[i]=*str;
i++;
str++;
}
strbuf[i]='0';
}
return(found);
}

int8_t analyse_cmd(char *str)
{
int8_t r=-1;

if (find_key_val(str,"cmd")){
if (*strbuf < 0x3a && *strbuf > 0x2f){
// is a ASCII number, return it
r=(*strbuf-0x30);
}
}
return r;
}

uint16_t print_webpage (uint8_t *buf)
{
// Arrays to hold the temperature reading from each sensor
char temp_sensor[10];

float tempC;

tempC=AnalogRead(sensor);

tempC=(5.0 * tempC*100.0)/1024.0 // this equation converts the analog value from lm35 into the temperature reading
// and store the value in variable TEMPC

29

plen=es.ES_fill_tcp_data_p(buf,plen,PSTR("<html><head><title>Arduino ENC28J60 Ethernet Shield : Made by Saptarshi
Nag : Mem no:193965</title></head><body>"));

plen=es.ES_fill_tcp_data_p(buf,plen,PSTR("<center><h1> ENC28j60 Ethernet controller </h1>"));

plen = es.ES_fill_tcp_data_p (buf, plen, PSTR ("Temprature value is"));
for (i=0;i<10;i++)
{
plen++; }
return plen;
}

}

The program above has been made to build a simple webserver to put up the sensor values up on
the internet. This is a Half Duplex communication.

Mode 2 : using PC to save sensor data in Google
Spreadsheet
This method only needs the microcontroller /Sensor module Connected to a PC with internet
connectivity through USART protocol , no need of the Ethernet controller. The microcontroller
continuously sends the sensor data to the computer through the serial port. A software client
portion of this project runs on PC and is written in processing Processing is a computer language and
development environment similar to Arduino and created for creating virtual effect program . We
use Processing to build a computer program which would be running on the computer which would
serialy accept the data being transmitted by the Microcontroller, Directly to the Google Server.

The best thing is that you can then use any of the goodies that Google provides (charts, gadgets,
maps, etc) directly with your data. While the Temperature sensor LM35 is pretty basic, you can use
this basic setup to record data from more sophisticated sensors, such as a Parallax GPS receiver
module into Google Spreadsheets. And use Google maps to point to the latitude/longitude you are
located in.

The sketch (Processing’s code) relies on the Google API Client Library for Java, which is a set of code
libraries for interacting with various Google’s services (not just Spreadsheets).

Methodology

Create a Spreadsheet
The first step in the project is to set up a Google Spreadsheet. To do this, we first need to sign in to
our Google account . Sign in, and then go into documents to create a new spreadsheet named
“sensor log.” Then, add the following columns in first row: “date,” “time,” and “reading, these
column headers are used in the code to interact with the data in the spreadsheet. Then save the
spreadsheet.

Loading the Program on the host Computer

30

We first download the “Java client library” and “ Google Collection Library” nicknamed “Guava” to
the “Processing” library. After downloading the required libraries. We built the Processing code
which reads the serial port for sensor values and upload the code to the spreadsheet service of the
Google account assigned in the code .

In the beginning we need to import the library whose functions( predefined ) we would be using in
our program

import com.google.gdata.client.spreadsheet.*;
import com.google.gdata.data.*;
import com.google.gdata.data.spreadsheet.*;
import com.google.gdata.util.*;

The four instructions above imports from the Google API client library depending on the application
we are working on (Google Spreadsheet). The above four imported packages also have been
recommended for spreadsheet related application in Google Developers Guide (v3.0). the last
imported package gdata.util is the most important among all the four gdata.util contains a wide
assortments of classes and interfaces throughout the core Google Api client library .

import processing.serial.*;

This instruction is used for importing the Processing’s serial library. The Processing serial library
allows for easily reading and writing data to and from external machines. In this case the
ATMEGA168 microcontroller.

The next few instructions are used to uniquely identify your Google Account and the spreadsheet we
want to record our temperature sensor data.

// Variables structures for google spreadsheet API
SpreadsheetService service; //Holds link to all my spreadsheets
WorksheetEntry worksheet; //Holds link to the sensor log spreadsheet
String uname = "[Saptarshi.nag99]";//My Google user name
String pwd = "[--- My Google Password ---]";

String spreadsheet_name = "sensor log"; //Name of the spreadsheet we want
to want to write the sensor data to.

int spreadsheet_idx = 0; //Index for the "sensor log spreadsheet

Next we define the variables we need for writing sensor data ...

Serial port; // Create object from Serial class
int oldTime; //timer variable
int reportingInterval = 2000; //Number of miliiseconds between when sensor
data is recorded ; This is the Sampling rate which may differ for
diffent sensors

After this declaration, our main program starts, We use the predefined library of the Google API
clent within the user defined function“ transmitData(<value to be written>)” which passes values to
the Google spreadsheet.

void transmitData(float val) {

31

String date = day() + "/" + month() + "/" + year(); //Build the current
date,from Google server
String time = hour() + ":" + minute() + ":" + second(); //Build the
current time,from Google server
try {
//Create a new row with the name value pairs
ListEntry newEntry = new ListEntry(); //Creates an object “newEntry”
newEntry.getCustomElements().setValueLocal("date", date);
newEntry.getCustomElements().setValueLocal("time", time);

newEntry.getCustomElements().setValueLocal("reading",Float.toString(val));
//Write it out to the google doc
URL listFeedUrl = worksheet.getListFeedUrl();
ListEntry insertedRow = service.insert(listFeedUrl, newEntry);
} catch (Exception e) {
println(e.getStackTrace());
}
}

In the above lines of code the instructions :


newEntry.getCustomElements().setValueLocal("reading",Float.toString(val));

Are the ones which actually upload values up on the Google Server. transmitdata() is where most of
the work happens. It starts by creating a number of strings that hold the current date and the time,
and then creates a new ListEntry, which is the primary data class used to interact with worksheets.
The class method getCustomElements().setValueLocal() is used to map the Processing variables to
the column names in the worksheet.

The codes have been enclosed between the try – catch block which is a Java programming
instruction for exceptional handling. An exception is an event, which occurs during the execution
of a program, that disrupts the normal flow of the program's instructions. The catch block contains
code that is executed if and when the exception handler is invoked.

The next codes set up the processing to start receiving serial data

Println(Serial.list);

String arduinoPort = Serial.list()[<the port number controller is
connected>];

port = new Serial(this, arduinoPort, 9600);

The first instruction , list the number of available serial ports in your PC , In the second instruction
we assign the name of the port “arduinoPort” and in the third line of the instruction we define the
baudrate in this case by the rate of 9600 baud rate data would be transmitted/Received between PC
and microcontroller

The Main Processing Program:-

import com.google.gdata.client.spreadsheet.*;

32

import com.google.gdata.data.*;
import com.google.gdata.data.spreadsheet.*;
import com.google.gdata.util.*;


// Variables structures for google spreadsheet API
SpreadsheetService service; //Holds link to all your spreadsheets
WorksheetEntry worksheet; //Holds link to the sensor log spreadsheet
String uname = "[Saptarshi.nag99]"; //Your google account user name
String pwd = "[--- My Google Password ---]";
String spreadsheet_name = "sensor log";
int spreadsheet_idx = 0; //Index for the "sensor log spreadsheet

//Variables for writing sensor data
Serial port; // Create object from Serial class
int oldTime; //timer variable
int reportingInterval = 2000; //Number of miliiseconds between when sensor
data is recorded

// Sends the data to the spreadsheet
void transmitData(float val) {
String date = day() + "/" + month() + "/" + year(); //Build the current
date
String time = hour() + ":" + minute() + ":" + second(); //Build the
current time
try {
//Create a new row with the name value pairs
ListEntry newEntry = new ListEntry();
newEntry.getCustomElements().setValueLocal("reading",
Float.toString(val));
//Write it out to the google doc
URL listFeedUrl = worksheet.getListFeedUrl();//URL of the resource is set

ListEntry insertedRow = service.insert(listFeedUrl, newEntry);
println(e.getStackTrace());
}
}

void setup() {
//Set up the serial port to read data
Println(Serial.list)
String arduinoPort = Serial.list()[3];
port = new Serial(this, arduinoPort, 9600);
oldTime = millis();

//Set up the google spreadsheet
try {
service.setUserCredentials(uname, pwd);
// Search for the spreadsheet named we're looking for

// this code pulls a list of all the Spreadheets inthe acocunt and
searches for the
// one with the matching name.
URL feedURL = new
URL("http://spreadsheets.google.com/feeds/spreadsheets/private/full/");

33

SpreadsheetFeed feed = service.getFeed(feedURL,SpreadsheetFeed.class);

for (SpreadsheetEntry entry: feed.getEntries()) {
if (entry.getTitle().getPlainText().equals(spreadsheet_name) ) {
break;
}
spreadsheet_idx += 1;
}
//Fetch the correct spreadsheet
SpreadsheetEntry se = feed.getEntries().get(spreadsheet_idx); //Fetch
the spreadsheet we want
worksheet = se.getWorksheets().get(0); //Fetch the first worksheet
from that spreadsheet
println("Found worksheet " + se.getTitle().getPlainText());

println(e.toString());
}
}

//Reads the port every few seconds and sends the data back to Google
void draw() {
float val = 0;
if (port.available() > 0) { // If data is available,
val = port.read(); // read it and store it in val
transmitData(val); // Send the val as argument in the function
//transmitData(float)
}

}

Mode 3:

A Full Duplex communication over the internet , between the
third party server (Pachube) and an Embedded device
connected to PC directly.
Pachube is an on-line database service provider allowing developers to connect sensor data (energy
and environment data from objects, devices & buildings) to the Web and to build their own
applications on it. This method uses a internet enabled PC connected through a serial port to the
embedded device. The microcontroller sends the sensor values to the PC through the serial port . A
processing code is used in this method too to run on the host PC collect the data being send by the
microcontroller through serial port and this time uses Pachube services to host the sensor data in a
graphical and legible order. Pachube also provides application of dial and push button to send data
to the embedded device.

Methodology
Create an account in Pachube

34

First we need to make an account in Pachube.com by filling in a form and select a username and
password. Then go to Homepage > My feeds and The browser will redirect you to another page
,where you have to fill in an another form where you mention the:

 Title of the Feed
 Description of the Feed
 Select Tags (optional)
 Geographical Location name
 Select your location in the Map or mention your latitude/longitude
 Select the Domain your sensors are working at (Indoor or outdoor), (Fixed/Mobile)
 Select the privacy settings (Public or Private)
 Add a Datastream (variable whose values will be displayed and stored)

Screenshot of the generated Pachube Datastream form page :

Immediately after filling up the form , We request the Pachube service to generate an API key
for the Datastream ( Which we would be using in our Processing program )

After we set up the following configuration details in our Pachube account. Its time to start
sending data . We connect the Microcontroller board with the host PC.

In Processing we have to install New libraries of Pachuino Library (v 005), EEML library
( Extended Environments Markup Language (EEML)) for link processing codes to Pachube.

35

After which we compile the processing code (given below), in the host PC :


import cc.arduino.*;

import eeml.*;

import pachuino.*;

Pachuino p; // Create an object ‘p’

void setup(){

p = new Pachuino(this, Arduino.list()[2],9600); // where 9600 is the baud rate

//and [2] is the serial port were the microcontroller is connected

p.setPort(5230);

p.setKey("cI2AMoDhJj1RDuiTXi9kTsmLMegU90G8Gw8hZaXjlOvuMROxqHh9fezUT6sBR5sZWT
jDe4KyKAQgYEybQrHMyKnBDL5HKdWYOPQ4yMmntWWhgdUFw0Nyhy2i9Q6fDfMH");

// MY API KEY ; Provided to me by Pachube.com

// local sensors

p.addLocalSensor("analog", 0,"Temperature");

}

void draw(){

float tempVal1 = p.localSensor[0].value;

p.digitalWrite(15, 1); // Make the enable pin of l293D high

}

36

void onReceiveRequest(DataOut d){

p.updateLocalSensors(d);

}

OutPut Screenshot
On Entering the URL https://pachube.com/feeds/44513 in a web browser (Google Chrome, in my
case) the present sensor reading along with other information like Geographical location and other
details will be displayed in a graphical and legible manner.

37

Other Pachube Plugins and apps
Besides the online database management services provided by the Pachube , Pachube.com provides
its user with wide range of graphical apps to its users, One of them is the use of graphical Virtual
Switch and Rotary Dial which could be used to controlling and manipulate actuators from a remote
location.

Pachube.com also provides option on how to display the data in other various graphical formats like
dial clock , graphs with preferred color settings etc.

38

Conclusion

 This is a prototype of an Internet Enabled Data Acquisition system , which
demonstrates how to upload the sensor value to a remote server through internet.
 It demonstrates the application of ENC28j60 Ethernet module developed by
Microchip
 It demonstrates how to use the service of third-party external server of Pachube to
collect and categorise data in legible and graphical order
 The complexity of the program increases with functionality , Protocols and
Embedded systems are designed to minimise the complexity so that even a non
technical operator can use the system with ease.
 Internet based data acquisition system could be widely used in industries and
home for monitoring sensor data remotely wirelessly without the need of
expensive wireless receiver/transmission module.

Reference

1. Pactical Arduino : A book on Arduino programming environment written by Jonathan
Oxan
2. Getting Started with Processing : Book written by Casy Reans and Ben Fry on the
Processing programming language
3. Micrchip.com: Documentary notes of ENC28J60 Ethernet controller module
4. Atmel.com: Documentary notes on ATMEGA168 microcontroller
5. Arduino.cc: Official arduino programming website
6. Pachube.com
7. Mr Andy D linslay’s blog: http://blog.thiseldo.co.uk
8. Nuelectronics.com: developers of ENC28J60 ethernet module’s ‘C’ library for
Arduino
9. Makezine.com: online magazine for electronics hobbyist Projects
10. Code.google.com: to read the documentary of the Google API library for Java client.

39

An Internet Based Interactive Data Acquisition System

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (19)

Ähnlich wie An Internet Based Interactive Data Acquisition System

Ähnlich wie An Internet Based Interactive Data Acquisition System (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

An Internet Based Interactive Data Acquisition System