This project shows how to implement a distributed sensor network by using the arduino and the ethernet shield.

1. Web Client concept

Since I published ethernet Shield web-server project note a few months ago [link], I’ve got a few emails about how to use the Ethernet shield as a web client. In a sense, a web client application is more appropriate for a small device such as the Ethernet shield on Arduino.

Based on the TCP/IP protocol, it is the web client (such as a web browser) who initializes the TCP connections, requests data from or sends data to the web server. Therefore the ethernet shield running in web client mode can be used as a distributed sensor node in the network. It can send periodic or interrupt driven sensor data to a web server. The web server can then record, process and show the sensor data from one or multiple web client.

In this project, a web client application is devloped for the ethernet shield, which can send periodic data (such as temperature reading) or spontaneous data (such as infrared sensor data or switch press) to a webserver. PHP scripts that used to save and show the data received on the websever are also developed.

2. Web Client TCP/IP implementation

The Web client TCP/IP protocol is implemented in the client_process() routine, which is called in the main Arduino sketch loop() routine. The client process uses a state machine to control the TCP/IP protocol as shown in the following code segment –

void client_process ( void )
{
    uint16_t plen;
	uint8_t i;
    if (client_data_ready == 0)  return;     // nothing to send

	if(client_state == IDLE){   // initialize ARP
       es.ES_make_arp_request(buf, dest_ip);

	   client_state = ARP_SENT;
	   return;
	}

	if(client_state == ARP_SENT){

        plen = es.ES_enc28j60PacketReceive(BUFFER_SIZE, buf);

		// destination ip address was found on network
        if ( plen!=0 )
        {
            if ( es.ES_arp_packet_is_myreply_arp ( buf ) ){
                client_state = ARP_REPLY;
				syn_ack_timeout=0;
				return;
            }

		}
	        delay(10);
		syn_ack_timeout++;

		if(syn_ack_timeout== 100) {  //timeout, server ip not found
			client_state = IDLE;
			client_data_ready =0;
			syn_ack_timeout=0;
			return;
		}
    }

 // send SYN packet to initial connection
	if(client_state == ARP_REPLY){
		// save dest mac
		for(i=0; i<6; i++){
			dest_mac[i] = buf[ETH_SRC_MAC+i];
		}

        es.ES_tcp_client_send_packet (
                       buf,
                       80,
                       1200,
                       TCP_FLAG_SYN_V,                 // flag
                       1,                                              // (bool)maximum segment size
                       1,                                              // (bool)clear sequence ack number
                       0,                                              // 0=use old seq, seqack : 1=new seq,seqack no data : new seq,seqack with data
                       0,                                              // tcp data length
		      dest_mac,
		      dest_ip
                       );

		client_state = SYNC_SENT;
	}
  // get new packet
  if(client_state == SYNC_SENT){
    plen = es.ES_enc28j60PacketReceive(BUFFER_SIZE, buf);

       // no new packet incoming
    if ( plen == 0 )
    {
        return;
    }

       // check ip packet send to avr or not?
       // accept ip packet only
    if ( es.ES_eth_type_is_ip_and_my_ip(buf,plen)==0){
		return;
    }

       // check SYNACK flag, after AVR send SYN server response by send SYNACK to AVR
    if ( buf [ TCP_FLAGS_P ] == ( TCP_FLAG_SYN_V | TCP_FLAG_ACK_V ) )
    {

               // send ACK to answer SYNACK

               es.ES_tcp_client_send_packet (
                       buf,
                       80,
                       1200,
                       TCP_FLAG_ACK_V,                 // flag
                       0,                                              // (bool)maximum segment size
                       0,                                              // (bool)clear sequence ack number
                       1,                                              // 0=use old seq, seqack : 1=new seq,seqack no data : new seq,seqack with data
                       0,                                              // tcp data length
						dest_mac,
						dest_ip
                       );
               // setup http request to server
               plen = gen_client_request( buf );
               // send http request packet
               // send packet with PSHACK
               es.ES_tcp_client_send_packet (
                                       buf,
                                       80,                                             // destination port
                                       1200,                                   // source port
                                       TCP_FLAG_ACK_V | TCP_FLAG_PUSH_V,                        // flag
                                       0,                                              // (bool)maximum segment size
                                       0,                                              // (bool)clear sequence ack number
                                       0,                                              // 0=use old seq, seqack : 1=new seq,seqack no data : >1 new seq,seqack with data
                                       plen,                           // tcp data length
                                       dest_mac,
									   dest_ip
									   );
               return;
       }
       // after AVR send http request to server, server response by send data with PSHACK to AVR
       // AVR answer by send ACK and FINACK to server
       if ( buf [ TCP_FLAGS_P ] == (TCP_FLAG_ACK_V|TCP_FLAG_PUSH_V) )
       {
               plen = es.ES_tcp_get_dlength( (uint8_t*)&buf );

               // send ACK to answer PSHACK from server
               es.ES_tcp_client_send_packet (
                                       buf,
                                       80,                                             // destination port
                                       1200,                                   // source port
                                       TCP_FLAG_ACK_V,                  // flag
                                       0,                                              // (bool)maximum segment size
                                       0,                                              // (bool)clear sequence ack number
                                       plen,                                           // 0=use old seq, seqack : 1=new seq,seqack no data : >1 new seq,seqack with data
                                       0,                              // tcp data length
				      dest_mac,
				      dest_ip
               );;
               // send finack to disconnect from web server

               es.ES_tcp_client_send_packet (
                                       buf,
                                       80,                                             // destination port
                                       1200,                                   // source port
                                       TCP_FLAG_FIN_V|TCP_FLAG_ACK_V,                  // flag
                                       0,                                              // (bool)maximum segment size
                                       0,                                              // (bool)clear sequence ack number
                                       0,                                           // 0=use old seq, seqack : 1=new seq,seqack no data : >1 new seq,seqack with data
                                       0,
										dest_mac,
										dest_ip
				);

               return;

       }
       // answer FINACK from web server by send ACK to web server
       if ( buf [ TCP_FLAGS_P ] == (TCP_FLAG_ACK_V|TCP_FLAG_FIN_V) )
       {
               // send ACK with seqack = 1
               es.ES_tcp_client_send_packet(

                                       buf,
                                       80,                                             // destination port
                                       1200,                                   // source port
                                       TCP_FLAG_ACK_V,                 // flag
                                       0,                                              // (bool)maximum segment size
                                       0,                                              // (bool)clear sequence ack number
                                       1,                                              // 0=use old seq, seqack : 1=new seq,seqack no data : >1 new seq,seqack with data
                                       0,
									   dest_mac,
									   dest_ip
				);
			client_state = IDLE;		// return to IDLE state
			client_data_ready =0;		// client data sent
		}
  }
}

