diff options
| author | Jesse Morgan <jesse@jesterpm.net> | 2011-10-20 22:16:19 -0700 |
|---|---|---|
| committer | Jesse Morgan <jesse@jesterpm.net> | 2011-10-20 22:16:19 -0700 |
| commit | fc944ff979dbbd49a57722fe2d1d2acf47312eb4 (patch) | |
| tree | 38cc3a5c5c8f24f55068fc4ffa73d018169fc2df /libraries/Ethernet/examples | |
Inital commit... halfway through the project
Diffstat (limited to 'libraries/Ethernet/examples')
9 files changed, 1021 insertions, 0 deletions
diff --git a/libraries/Ethernet/examples/BarometricPressureWebServer/BarometricPressureWebServer.pde b/libraries/Ethernet/examples/BarometricPressureWebServer/BarometricPressureWebServer.pde new file mode 100644 index 0000000..5414c8e --- /dev/null +++ b/libraries/Ethernet/examples/BarometricPressureWebServer/BarometricPressureWebServer.pde @@ -0,0 +1,225 @@ +/*
+ SCP1000 Barometric Pressure Sensor Display
+
+ Serves the output of a Barometric Pressure Sensor as a web page.
+ Uses the SPI library. For details on the sensor, see:
+ http://www.sparkfun.com/commerce/product_info.php?products_id=8161
+ http://www.vti.fi/en/support/obsolete_products/pressure_sensors/
+
+ This sketch adapted from Nathan Seidle's SCP1000 example for PIC:
+ http://www.sparkfun.com/datasheets/Sensors/SCP1000-Testing.zip
+
+ Circuit:
+ SCP1000 sensor attached to pins 6,7, and 11 - 13:
+ DRDY: pin 6
+ CSB: pin 7
+ MOSI: pin 11
+ MISO: pin 12
+ SCK: pin 13
+
+ created 31 July 2010
+ by Tom Igoe
+ */
+
+#include <Ethernet.h>
+// the sensor communicates using SPI, so include the library:
+#include <SPI.h>
+
+
+// assign a MAC address for the ethernet controller.
+// fill in your address here:
+byte mac[] = {
+ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+// assign an IP address for the controller:
+byte ip[] = {
+ 192,168,1,20 };
+byte gateway[] = {
+ 192,168,1,1};
+byte subnet[] = {
+ 255, 255, 255, 0 };
+
+
+// Initialize the Ethernet server library
+// with the IP address and port you want to use
+// (port 80 is default for HTTP):
+Server server(80);
+
+
+//Sensor's memory register addresses:
+const int PRESSURE = 0x1F; //3 most significant bits of pressure
+const int PRESSURE_LSB = 0x20; //16 least significant bits of pressure
+const int TEMPERATURE = 0x21; //16 bit temperature reading
+
+// pins used for the connection with the sensor
+// the others you need are controlled by the SPI library):
+const int dataReadyPin = 6;
+const int chipSelectPin = 7;
+
+float temperature = 0.0;
+long pressure = 0;
+long lastReadingTime = 0;
+
+void setup() {
+ // start the SPI library:
+ SPI.begin();
+
+ // start the Ethernet connection and the server:
+ Ethernet.begin(mac, ip);
+ server.begin();
+
+ // initalize the data ready and chip select pins:
+ pinMode(dataReadyPin, INPUT);
+ pinMode(chipSelectPin, OUTPUT);
+
+ Serial.begin(9600);
+
+ //Configure SCP1000 for low noise configuration:
+ writeRegister(0x02, 0x2D);
+ writeRegister(0x01, 0x03);
+ writeRegister(0x03, 0x02);
+
+ // give the sensor and Ethernet shield time to set up:
+ delay(1000);
+
+ //Set the sensor to high resolution mode tp start readings:
+ writeRegister(0x03, 0x0A);
+
+}
+
+void loop() {
+ // check for a reading no more than once a second.
+ if (millis() - lastReadingTime > 1000){
+ // if there's a reading ready, read it:
+ // don't do anything until the data ready pin is high:
+ if (digitalRead(dataReadyPin) == HIGH) {
+ getData();
+ // timestamp the last time you got a reading:
+ lastReadingTime = millis();
+ }
+ }
+
+ // listen for incoming Ethernet connections:
+ listenForClients();
+}
+
+
+void getData() {
+ Serial.println("Getting reading");
+ //Read the temperature data
+ int tempData = readRegister(0x21, 2);
+
+ // convert the temperature to celsius and display it:
+ temperature = (float)tempData / 20.0;
+
+ //Read the pressure data highest 3 bits:
+ byte pressureDataHigh = readRegister(0x1F, 1);
+ pressureDataHigh &= 0b00000111; //you only needs bits 2 to 0
+
+ //Read the pressure data lower 16 bits:
+ unsigned int pressureDataLow = readRegister(0x20, 2);
+ //combine the two parts into one 19-bit number:
+ pressure = ((pressureDataHigh << 16) | pressureDataLow)/4;
+
+ Serial.print("Temperature: ");
+ Serial.print(temperature);
+ Serial.println(" degrees C");
+ Serial.print("Pressure: " + String(pressure));
+ Serial.println(" Pa");
+}
+
+void listenForClients() {
+ // listen for incoming clients
+ Client client = server.available();
+ if (client) {
+ Serial.println("Got a client");
+ // an http request ends with a blank line
+ boolean currentLineIsBlank = true;
+ while (client.connected()) {
+ if (client.available()) {
+ char c = client.read();
+ // if you've gotten to the end of the line (received a newline
+ // character) and the line is blank, the http request has ended,
+ // so you can send a reply
+ if (c == '\n' && currentLineIsBlank) {
+ // send a standard http response header
+ client.println("HTTP/1.1 200 OK");
+ client.println("Content-Type: text/html");
+ client.println();
+ // print the current readings, in HTML format:
+ client.print("Temperature: ");
+ client.print(temperature);
+ client.print(" degrees C");
+ client.println("<br />");
+ client.print("Pressure: " + String(pressure));
+ client.print(" Pa");
+ client.println("<br />");
+ break;
+ }
+ if (c == '\n') {
+ // you're starting a new line
+ currentLineIsBlank = true;
+ }
+ else if (c != '\r') {
+ // you've gotten a character on the current line
+ currentLineIsBlank = false;
+ }
+ }
+ }
+ // give the web browser time to receive the data
+ delay(1);
+ // close the connection:
+ client.stop();
+ }
+}
+
+
+//Send a write command to SCP1000
+void writeRegister(byte registerName, byte registerValue) {
+ // SCP1000 expects the register name in the upper 6 bits
+ // of the byte:
+ registerName <<= 2;
+ // command (read or write) goes in the lower two bits:
+ registerName |= 0b00000010; //Write command
+
+ // take the chip select low to select the device:
+ digitalWrite(chipSelectPin, LOW);
+
+ SPI.transfer(registerName); //Send register location
+ SPI.transfer(registerValue); //Send value to record into register
+
+ // take the chip select high to de-select:
+ digitalWrite(chipSelectPin, HIGH);
+}
+
+
+//Read register from the SCP1000:
+unsigned int readRegister(byte registerName, int numBytes) {
+ byte inByte = 0; // incoming from the SPI read
+ unsigned int result = 0; // result to return
+
+ // SCP1000 expects the register name in the upper 6 bits
+ // of the byte:
+ registerName <<= 2;
+ // command (read or write) goes in the lower two bits:
+ registerName &= 0b11111100; //Read command
+
+ // take the chip select low to select the device:
+ digitalWrite(chipSelectPin, LOW);
+ // send the device the register you want to read:
+ int command = SPI.transfer(registerName);
+ // send a value of 0 to read the first byte returned:
+ inByte = SPI.transfer(0x00);
+
+ result = inByte;
+ // if there's more than one byte returned,
+ // shift the first byte then get the second byte:
+ if (numBytes > 1){
+ result = inByte << 8;
+ inByte = SPI.transfer(0x00);
+ result = result |inByte;
+ }
+ // take the chip select high to de-select:
+ digitalWrite(chipSelectPin, HIGH);
+ // return the result:
+ return(result);
+}
diff --git a/libraries/Ethernet/examples/ChatServer/ChatServer.pde b/libraries/Ethernet/examples/ChatServer/ChatServer.pde new file mode 100644 index 0000000..7631e73 --- /dev/null +++ b/libraries/Ethernet/examples/ChatServer/ChatServer.pde @@ -0,0 +1,63 @@ +/*
+ Chat Server
+
+ A simple server that distributes any incoming messages to all
+ connected clients. To use telnet to your device's IP address and type.
+ You can see the client's input in the serial monitor as well.
+ 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 10 August 2010
+ 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.
+// gateway and subnet are optional:
+byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
+byte ip[] = { 192,168,1, 177 };
+byte gateway[] = { 192,168,1, 1 };
+byte subnet[] = { 255, 255, 0, 0 };
+
+// telnet defaults to port 23
+Server server(23);
+boolean gotAMessage = false; // whether or not you got a message from the client yet
+
+void setup() {
+ // initialize the ethernet device
+ Ethernet.begin(mac, ip, gateway, subnet);
+ // start listening for clients
+ server.begin();
+ // open the serial port
+ Serial.begin(9600);
+}
+
+void loop() {
+ // wait for a new client:
+ Client client = server.available();
+
+ // when the client sends the first byte, say hello:
+ if (client) {
+ if (!gotAMessage) {
+ Serial.println("We have a new client");
+ client.println("Hello, client!");
+ gotAMessage = true;
+ }
+
+ // read the bytes incoming from the client:
+ char thisChar = client.read();
+ // echo the bytes back to the client:
+ server.write(thisChar);
+ // echo the bytes to the server as well:
+ Serial.print(thisChar);
+ }
+}
\ No newline at end of file diff --git a/libraries/Ethernet/examples/PachubeClient/PachubeClient.pde b/libraries/Ethernet/examples/PachubeClient/PachubeClient.pde new file mode 100644 index 0000000..10c08a2 --- /dev/null +++ b/libraries/Ethernet/examples/PachubeClient/PachubeClient.pde @@ -0,0 +1,139 @@ +/*
+ Pachube sensor client
+
+ This sketch connects an analog sensor to Pachube (http://www.pachube.com)
+ using a Wiznet Ethernet shield. You can use the Arduino Ethernet shield, or
+ the Adafruit Ethernet shield, either one will work, as long as it's got
+ a Wiznet Ethernet module on board.
+
+ Circuit:
+ * Analog sensor attached to analog in 0
+ * Ethernet shield attached to pins 10, 11, 12, 13
+
+ created 15 March 2010
+ updated 4 Sep 2010
+ by Tom Igoe
+
+ http://www.tigoe.net/pcomp/code/category/arduinowiring/873
+ This code is in the public domain.
+
+ */
+
+#include <SPI.h>
+#include <Ethernet.h>
+
+// assign a MAC address for the ethernet controller.
+// fill in your address here:
+byte mac[] = {
+ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+// assign an IP address for the controller:
+byte ip[] = {
+ 192,169,1,20 };
+byte gateway[] = {
+ 192,168,1,1};
+byte subnet[] = {
+ 255, 255, 255, 0 };
+
+// The address of the server you want to connect to (pachube.com):
+byte server[] = {
+ 209,40,205,190 };
+
+// initialize the library instance:
+Client client(server, 80);
+
+long lastConnectionTime = 0; // last time you connected to the server, in milliseconds
+boolean lastConnected = false; // state of the connection last time through the main loop
+const int postingInterval = 10000; //delay between updates to Pachube.com
+
+void setup() {
+ // start the ethernet connection and serial port:
+ Ethernet.begin(mac, ip);
+ Serial.begin(9600);
+ // give the ethernet module time to boot up:
+ delay(1000);
+}
+
+void loop() {
+ // read the analog sensor:
+ int sensorReading = analogRead(A0);
+
+ // if there's incoming data from the net connection.
+ // send it out the serial port. This is for debugging
+ // purposes only:
+ if (client.available()) {
+ char c = client.read();
+ Serial.print(c);
+ }
+
+ // if there's no net connection, but there was one last time
+ // through the loop, then stop the client:
+ if (!client.connected() && lastConnected) {
+ Serial.println();
+ Serial.println("disconnecting.");
+ client.stop();
+ }
+
+ // if you're not connected, and ten seconds have passed since
+ // your last connection, then connect again and send data:
+ if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
+ sendData(sensorReading);
+ }
+ // store the state of the connection for next time through
+ // the loop:
+ lastConnected = client.connected();
+}
+
+// this method makes a HTTP connection to the server:
+void sendData(int thisData) {
+ // if there's a successful connection:
+ if (client.connect()) {
+ Serial.println("connecting...");
+ // send the HTTP PUT request.
+ // fill in your feed address here:
+ client.print("PUT /api/YOUR_FEED_HERE.csv HTTP/1.1\n");
+ client.print("Host: www.pachube.com\n");
+ // fill in your Pachube API key here:
+ client.print("X-PachubeApiKey: YOUR_KEY_HERE\n");
+ client.print("Content-Length: ");
+
+ // calculate the length of the sensor reading in bytes:
+ int thisLength = getLength(thisData);
+ client.println(thisLength, DEC);
+
+ // last pieces of the HTTP PUT request:
+ client.print("Content-Type: text/csv\n");
+ client.println("Connection: close\n");
+
+ // here's the actual content of the PUT request:
+ client.println(thisData, DEC);
+
+ // note the time that the connection was made:
+ lastConnectionTime = millis();
+ }
+ else {
+ // if you couldn't make a connection:
+ Serial.println("connection failed");
+ }
+}
+
+
+// This method calculates the number of digits in the
+// sensor reading. Since each digit of the ASCII decimal
+// representation is a byte, the number of digits equals
+// the number of bytes:
+
+int getLength(int someValue) {
+ // there's at least one byte:
+ int digits = 1;
+ // continually divide the value by ten,
+ // adding one to the digit count for each
+ // time you divide, until you're at 0:
+ int dividend = someValue /10;
+ while (dividend > 0) {
+ dividend = dividend /10;
+ digits++;
+ }
+ // return the number of digits:
+ return digits;
+}
+
diff --git a/libraries/Ethernet/examples/PachubeClientString/PachubeClientString.pde b/libraries/Ethernet/examples/PachubeClientString/PachubeClientString.pde new file mode 100644 index 0000000..c6608b4 --- /dev/null +++ b/libraries/Ethernet/examples/PachubeClientString/PachubeClientString.pde @@ -0,0 +1,124 @@ +/*
+ Pachube sensor client with Strings
+
+ This sketch connects an analog sensor to Pachube (http://www.pachube.com)
+ using a Wiznet Ethernet shield. You can use the Arduino Ethernet shield, or
+ the Adafruit Ethernet shield, either one will work, as long as it's got
+ a Wiznet Ethernet module on board.
+
+ This example uses the String library, which is part of the Arduino core from
+ version 0019.
+
+ Circuit:
+ * Analog sensor attached to analog in 0
+ * Ethernet shield attached to pins 10, 11, 12, 13
+
+ created 15 March 2010
+ updated 4 Sep 2010
+ by Tom Igoe
+
+ This code is in the public domain.
+
+ */
+
+#include <SPI.h>
+#include <Ethernet.h>
+
+// assign a MAC address for the ethernet controller.
+// fill in your address here:
+byte mac[] = {
+ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+// assign an IP address for the controller:
+byte ip[] = {
+ 192,169,1,20 };
+byte gateway[] = {
+ 192,168,1,1};
+byte subnet[] = {
+ 255, 255, 255, 0 };
+
+// The address of the server you want to connect to (pachube.com):
+byte server[] = {
+ 209,40,205,190 };
+
+// initialize the library instance:
+Client client(server, 80);
+
+long lastConnectionTime = 0; // last time you connected to the server, in milliseconds
+boolean lastConnected = false; // state of the connection last time through the main loop
+const int postingInterval = 10000; //delay between updates to Pachube.com
+
+void setup() {
+ // start the ethernet connection and serial port:
+ Ethernet.begin(mac, ip);
+ Serial.begin(9600);
+ // give the ethernet module time to boot up:
+ delay(1000);
+}
+
+void loop() {
+ // read the analog sensor:
+ int sensorReading = analogRead(A0);
+ // convert the data to a String to send it:
+ String dataString = String(sensorReading);
+
+ // you can append multiple readings to this String if your
+ // pachube feed is set up to handle multiple values:
+ int otherSensorReading = analogRead(A1);
+ dataString += ",";
+ dataString += String(otherSensorReading);
+
+ // if there's incoming data from the net connection.
+ // send it out the serial port. This is for debugging
+ // purposes only:
+ if (client.available()) {
+ char c = client.read();
+ Serial.print(c);
+ }
+
+ // if there's no net connection, but there was one last time
+ // through the loop, then stop the client:
+ if (!client.connected() && lastConnected) {
+ Serial.println();
+ Serial.println("disconnecting.");
+ client.stop();
+ }
+
+ // if you're not connected, and ten seconds have passed since
+ // your last connection, then connect again and send data:
+ if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
+ sendData(dataString);
+ }
+ // store the state of the connection for next time through
+ // the loop:
+ lastConnected = client.connected();
+}
+
+// this method makes a HTTP connection to the server:
+void sendData(String thisData) {
+ // if there's a successful connection:
+ if (client.connect()) {
+ Serial.println("connecting...");
+ // send the HTTP PUT request.
+ // fill in your feed address here:
+ client.print("PUT /api/YOUR_FEED_HERE.csv HTTP/1.1\n");
+ client.print("Host: www.pachube.com\n");
+ // fill in your Pachube API key here:
+ client.print("X-PachubeApiKey: YOUR_KEY_HERE\n");
+ client.print("Content-Length: ");
+ client.println(thisData.length(), DEC);
+
+ // last pieces of the HTTP PUT request:
+ client.print("Content-Type: text/csv\n");
+ client.println("Connection: close\n");
+
+ // here's the actual content of the PUT request:
+ client.println(thisData);
+
+ // note the time that the connection was made:
+ lastConnectionTime = millis();
+ }
+ else {
+ // if you couldn't make a connection:
+ Serial.println("connection failed");
+ }
+}
diff --git a/libraries/Ethernet/examples/TelnetClient/TelnetClient.pde b/libraries/Ethernet/examples/TelnetClient/TelnetClient.pde new file mode 100644 index 0000000..76a264e --- /dev/null +++ b/libraries/Ethernet/examples/TelnetClient/TelnetClient.pde @@ -0,0 +1,89 @@ +/*
+ Telnet client
+
+ This sketch connects to a a telnet server (http://www.google.com)
+ using an Arduino Wiznet Ethernet shield. You'll need a telnet server
+ to test this with.
+ Processing's ChatServer example (part of the network library) works well,
+ running on port 10002. It can be found as part of the examples
+ in the Processing application, available at
+ http://processing.org/
+
+ Circuit:
+ * Ethernet shield attached to pins 10, 11, 12, 13
+
+ created 14 Sep 2010
+ 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 };
+byte ip[] = {
+ 192,168,1,177 };
+
+// Enter the IP address of the server you're connecting to:
+byte server[] = {
+ 1,1,1,1 };
+
+// Initialize the Ethernet client library
+// with the IP address and port of the server
+// that you want to connect to (port 23 is default for telnet;
+// if you're using Processing's ChatServer, use port 10002):
+Client client(server, 10002);
+
+void setup() {
+ // start the Ethernet connection:
+ Ethernet.begin(mac, ip);
+ // start the serial library:
+ Serial.begin(9600);
+ // give the Ethernet shield a second to initialize:
+ delay(1000);
+ Serial.println("connecting...");
+
+ // if you get a connection, report back via serial:
+ if (client.connect()) {
+ Serial.println("connected");
+ }
+ else {
+ // if you didn't get a connection to the server:
+ Serial.println("connection failed");
+ }
+}
+
+void loop()
+{
+ // if there are incoming bytes available
+ // from the server, read them and print them:
+ if (client.available()) {
+ char c = client.read();
+ Serial.print(c);
+ }
+
+ // as long as there are bytes in the serial queue,
+ // read them and send them out the socket if it's open:
+ while (Serial.available() > 0) {
+ char inChar = Serial.read();
+ if (client.connected()) {
+ client.print(inChar);
+ }
+ }
+
+ // if the server's disconnected, stop the client:
+ if (!client.connected()) {
+ Serial.println();
+ Serial.println("disconnecting.");
+ client.stop();
+ // do nothing:
+ while(true);
+ }
+}
+
+
+
+
diff --git a/libraries/Ethernet/examples/UDPSendReceiveString/UDPSendReceiveString.pde b/libraries/Ethernet/examples/UDPSendReceiveString/UDPSendReceiveString.pde new file mode 100644 index 0000000..edf3b9c --- /dev/null +++ b/libraries/Ethernet/examples/UDPSendReceiveString/UDPSendReceiveString.pde @@ -0,0 +1,107 @@ +/*
+ UDPSendReceive.pde:
+ This sketch receives UDP message strings, prints them to the serial port
+ and sends an "acknowledge" string back to the sender
+
+ A Processing sketch is included at the end of file that can be used to send
+ and received messages for testing with a computer.
+
+ created 21 Aug 2010
+ by Michael Margolis
+
+ This code is in the public domain.
+ */
+
+
+#include <SPI.h> // needed for Arduino versions later than 0018
+#include <Ethernet.h>
+#include <Udp.h> // UDP library from: bjoern@cs.stanford.edu 12/30/2008
+
+
+// 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 };
+byte ip[] = {
+ 192,168,1,177 };
+
+unsigned int localPort = 8888; // local port to listen on
+
+// the next two variables are set when a packet is received
+byte remoteIp[4]; // holds received packet's originating IP
+unsigned int remotePort; // holds received packet's originating port
+
+// buffers for receiving and sending data
+char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,
+char ReplyBuffer[] = "acknowledged"; // a string to send back
+
+
+void setup() {
+ // start the Ethernet and UDP:
+ Ethernet.begin(mac,ip);
+ Udp.begin(localPort);
+
+ Serial.begin(9600);
+}
+
+void loop() {
+ // if there's data available, read a packet
+ int packetSize = Udp.available(); // note that this includes the UDP header
+ if(packetSize)
+ {
+ packetSize = packetSize - 8; // subtract the 8 byte header
+ Serial.print("Received packet of size ");
+ Serial.println(packetSize);
+
+ // read the packet into packetBufffer and get the senders IP addr and port number
+ Udp.readPacket(packetBuffer,UDP_TX_PACKET_MAX_SIZE, remoteIp, remotePort);
+ Serial.println("Contents:");
+ Serial.println(packetBuffer);
+
+ Udp.sendPacket( ReplyBuffer, remoteIp, remotePort);
+ }
+ delay(10);
+}
+
+
+/*
+ Processing sketch to run with this example
+ =====================================================
+
+ // Processing UDP example to send and receive string data from Arduino
+ // press any key to send the "Hello Arduino" message
+
+
+ import hypermedia.net.*;
+
+ UDP udp; // define the UDP object
+
+
+ void setup() {
+ udp = new UDP( this, 6000 ); // create a new datagram connection on port 6000
+ //udp.log( true ); // <-- printout the connection activity
+ udp.listen( true ); // and wait for incoming message
+ }
+
+ void draw()
+ {
+ }
+
+ void keyPressed() {
+ String ip = "192.168.1.177"; // the remote IP address
+ int port = 8888; // the destination port
+
+ udp.send("Hello World", ip, port ); // the message to send
+
+ }
+
+ void receive( byte[] data ) { // <-- default handler
+ //void receive( byte[] data, String ip, int port ) { // <-- extended handler
+
+ for(int i=0; i < data.length; i++)
+ print(char(data[i]));
+ println();
+ }
+ */
+
+
diff --git a/libraries/Ethernet/examples/UdpNtpClient/UdpNtpClient.pde b/libraries/Ethernet/examples/UdpNtpClient/UdpNtpClient.pde new file mode 100644 index 0000000..1010ec9 --- /dev/null +++ b/libraries/Ethernet/examples/UdpNtpClient/UdpNtpClient.pde @@ -0,0 +1,121 @@ +/*
+
+ Udp NTP Client
+
+ Get the time from a Network Time Protocol (NTP) time server
+ Demonstrates use of UDP sendPacket and ReceivePacket
+ For more on NTP time servers and the messages needed to communicate with them,
+ see http://en.wikipedia.org/wiki/Network_Time_Protocol
+
+ created 4 Sep 2010
+ by Michael Margolis
+ modified 17 Sep 2010
+ by Tom Igoe
+
+ This code is in the public domain.
+
+ */
+
+#include <SPI.h>
+#include <Ethernet.h>
+#include <Udp.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 };
+byte ip[] = {
+ 192,168,1,177 };
+
+
+unsigned int localPort = 8888; // local port to listen for UDP packets
+
+byte timeServer[] = {
+ 192, 43, 244, 18}; // time.nist.gov NTP server
+
+const int NTP_PACKET_SIZE= 48; // NTP time stamp is in the first 48 bytes of the message
+
+byte packetBuffer[ NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets
+
+void setup()
+{
+ // start Ethernet and UDP
+ Ethernet.begin(mac,ip);
+ Udp.begin(localPort);
+
+ Serial.begin(9600);
+}
+
+void loop()
+{
+ sendNTPpacket(timeServer); // send an NTP packet to a time server
+
+ // wait to see if a reply is available
+ delay(1000);
+ if ( Udp.available() ) {
+ Udp.readPacket(packetBuffer,NTP_PACKET_SIZE); // read the packet into the buffer
+
+ //the timestamp starts at byte 40 of the received packet and is four bytes,
+ // or two words, long. First, esxtract the two words:
+
+ unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
+ unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
+ // combine the four bytes (two words) into a long integer
+ // this is NTP time (seconds since Jan 1 1900):
+ unsigned long secsSince1900 = highWord << 16 | lowWord;
+ Serial.print("Seconds since Jan 1 1900 = " );
+ Serial.println(secsSince1900);
+
+ // now convert NTP time into everyday time:
+ Serial.print("Unix time = ");
+ // Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
+ const unsigned long seventyYears = 2208988800UL;
+ // subtract seventy years:
+ unsigned long epoch = secsSince1900 - seventyYears;
+ // print Unix time:
+ Serial.println(epoch);
+
+
+ // print the hour, minute and second:
+ Serial.print("The UTC time is "); // UTC is the time at Greenwich Meridian (GMT)
+ Serial.print((epoch % 86400L) / 3600); // print the hour (86400 equals secs per day)
+ Serial.print(':');
+ Serial.print((epoch % 3600) / 60); // print the minute (3600 equals secs per minute)
+ Serial.print(':');
+ Serial.println(epoch %60); // print the second
+ }
+ // wait ten seconds before asking for the time again
+ delay(10000);
+}
+
+// send an NTP request to the time server at the given address
+unsigned long sendNTPpacket(byte *address)
+{
+ // set all bytes in the buffer to 0
+ memset(packetBuffer, 0, NTP_PACKET_SIZE);
+ // Initialize values needed to form NTP request
+ // (see URL above for details on the packets)
+ packetBuffer[0] = 0b11100011; // LI, Version, Mode
+ packetBuffer[1] = 0; // Stratum, or type of clock
+ packetBuffer[2] = 6; // Polling Interval
+ packetBuffer[3] = 0xEC; // Peer Clock Precision
+ // 8 bytes of zero for Root Delay & Root Dispersion
+ packetBuffer[12] = 49;
+ packetBuffer[13] = 0x4E;
+ packetBuffer[14] = 49;
+ packetBuffer[15] = 52;
+
+ // all NTP fields have been given values, now
+ // you can send a packet requesting a timestamp:
+ Udp.sendPacket( packetBuffer,NTP_PACKET_SIZE, address, 123); //NTP requests are to port 123
+}
+
+
+
+
+
+
+
+
+
+
diff --git a/libraries/Ethernet/examples/WebClient/WebClient.pde b/libraries/Ethernet/examples/WebClient/WebClient.pde new file mode 100644 index 0000000..355d746 --- /dev/null +++ b/libraries/Ethernet/examples/WebClient/WebClient.pde @@ -0,0 +1,71 @@ +/*
+ Web client
+
+ This sketch connects to a website (http://www.google.com)
+ using an Arduino Wiznet Ethernet shield.
+
+ Circuit:
+ * Ethernet shield attached to pins 10, 11, 12, 13
+
+ created 18 Dec 2009
+ by David A. Mellis
+
+ */
+
+#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 };
+byte ip[] = { 192,168,1,177 };
+byte server[] = { 173,194,33,104 }; // Google
+
+// Initialize the Ethernet client library
+// with the IP address and port of the server
+// that you want to connect to (port 80 is default for HTTP):
+Client client(server, 80);
+
+void setup() {
+ // start the Ethernet connection:
+ Ethernet.begin(mac, ip);
+ // start the serial library:
+ Serial.begin(9600);
+ // give the Ethernet shield a second to initialize:
+ delay(1000);
+ Serial.println("connecting...");
+
+ // if you get a connection, report back via serial:
+ if (client.connect()) {
+ Serial.println("connected");
+ // Make a HTTP request:
+ client.println("GET /search?q=arduino HTTP/1.0");
+ client.println();
+ }
+ else {
+ // kf you didn't get a connection to the server:
+ Serial.println("connection failed");
+ }
+}
+
+void loop()
+{
+ // if there are incoming bytes available
+ // from the server, read them and print them:
+ if (client.available()) {
+ char c = client.read();
+ Serial.print(c);
+ }
+
+ // if the server's disconnected, stop the client:
+ if (!client.connected()) {
+ Serial.println();
+ Serial.println("disconnecting.");
+ client.stop();
+
+ // do nothing forevermore:
+ for(;;)
+ ;
+ }
+}
+
diff --git a/libraries/Ethernet/examples/WebServer/WebServer.pde b/libraries/Ethernet/examples/WebServer/WebServer.pde new file mode 100644 index 0000000..27eaf14 --- /dev/null +++ b/libraries/Ethernet/examples/WebServer/WebServer.pde @@ -0,0 +1,82 @@ +/*
+ 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 4 Sep 2010
+ 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 };
+byte 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):
+Server server(80);
+
+void setup()
+{
+ // start the Ethernet connection and the server:
+ Ethernet.begin(mac, ip);
+ server.begin();
+}
+
+void loop()
+{
+ // listen for incoming clients
+ Client client = server.available();
+ if (client) {
+ // an http request ends with a blank line
+ boolean currentLineIsBlank = true;
+ while (client.connected()) {
+ if (client.available()) {
+ char c = client.read();
+ // if you've gotten to the end of the line (received a newline
+ // character) and the line is blank, the http request has ended,
+ // so you can send a reply
+ if (c == '\n' && currentLineIsBlank) {
+ // send a standard http response header
+ client.println("HTTP/1.1 200 OK");
+ client.println("Content-Type: text/html");
+ client.println();
+
+ // output the value of each analog input pin
+ for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
+ client.print("analog input ");
+ client.print(analogChannel);
+ client.print(" is ");
+ client.print(analogRead(analogChannel));
+ client.println("<br />");
+ }
+ break;
+ }
+ if (c == '\n') {
+ // you're starting a new line
+ currentLineIsBlank = true;
+ }
+ else if (c != '\r') {
+ // you've gotten a character on the current line
+ currentLineIsBlank = false;
+ }
+ }
+ }
+ // give the web browser time to receive the data
+ delay(1);
+ // close the connection:
+ client.stop();
+ }
+}
\ No newline at end of file |