SPI Communication
SPI stands for Serial Peripheral Interface. Its a type of Serial communication that uses Synchronization. Here's a nice tutorial on this from Sparkfun(its better to share good content than rewrite!) -> https://learn.sparkfun.com/tutorials/serial-peripheral-interface-spi/all
Read the above tutorial before proceeding.
The W5100 Ethernet Shield
The W5100 Ethernet Shield is based on the W5100 chip from Wiznet. There are 2 versions of this available from the Simple Labs website
- The Official Arduino Ethernet Shield R3 - This is the Rev3 Version of the Ethernet Shield
- The Low Cost W5100 Ethernet Shield - This is a cheap chinese version of the Ethernet Shield. This shield is not a Rev3 shield however will work with all boards including the Rev3 ones.
The shields come with a slot for microSD, which shares the SPI bus along with the Ethernet Controller. The Chip Select Pin for the microSD is Pin 4 and the Chip Select Pin for the Ethernet Controller is Pin 10. Both of these can be used at the same time. Lets see how to work with both of these one at a time
Working with the MicroSD
Working with the MicroSD is easier as Arduino comes with a SD Library for working with these. The SD Library provides with a number of functions required for us to work with an SD card. You can read more about the library here -> http://arduino.cc/en/Reference/SD (Read Before you Proceed!)
Load and try the following examples from the Arduino IDE -> Examples -> SD
Cardinfo.ino
Datalogger.ino
ReadWrite.ino
Now lets modify the Datalogger example to include a date / time stamp from our RTC, This way the datalogger becomes more meaningful.
Here's the Program
/* Induino R3 User Guide - Program 18.0 - A SD Datalogger with Time Stamp
SD card datalogger
This example shows how to log data from three analog sensors
to an SD card using the SD library.
The circuit:
* analog sensors on analog ins 0, 1, and 2
* SD card attached to SPI bus as follows:
** MOSI - pin 11
** MISO - pin 12
** CLK - pin 13
** CS - pin 4
created 24 Nov 2010
modified 9 Apr 2012
by Tom Igoe
This example code is in the public domain.
*/
#include <SD.h>
#include <Wire.h> // I2C Library
// On the Ethernet Shield, CS is pin 4. Note that even if it's not
// used as the CS pin, the hardware CS pin (10 on most Arduino boards,
// 53 on the Mega) must be left as an output or the SD library
// functions will not work.
const int chipSelect = 4;
#define myrtc 0x68 // I2C Address of DS1307
char *dow[]={
" ","MON","TUE","WED","THU","FRI","SAT","SUN"}; // An Array to store the DAY text to match with the DAY parameter of the RTC
char *mode[]={
"HR","AM","PM"}; // An Array to store the time mode
char *month[]={
"","JAN","FEB","MAR","APR","MAY","JUN","JUL","AUG","SEP","OCT","NOV","DEC"};
int dd,mm,yy,day,hh,mins,ss,mde; // Variables to store the retrieved time value
void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(9600);
Wire.begin(); // Initialise Wire Communication - Join the I2C Bus
delay(100);
set_time(15,11,13,5,11,10,55,2);
Serial.print("Initializing SD card...");
// make sure that the default chip select pin is set to
// output, even if you don't use it:
pinMode(10, OUTPUT);
// see if the card is present and can be initialized:
if (!SD.begin(chipSelect)) {
Serial.println("Card failed, or not present");
// don't do anything more:
return;
}
Serial.println("card initialized.");
}
void loop()
{
// make a string for assembling the data to log:
String dataString = "";
String dateString ="";
get_time();// get Date / time value into a String Variable
dateString +=dow[day];
dateString +=" ";
dateString +=String(dd);
dateString +="-";
dateString +=month[mm];
dateString +="-";
dateString +=String(yy);
dateString +=" : ";
dateString +=String(hh);
dateString +=":";
dateString +=String(mm);
dateString +=":";
dateString +=String(ss);
dateString +=" ";
dateString +=mode[mde];
dateString +=" ";
dataString += dateString; // Append the Date String to the Data String
// read three sensors and append to the string:
for (int analogPin = 0; analogPin < 3; analogPin++) {
int sensor = analogRead(analogPin);
dataString += String(sensor);
if (analogPin < 2) {
dataString += ",";
}
}
// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
File dataFile = SD.open("datalog.txt", FILE_WRITE);
// if the file is available, write to it:
if (dataFile) {
dataFile.println(dataString);
dataFile.close();
// print to the serial port too:
Serial.println(dataString);
}
// if the file isn't open, pop up an error:
else {
Serial.println("error opening datalog.txt");
}
}
// The set_time function takes parameters in the order of date, month, year, day of week, hours, minutes, seconds & mode
// the mode can have 3 possible values (0=>24HR, 1=> AM, 2 => PM)
void set_time(int sdd, int smm, int syy, int sday, int shr, int smin, int ssec, int smode)
{
Wire.beginTransmission(myrtc); // Initialise transmission to the myrtc I2C address
Wire.write(0x00); // Write the value of the register to start with, 0 in this case represented in BCD format
Wire.write(dec_to_bcd(ssec)); // convert the seconds value from decimal to bcd and write it to the seconds register
// after the write operation the register pointer will be at the next register, so we do not have to set the value of the register again
Wire.write(dec_to_bcd(smin)); // convert the minutes value from decimal to bcd and write it to the minutes register
if(smode == 0) // Check if the mode is 24hrs mode
{
Wire.write(dec_to_bcd(shr)); // if 24 hours mode is on then convert the hours value from decimal to bcd and write it to the hours register
}
else // if the mode is 12 hr mode
{
// If 12 hour mode is selected then the 12 Hour mode bit (the 6th bit) has to be set to 1
// convert the hour value to bcd first and then adding 64(2^6) to the converted hrs value will set the 6th bit HIGH
shr = dec_to_bcd(shr)+64;
if(smode == 1) // check if it is AM
Wire.write(shr); // if it is AM we can directly write the value of the above modified hours values to the hours register
if(smode == 2) // check if it is PM
Wire.write(shr+32); // If it is PM, then adding 32 (2^5) sets the 5th bit (the PM indication bit) HIGH, the calculated value is written to the hours register
}
Wire.write(dec_to_bcd(sday)); // convert the day value from decimal to bcd and write it to the day register
Wire.write(dec_to_bcd(sdd)); // convert the date value from decimal to bcd and write it to the date register
Wire.write(dec_to_bcd(smm)); // convert the month value from decimal to bcd and write it to the month register
Wire.write(dec_to_bcd(syy));// convert the year value from decimal to bcd and write it to the year register
Wire.endTransmission(); // end the transmission with the I2C device
}
// the get_time() function will retrieve the current time from the RTC and store it in the Global Variables declared
void get_time()
{
Wire.beginTransmission(myrtc); // Initialise transmission to the myrtc I2C address
Wire.write(0x00); // Write the value of the register to start with, 0 in this case represented in BCD format
Wire.endTransmission(); // end the transmission with the I2C device
Wire.requestFrom(myrtc, 7); // Now ask the I2C device for 7 Bytes of Data // This corresponds to the values of the 7 registers starting with the 0th register
ss = bcd_to_dec(Wire.read()); // The first read will retrieve the value from the register address 0x00 or the seconds register, this is in the BCD format, convert this back to decimal
mins = bcd_to_dec(Wire.read());// The second read will retrieve the value from the register address 0x01 or the minutes register, this is in the BCD format, convert this back to decimal
hh = Wire.read();// The third read will retrieve the value from the hours register, this value needs to be processed for the 24/12 hr mode
// Check of if the BCD hours value retrieved is greater than 35 (this indicates that the hours is in 12 hour mode
// 35 is the maximum BCD value possible in the 24hr mode
if(hh > 35)
{
hh = hh - 64; // in the 12 Hours Mode the 12 hour mode bit (6th bit) is set to high, so we need to subtract 2^6 from our hours value
if(hh > 32)// Now check if the hour value is greater than 32 (2^5 = 32) (this indicates that PM bit (5th bit) is high)
{
mde = 2; // Set the mde variable to indicate PM
hh = hh-32; // subtract 32 from the hours value
}
else // if the hour value is less than 32 it means that its in the AM mode
{
mde = 1; // Set the mde variable to indicate AM
}
}
else // if the 12 hour mode bit was not set, then the hour is in the 24 hour mode
{
mde = 0; // Set the mde variable to indicate 24 Hours
}
hh = bcd_to_dec(hh); // Convert the final hour value from BCD to decimal and store it back into the same variable
day = bcd_to_dec(Wire.read());// The fourth read will retrieve the value from the register address 0x03 or the day register, this is in the BCD format, convert this back to decimal
dd = bcd_to_dec(Wire.read());// The fifthread will retrieve the value from the register address 0x04 or the date register, this is in the BCD format, convert this back to decimal
mm = bcd_to_dec(Wire.read());// The sixth read will retrieve the value from the register address 0x05 or the month register, this is in the BCD format, convert this back to decimal
yy = bcd_to_dec(Wire.read());// The seventh read will retrieve the value from the register address 0x06 or the year register, this is in the BCD format, convert this back to decimal
}
// The dec_to_bcd() function converts a given decimal number to BCD format
int dec_to_bcd(int dec)
{
return dec/10*16 + (dec%10); // convert and return the number from decimal to bcd format
}
// The dec_to_bcd() function converts a given BCD number to decimal format
int bcd_to_dec(int bcd)
{
return bcd/16*10 + (bcd%16); // convert and return the number from bcd to decimal format
}
Next we will see how to work with the Ethernet Part of the shield.
Ethernet
The Ethernet Shield uses Wiznet W5100 Module for providing ethernet. The Ethernet Capability works out of the box with the Arduino Ethernet Library. To work with the ethernet shield you need to have a clear understanding of networks & HTML. The scope of this tutorial will be limited to getting the ethernet up and running and not venturing into these. Get yourselves familiar with HTML & the Ethernet Library before proceeding
So lets try an example, Make the following connections
- Place the shield on top of your Induino R3 / Arduino Board
- Connect a Ethernet Cable Between the Shield and your modem / router - you cannot connect it your computer directly, it will not work!
- Upload the example from under Examples -> Ethernet-> WebServer
- Open your Browser (Chrome might have issues, try Firefox) and type in 192.168.1.177 in the address bar
- You should now see the Values from Analog Pins being displayed in the browser.
What the example does is, it waits for a client(a browser) to connect to our ethernet shield and then it reads the GET request from the Client. At the end of the Get Request, it responsds with a HTML page which includes the Analog Pin Values
Next, Try the following modified version of the above example. We will build on top of this.
Here's the Program
/* Induino R3 User Guide - Program 18.1 - A Simple Webserver that responds with Analog Values
Modified original Webserver Example
Web Server
A simple web server that shows the value of the analog input pins.
using an Arduino Wiznet Ethernet shield.
Circuit:
* Ethernet shield attached to pins 10, 11, 12, 13
* Analog inputs attached to pins A0 through A5 (optional)
created 18 Dec 2009
by David A. Mellis
modified 9 Apr 2012
by Tom Igoe
*/
#include <SPI.h>
#include <Ethernet.h>
// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1,177);
// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);
String req; // a variable to store the GET request
void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}
// start the Ethernet connection and the server:
Ethernet.begin(mac, ip);
server.begin();
Serial.print("server is at ");
Serial.println(Ethernet.localIP());
}
void loop() {
// listen for incoming clients
EthernetClient client = server.available();
if (client) { // Check if there is a client available
Serial.println("new client");
while (client.connected()) { // check if the client is connected
if (client.available()) { // Check if there is a request from the client
Serial.print("$$$$");
req=""; // reset the request variable
while(client.available()) // Read data from the client 1 byte at a time as long as there is data
{
char c=client.read(); // Read 1 byte of data from the client
req += c; // append the read data to the existing value
delay(1);
}
Serial.println(req);
Serial.println("XXX");
}
Serial.println("Sending Data to Client");
client.println("HTTP/1.1 200 OK"); // start responding with the DATA to the client & Send out the response header
client.println("Content-Type: text/html");
client.println("Connection: close"); // the connection will be closed after completion of the responsedelay(1);
// client.println("Refresh: 5"); // refresh the page automatically every 5 sec
client.println();
client.println("<!DOCTYPE HTML>");
client.println("<html>");
// output the value of each analog input pin
for (int analogChannel = 0; analogChannel < 6; analogChannel++)
{
int sensorReading = analogRead(analogChannel);
client.print("<a href=\"/");
client.print(analogChannel);
client.print(".html\">");
client.print("analog input ");
client.print(analogChannel);
client.print(" is ");
client.print(sensorReading);
client.print("</a>");
client.println("<br />");
}
client.println("</html>");
break;
}
delay(1);
// close the connection:
client.stop();
Serial.println("client disonnected");
}
}
Now open the Serial Monitor and Open your Browser. Try the address 192.168.1.177 from your browser and see the results in the Serial monitor (like in the image below).
The contents of the GET request are printed between the $$$ and the XXX markings. The content of the GET request will vary depending upon the address you type in the browser, for example if you try
192.168.1.177/echo_me you would get a response similar to this in the serial monitor
We need to process the content in the first line between the GET and the HTTP/1.1 to identify the address requested, we can then respond accordingly. in addition, we would need to use additional string processing functions to extract string information.
Let's try a Simple Example to control a LED. We will try to On / OFF the RED of the RGB LED (we cannot use the LEDS on Pin 11, 12 & 13 as these pins are used for SPI communication with the Ethernet Shield). For this, we will generate a simple html page with a link to ON / OFF (the link keeps toggling based on the current status of the LED)
Here's the HTML code for generating a link
<a href="/?ON">Click Here to Switch ON</a>
<a href="/?OFF">Click Here to Switch OFF</a>
The contents of the GET request are printed between the $$$ and the XXX markings. The content of the GET request will vary depending upon the address you type in the browser, for example if you try
192.168.1.177/echo_me you would get a response similar to this in the serial monitor
We need to process the content in the first line between the GET and the HTTP/1.1 to identify the address requested, we can then respond accordingly. in addition, we would need to use additional string processing functions to extract string information.
Let's try a Simple Example to control a LED. We will try to On / OFF the RED of the RGB LED (we cannot use the LEDS on Pin 11, 12 & 13 as these pins are used for SPI communication with the Ethernet Shield). For this, we will generate a simple html page with a link to ON / OFF (the link keeps toggling based on the current status of the LED)
Here's the HTML code for generating a link
<a href="/?ON">Click Here to Switch ON</a>
<a href="/?OFF">Click Here to Switch OFF</a>
So when the user clicks the link, we will get /?ON or /?OFF as part of the GET request. We need to process the get request, identify this and control accordingly.
Here's the Program
/*Induino R3 User Guide - Program 18.2 - A Simple Webserver that Controls using Links
Modified original Webserver Example
A simple web server that shows the value of the analog input pins.
using an Arduino Wiznet Ethernet shield.
Circuit:
* Ethernet shield attached to pins 10, 11, 12, 13
* Analog inputs attached to pins A0 through A5 (optional)
created 18 Dec 2009
by David A. Mellis
modified 9 Apr 2012
by Tom Igoe
*/
#include <SPI.h>
#include <Ethernet.h>
// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1,177);
// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);
String req; // a variable to store the GET request
boolean state = 0; // a variable to store the state of the LED
String state_val[]={"OFF","ON"}; // A Variable to store the State of the LED as String
void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}
// start the Ethernet connection and the server:
Ethernet.begin(mac, ip);
server.begin();
Serial.print("server is at ");
Serial.println(Ethernet.localIP());
pinMode(6,OUTPUT); // RGB LED RED is on Pin 6
}
void loop() {
// listen for incoming clients
EthernetClient client = server.available();
if (client) { // Check if there is a client available
Serial.println("new client");
while (client.connected()) { // check if the client is connected
if (client.available()) { // Check if there is a request from the client
Serial.print("$$$$");
req=""; // reset the request variable
while(client.available()) // Read data from the client 1 byte at a time as long as there is data
{
char c=client.read(); // Read 1 byte of data from the client
if(c==13) // Check if the data read is a Carriage Return a.ka. Enter, This means end of first line - the line starting with GET and ending with HTTP/1.1
break; // Since we have read the first line, we need not read the remaining data for storage, so exit the while loop
req += c; // append the read data to the existing value
delayMicroseconds(1000);
}
// if the while loop above exited from the break statement, then there is data in the client buffer, which needs to be read to be removed
// we need to read this data to empty the buffer
while(client.available()) // While loop to read the data to empty buffer
{
client.read();
delayMicroseconds(1000);
}
Serial.println(req); // print the value of the request to the Serial Monitor for debugging
Serial.println("XXX");
}
if(find_string(req,"GET /?ON")) // Check if the received Request containts the String ON
{
state = 1; // Set the State Variable
digitalWrite(6,state); // Set the state to the RED LED
}
if(find_string(req,"GET /?OFF")) // Check if the received Request containts the String ON
{
state = 0; // Set the State Variable
digitalWrite(6,state);
}
Serial.println("here 1"); // for debugging
client.println("HTTP/1.1 200 OK"); // start responding with the DATA to the client & Send out the response header
client.println("Content-Type: text/html");
client.println("Connection: close"); // the connection will be closed after completion of the responsedelay(1);
client.println();
client.println("<!DOCTYPE HTML>"); // Start of the HTML Page
client.println("<html>");
client.println("<br />");
if(state) // Check the State and print the LINK on the Page accordingly
{
client.println("<a href= \"/?"+state_val[0]+" \">");
}
else
{
client.println("<a href= \"/?"+state_val[1]+" \">");
}
client.println("Click Here to Switch "+state_val[!state]+" -RED of RGB LED");
client.println("</a>");
client.println("</html>");
break;
}
client.stop();
Serial.println("client disonnected");
}
}
// A Function to locate a given search string in a given base string
boolean find_string(String base, String search)
{
int len = search.length(); // find the length of the base string
for(int m = 0; m<((base.length()-len)+1);m++)// Iterate from the beginning of the base string till the end minus length of the substring
{
if(base.substring(m,(m+len))==search) // Check if the extracted Substring Matches the Search String
{
return true; // if it matches exit the function with a true value
}
}
return false; // if the above loop did not find any matches, control would come here and return a false value
}
Now open your browser, try the address 192.168.1.177, you should see the text with the link and clicking the text should toggle the state of the LED
Now lets see how to handle numeric values received through a get request, For the HTML Page We'll design 3 sliders that will let the user set values from 0-255. The slider will be set inside a form and when the user clicks the button to submit the form, it will be sent to a preset page along with the slider data as part of the get request, By processing the GET request for this page, we can read the data of the sliders that was submitted and use the values to control the RGB LED.
Now lets see how to handle numeric values received through a get request, For the HTML Page We'll design 3 sliders that will let the user set values from 0-255. The slider will be set inside a form and when the user clicks the button to submit the form, it will be sent to a preset page along with the slider data as part of the get request, By processing the GET request for this page, we can read the data of the sliders that was submitted and use the values to control the RGB LED.
Here's the Program
/*Induino R3 User Guide - Program 18.2 - A Simple Webserver that Let you set the Intensity of the RGB LED on the Induino R3 Board using a Slider
Modified original Webserver Example
Web Server
A simple web server that shows the value of the analog input pins.
using an Arduino Wiznet Ethernet shield.
Circuit:
* Ethernet shield attached to pins 10, 11, 12, 13
* Analog inputs attached to pins A0 through A5 (optional)
created 18 Dec 2009
by David A. Mellis
modified 9 Apr 2012
by Tom Igoe
*/
#include <SPI.h>
#include <Ethernet.h>
// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1,177);
// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);
String req; // a variable to store the GET request
int RGB[]={0,0,0}; // a variable to store the Intensity Value, RGB[0] => RED, RGB[1] => Green, RGB[2]=>Blue
String tmp_rgb =""; // a temporary variable
void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}
// start the Ethernet connection and the server:
Ethernet.begin(mac, ip);
server.begin();
Serial.print("server is at ");
Serial.println(Ethernet.localIP());
}
void loop() {
// listen for incoming clients
EthernetClient client = server.available();
if (client) { // Check if there is a client available
Serial.println("new client");
while (client.connected()) { // check if the client is connected
if (client.available()) { // Check if there is a request from the client
Serial.print("$$$$");
req=""; // reset the request variable
while(client.available()) // Read data from the client 1 byte at a time as long as there is data
{
char c=client.read(); // Read 1 byte of data from the client
if(c==13) // Check if the data read is a Carriage Return a.ka. Enter, This means end of first line - the line starting with GET and ending with HTTP/1.1
break; // Since we have read the first line, we need not read the remaining data for storage, so exit the while loop
req += c; // append the read data to the existing value
delayMicroseconds(1000);
}
// if the while loop above exited from the break statement, then there is data in the client buffer, which needs to be read to be removed
// we need to read this data to empty the buffer
while(client.available()) // While loop to read the data to empty buffer
{
client.read();
delayMicroseconds(1000);
}
Serial.println(req); // print the value of the request to the Serial Monitor for debugging
Serial.println("XXX");
}
// Check if the GET request contains the text setrgb?
// If it contains the text, then we need to extract the values for RED, GREEN & Blue
if(find_string(req,"GET /setrgb?"))
{
int start_loc= find_string_loc(req,"RED=")+4; // Find the starting location of the Value for RED
int end_loc = find_string_loc(req, "&GREEN"); // Find the ending location of the Value for RED
RGB[0] = string_to_int(req.substring(start_loc,end_loc)); // Extract the Value and Store it
start_loc= find_string_loc(req,"GREEN=")+6; // Find the starting location of the Value for GREEN
end_loc = find_string_loc(req, "&BLUE"); // Find the ending location of the Value for GREEN
RGB[1] = string_to_int(req.substring(start_loc,end_loc)); // Extract the Value and Store it
start_loc= find_string_loc(req,"BLUE=")+5; // Find the starting location of the Value for BLUE
end_loc = find_string_loc(req, "HTTP/1.1")-1;// Find the ending location of the Value for BLUE
RGB[2] = string_to_int(req.substring(start_loc,end_loc));// Extract the Value and Store it
analogWrite(3,RGB[1]);analogWrite(5,RGB[2]);analogWrite(6,RGB[0]); // Set the RGB Intensities from the Variable
}
Serial.println("here 1"); // for debugging
client.println("HTTP/1.1 200 OK"); // start responding with the DATA to the client & Send out the response header
client.println("Content-Type: text/html");
client.println("Connection: close"); // the connection will be closed after completion of the responsedelay(1);
client.println();
client.println("<!DOCTYPE HTML>"); // Start of the HTML Page
client.println("<html>");
client.println("<br />");
// Code for Printing Slider
client.println("<form action=\"/setrgb\" method=\"get\">");
tmp_rgb = (String) RGB[0];
// The Sliders are set to have the current RGB[] values as the default values
client.println("RED Value: <input type=\"range\" name=\"RED\" min=\"0\" max=\"255\" value=\""+tmp_rgb+"\">");
tmp_rgb = (String) RGB[1];
client.println("<br/>GREEN Value: <input type=\"range\" name=\"GREEN\" min=\"0\" max=\"255\" value=\""+tmp_rgb+"\">");
tmp_rgb = (String) RGB[2];
client.println("<br/>BLUE Value: <input type=\"range\" name=\"BLUE\" min=\"0\" max=\"255\" value=\""+tmp_rgb+"\">");
client.println("<br/><br/><input type=\"submit\" value=\"SET\" />");
client.println("</form>");
client.println("</html>");
break;
}
//delay(1);
// close the connection:
client.stop();
Serial.println("client disonnected");
}
}
// A Function to locate a given search string in a given base string
boolean find_string(String base, String search)
{
int len = search.length(); // find the length of the base string
for(int m = 0; m<((base.length()-len)+1);m++)// Iterate from the beginning of the base string till the end minus length of the substring
{
if(base.substring(m,(m+len))==search) // Check if the extracted Substring Matches the Search String
{
return true; // if it matches exit the function with a true value
}
}
return false; // if the above loop did not find any matches, control would come here and return a false value
}
// This function is similar to the String Search function except it returns the starting location of the Search String in the Base String
int find_string_loc(String base, String search)
{
int len = search.length(); // find the length of the base string
int m, val=0; // val is used to store the return value and m is a counter
for(m = 0; m<((base.length()-len)+1);m++)// Iterate from the beginning of the base string till the end minus length of the substring
{
if(base.substring(m,(m+len))==search) // Check if the extracted Substring Matches the Search String
{
val= m; // if it matches set the return value to the current value of m
}
if(val!=0) // if the return value is non-zero, exit the for loop
break;
}
return val; // return the retun value
}
//A Function to convert a given String with numerical content to its integer equivalent
int string_to_int(String base)
{
int len = base.length(); // get the length of the string
int ret_val=0;
for(int m=0;m<len;m++) // iterate through each character in the string
{
ret_val = (ret_val*10)+ (base[m]-48); // subtract 48 from the ascii value to get the numeric value and add it to the existing value
// if the string was 225, then when m=0, ret_val would be 2, when m=1, ret_val would be 20+2, when m=2, ret_val would be 220+5,
}
return ret_val;
}
Now open your browser, try the address 192.168.1.177, you should see 3 Sliders that let you control the RGB Led on the Induino R3.
Thats It For This Part! Enjoy... and feel free to drop us an email with questions you might have -> info@simplelabs.co.in
Thats It For This Part! Enjoy... and feel free to drop us an email with questions you might have -> info@simplelabs.co.in
Visit www.simplelabs.co.in for more interesting products