The client data is generated in the gen_client_request routine. The following example shows that a temperature reading is filled into the http buffer. The keyword “pwd”, “client” and “status” are used for the server php script to identify the data that client sends.

uint16_t gen_client_request(uint8_t *buf )
{
	uint16_t plen;
	byte i;

	plen= es.ES_fill_tcp_data_p(buf,0, PSTR ( "GET /ethershield_log/save.php?pwd=secret&client=" ) );
        for(i=0; client_ip[i]!='\0'; i++){
            buf[TCP_DATA_P+plen]=client_ip[i];
            plen++;
        }
        plen= es.ES_fill_tcp_data_p(buf,plen, PSTR ( "&status=temperature-" ) );
        for(i=0; sensorData[i]!='\0'; i++){

                buf[TCP_DATA_P+plen]=sensorData[i];
                plen++;
        }	

	plen= es.ES_fill_tcp_data_p(buf, plen, PSTR ( " HTTP/1.0\r\n" ));
	plen= es.ES_fill_tcp_data_p(buf, plen, PSTR ( "Host: 192.168.1.4\r\n" ));
	plen= es.ES_fill_tcp_data_p(buf, plen, PSTR ( "User-Agent: AVR ethernet\r\n" ));
        plen= es.ES_fill_tcp_data_p(buf, plen, PSTR ( "Accept: text/html\r\n" ));
	plen= es.ES_fill_tcp_data_p(buf, plen, PSTR ( "Keep-Alive: 300\r\n" ));
	plen= es.ES_fill_tcp_data_p(buf, plen, PSTR ( "Connection: keep-alive\r\n\r\n" ));

	return plen;
}

3. Web Server and PHP scripts

To test the web client application, I set up a web server in my home LAN environment. I used the wampserver package, which has Apache, PHP and MYSQL, in the windows. The installation is straightforward, after installation you need to allow the client ip address to access your apache webserver by modifying the httpd.conf file. For me, I just enable all my local ip addresses as –

    #
    # Possible values for the Options directive are "None", "All",
    # or any combination of:
    #   Indexes Includes FollowSymLinks SymLinksifOwnerMatch ExecCGI MultiViews
    #
    # Note that "MultiViews" must be named *explicitly* --- "Options All"
    # doesn't give it to you.
    #
    # The Options directive is both complicated and important.  Please see
    # http://httpd.apache.org/docs/2.2/mod/core.html#options
    # for more information.
    #
    Options Indexes FollowSymLinks

    #
    # AllowOverride controls what directives may be placed in .htaccess files.
    # It can be "All", "None", or any combination of the keywords:
    #   Options FileInfo AuthConfig Limit
    #
    AllowOverride all

    #
    # Controls who can get stuff from this server.
    #
#   onlineoffline tag - don't remove
    Order Deny,Allow
#    Deny from all
    Allow from 127.0.0.1 192.168.1

Two PHP script are developed for saving and showing the web client data. The save.php is used to save web client data to a data.txt file. It looks for the keywords “pwd”, “client” and “status” in the http data sent by the client, and then record them with timestamps.

<?php
function get_val ( $val )
{

		return $_GET[$val];

}

$password = get_val ( 'pwd' );

if ( $password != 'secret' )
{
	echo "<font color=red><b>Access denied!!!</b></font>";
	exit;
}

$client = get_val('client');
if ( $client == '' )
{
	echo "<font color=red><b>Wrong client number!!!</b></font>";
	exit;
}

$status = get_val ( 'status' );

if ( $status == '' )
{
	echo "<font color=red><b>Wrong client status!!!</b></font>";
	exit;
}

$filename = "./data.txt";
$time = date ("Y-n-j H:i:s");

$string = $client . '|' .$time.';'.$status."\r\n";
$a = fopen("$filename", "a+");
fputs($a, $string);
fclose($a);
?>

The index.php script dynamically reads data from the data.txt file and shows them in a table format. It can be accessed for a web browser as shown below.

4. Software structure

A new version of ethernet shield software is developed based on tuxgraph’s code and avrnet code. The software is in the form of Arduino library and completes with a few examples, which consists of -

• etherShield.cpp - a wrapper cpp file, as an Arduino library interface.
• ip_arp_udp_tcp.c - the IP, ARP, UDP and TCP protocol implementation, now with new web client founctions.
• enc28j60.c - ENC28J60 SPI routines
• net.h - network protocol definitions.
• /examples -
  • etherShield_ping - the PING example
  • etherShield_web_temperature - a Web server temperature sensor example
  • etherShield_web_switch - a Web server led switch exampe
  • etherShield_web_client - a Web client example that sends periodic temeperature sensor reading.
  • etherShield_web_client1 - a Web client example that sends spontaneous infrared sensor stauts

5. Links & Downloads

• Arduino Ethernet Shield schematic V1.0
• Arduino ethershield library - new version with web client funtions & examples
• Microchip ENC28J60 datasheet

1. Schematic

The Arduino Ethernet Shield V1.0 is dedicated for the Arduino boards. It uses the Microchip’s ENC28J60 SPI based stand-alone Ethernet controller (download datasheet here) and a compatible RJ45 socket with magnetics. Since the ENC28J60 is a 3V3 device that only drive 3V3 logic level output but capable of accepting 5V logic input, a 5V CMOS/TTL quad positive AND gates 74HCT08D is used to convert the 3.3 logic level output to 5V logic level.

2. Software Structure

The Ethernet Shield software is in the format of Arduino library, which you can download from here. The library is implemented based on tuxgraphics.org’s open-source TCP/IP stack for Atmega88 and ENC28J60. The main files in the library are –

• etherShield.cpp — a wrapper cpp file, as an Arduino library interface with tuxgraphic’s code
• ip_arp_udp_tcp.c — simplified TCP/IP stack implementation
• enc28j60.c — ENC28J60 SPI routines
• net.h — network protocol definitions

3. TCP/IP implementation

The standard TCP is a protocl to establish a connection. To do this, a number of packets needs to be exchaged between two sides first to establish the connection; then data packets can be exchaged. Usually a complicated state-machine is needed to implement the TCP protocol.

For Auduino’s ATMEGA168, a 8-bit AVR microcontroller with 1K SRAM, it is impossible to implement the full TCP stack. Also the webpage for 8-bit microcontroller that normally is used to control a relay or read a temperature sensor etc., is very simple. Therefore, instead of implementing full TCP protocl, a single data packet TCP protocol is used. You webpage contents, including all html tags, must be in one packet. The length of packet is limited by the SRAM size, currently half of the RAM space (500 bytes) is used for network Packet buffer. It is sufficient for simple webpages as shown below.

4. Ethersheild library installation & modification

First download the ethershield library here, then copy & unzip the library in your Arduino IDE library directory (for example arduino-0010/hardware/libraries/).

There are three examples in the ethershield library, you might need to change the ip address in the example sketch (.pde) files. The ip address must be a free address with your network range

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.1.15/";  

Also you might like to change the webpage contents in the print_webpage funtion. Note that the webpage contents are stored in the PROGMEM (using PSTR declaration) to save the precious SRAM space.

5. Examples

Three examples are included in the ethershield library –

• ethershield_ping.pde — a PING example

  

• ethershield_webserver.pde — a general webserver example

  

• ethershield_web_temperature.pde — a webserver with temperature sensor (DS18B20) readings

  

• ethershield_web_switch.pde — New — Webserver example, switch on/off LED

  

5. Links & Downloads

• Arduino Ethernet Shield schematic V1.0
• Arduino ethershield library - new version with web client funtions & examples
• Microchip ENC28J60 datasheet

1. LCD Smartie

LCD Smartie is an open-source software for Windows that you can use to show lots of different types of information on your LCD/VFD that connects to the PC via USB/Serial/Parallel ports.
It can display: CPU frequecy, load etc; BBC World News (or any other RSS feed!); WinAmp stats; Network stats (speed, total bytes, etc); Disk available/free, memory usage, Email details, game stats, and many more…

2. Firmware Features

The LCD Keypad Shield for Arduino is a perfect platform for implementing the LCD Smartie on Arduino. An Arduino sketch is developed to interface the LCD Smartie software running on the PC, and it has following features -

• Drives the LCD Keypad Shield using the modified LCD_4Bit library download here
• Implements a basic subset of the Matrix Orbital commands
• Baud Rate 19200, 8bits, 1 stop, no parity
• Interrupt driven 5-key Joystick keypad reading routine to send key press to the PC

You can download the sketch from here

3. Firmware Description

3.1 Main loop() routine
The main loop() routine implements a command interpreter to accept and execute the commands and data sent by the LCD smartie software running on the PC. It implements a basic subset of the Matrix Orbital commands –

3.2 Interrupt driven Keypad scanning routine
An interrupt driven Keypad scanning routine is used to capture key press from the Joystick keypad inputs. Timer2 is used to generate interrupt at 4ms interval. The interrupt routine records the key press by reading AD0 value and comparing with keypad value stored in an array. A debounce mechnism is also implemented. The interrupt routine then transfer the key press to LCD Smartie software running on the PC. The key press is useful for controlling PC applications, such as Winamp Player.

4. Hardware and Software Setup Procedure

• Download & install the modified LCD_4bit library as shown here .
• Download the Arduino LCD Smartie sketch here .
• Compile and upload your sketch to the Arduino/Freeduino board
• Setup the LCD Smartie software as following pictures –

Fig 1. LCD Smartie 5.4 Plugin setup tab –
Display Plugin — choose matrix.dll
Startup Paramters — Choose COM number (for Arduino boards) & 19200 baud rate

Fig 2. LCD Smartie 5.4 Screen setup tab –
LCD Size - 2×16

5. Screenshots

The following pictures are some screenshots of LCD Smartie on Arduino… ENJOY !!!

1. Schematic

The LCD Keypad shield is developed for Arduino compatible boards, to provide a user-friendly interface that allows users to go through the menu, make selections etc. It consists of a 1602 white character blue backlight LCD and 5 pushbuttons that form a joystick-style keypad.

2. LCD Interface

The LCD interaface uses HD44780D 4-bit compatible interface. In order to preserve the SPI interface for future use, a different set of IO pins is used. The following diagram shows the IO pins used to drive the LCD, you can modify the original 4bit LCD libaray [download here] or you can download the modified 4-bit LCD library [download here] .

int USING_RW = false;

//RS, RW and Enable can be set to whatever you like

int RS = 8;

int RW = 11;

int Enable = 9;

//DB should be an unseparated group of pins 

int DB[] = {4, 5, 6, 7}; //wire these to DB4~7 on LCD. 

3. Keypad Interface

The joystick style keypad consists of 5 keys — select, up, right, down and left. To save the digital IO pins, the keypad interface only uses one ADC channel. The key value is read through a 5 stage voltage divider as shown below.

When a key is pressed, the ADC reads the voltage value through the voltage divider; the the voltage value is compared to the voltage threshold values stored in an array to identify which key is pressed.

 int adc_key_val[5] ={30, 150, 360, 535, 760 };

int NUM_KEYS = 5;

....

void loop() 

{ adc_key_in = analogRead(0); // read the value from the

sensor digitalWrite(13, HIGH); 

key = get_key(adc_key_in); // convert into key press 

if (key != oldkey) // if keypress is detected {

delay(50); // wait for debounce time 

adc_key_in = analogRead(0); //read the value from the sensor

key = get_key(adc_key_in); // convert into key press

 if (key != oldkey) { 

oldkey = key; 

if (key >=0){

lcd.cursorTo(2, 0); //line=2, x=0 

lcd.printIn(msgs[key]); 

} 

} 

}

digitalWrite(13, LOW); }

4. Examples

Two exmaples for LCD keypad shield are included in the midified LCD 4-bit library [download here]

• Example 1 — Joystick keypad test routine, keypress shown on the LCD screen
• Example 2 — Temperature measurenemt, using prototype shield & LCD keypad shield

5. Links & Downloads

• LCD keypad shield schematic V1.1
• Original LCD 4-bit library
• Modified LCD 4-bit libaray with examples
• New Project note - LCD Smartie on Arduino , communicate with your PC using the LCD keypad shield.

Not exactly a project note, just a few photos to show what you can do with the Arduino Protoshield Kit V1.0