etherdune/docs/_h_t_t_p_server_demo___multiple_clients_8ino_source.html

 // EtherDune HTTP Server demo supporting simultaneous connections

 // Author: Javier Peletier <jm@friendev.com>

 // Summary: Demonstrates how to build a simple web server that is able to serve multiple clients simultaneously

 //

 // Copyright (c) 2015 All Rights Reserved, http://friendev.com

 //

 // This source is subject to the GPLv2 license.

 // Please see the License.txt file for more information.

 // All other rights reserved.

 //

 // THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY

 // KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE

 // IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A

 // PARTICULAR PURPOSE.


 #include <ACross.h>

 #include <Checksum.h>

 #include <TCPSocket.h>


 #include <inet.h>

 #include <ENC28J60.h>

 #include <FlowScanner.h>

 #include <HTTPServer.h>

 #include <TCPListener.h>


 #define AC_LOGLEVEL 6

 #include <ACLog.h>

 ACROSS_MODULE("HTTPServerDemo_MultipleClients");


 static const uint8_t CS_PIN = 10; //Put here what pin you are using for your ENC28J60's chip select

 static MACAddress_P mymac = { 0x66, 0x72, 0x69, 0x65, 0x6e, 0x64 };

 static IPAddress_P gatewayIP = { 192, 168, 1, 1 };

 static IPAddress_P myIP = { 192, 168, 1, 33 };

 static IPAddress_P netmask = { 255, 255, 255, 0 };


 static const uint8_t MAX_CLIENTS = 2; // maximum number of simultaneous HTTP clients


 class HTTPServerTestMulti : public HTTPServer

 {

 public:

     static const uint8_t ACTION_DIGITALREAD = 1;

     static const uint8_t ACTION_ANALOGREAD = 2;


     void onRequest(char* queryString)

     {

         ACTRACE("Requested URL:%s", queryString);


         //for illustrative purposes, enforce that only a GET method is used to access this server

         if (httpMethod != HTTP_METHOD_GET)

         {

             beginResponse(HTTP_RESPONSE_METHOD_NOT_ALLOWED, HTTP_RESPONSE_METHOD_NOT_ALLOWED_STR);

             writeHeader(F("Allow"), F("GET"));

             beginResponseBody();

             write(F("Use a GET request"));


         }

         else

         {


             if (strcmp_P(queryString, PSTR("/")) == 0)

             {

                 beginResponse_P(HTTP_RESPONSE_OK, HTTP_RESPONSE_OK_STR);

                 writeContentTypeHeader_P(CONTENT_TYPE_TEXT_HTML);

                 beginResponseBody();

                 String title(F("Arduino Pin Monitor"));


                 write(F("<html><head><title>%</title></head><body><h1>%</h1><h2>Select pin to monitor:</h2><h3>digital</h3><ul>"), &title, &title);


                 for (uint8_t pin = 2; pin < 13; pin++)

                 {

                     String pinStr(pin);

                     write(F("<li><a href=\"/digitalRead/%\">Pin %</a></li>"), &pinStr, &pinStr);

                 }


                 write(F("</ul><h3>Analog</h3><ul>"));


                 for (uint8_t pin = A0; pin <= A7; pin++)

                 {

                     String pinStr(pin);

                     String APinStr(pin - A0);

                     write(F("<li><a href=\"/analogRead/%\">Pin A%</a></li>"), &pinStr, &APinStr);


                 }

                 write(F("</ul></html>"));


             }

             else

             {

                 if (strcmp_P(queryString, PSTR("/favicon.ico")) == 0)

                 {

                     beginResponse_P(HTTP_RESPONSE_FOUND, HTTP_RESPONSE_FOUND_STR);

                     writeHeader(HTTP_HEADER_LOCATION, F("http://www.iconj.com/ico/c/a/capa77m3l6.ico"));

                 }

                 else

                 {

                     uint8_t action = 0;

                     uint8_t pin;

                     char* p;

                     p = strtok(queryString, "/");


                     if (p != NULL)

                     {

                         if (strcmp_P(p, PSTR("digitalRead")) == 0)

                             action = ACTION_DIGITALREAD;

                         else

                         {

                             if (strcmp_P(p, PSTR("analogRead")) == 0)

                                 action = ACTION_ANALOGREAD;

                         }

                     }


                     if (action != 0)

                     {

                         p = strtok(NULL, "/");

                         if (p != NULL)

                         {

                             pin = atoi(p);

                         }


                         beginResponse_P(HTTP_RESPONSE_OK, HTTP_RESPONSE_OK_STR);

                         writeContentTypeHeader_P(CONTENT_TYPE_TEXT_HTML);

                         beginResponseBody();

                         String strPin(pin);

                         uint16_t val = (action == ACTION_ANALOGREAD) ? analogRead(pin) : digitalRead(pin);

                         String strVal(val);


                         write(F("<html><head><meta http-equiv=\"refresh\" content=\"10\" /></head><body><h1>pin%=%</h1></body></html>"), &strPin, &strVal);

                     }

                     else

                     {

                         beginResponse_P(HTTP_RESPONSE_NOT_FOUND, HTTP_RESPONSE_NOT_FOUND_STR);

                         beginResponseBody();

                         write(F("<html><body><h1>404 not found!</h1></body></html>"));

                     }

                 }

             }

         }


         endResponse();

     }


     void onHeaderReceived(const char* headerName, const char* headerValue)

     {

         ACTRACE("HTTP Header: %s = '%s'", headerName, headerValue);

     }


     void onBodyBegin()

     {

         ACTRACE("onBodyBegin: Content-Length = %d", contentLength);

     }


     void onRequestEnd()

     {

         ACTRACE("Request ended");

     }


 };


 TCPListener<HTTPServerTestMulti, MAX_CLIENTS> server;


 void setup()

 {


     Serial.begin(115200);

     ACross::init();

 #ifdef ACROSS_ARDUINO

     ACross::printf_serial_init();

 #endif


     printf(PSTR("Multiple client HTTP Server EtherDune sample\n"));

     Serial.print(F("Free RAM: ")); Serial.println(ACross::getFreeRam());

     printf(PSTR("Press any key to start...\n"));


     while (!Serial.available());


     net::localMAC = mymac;

     net::localIP = myIP;

     net::gatewayIP = gatewayIP;

     net::netmask = netmask;


     if (!net::begin(CS_PIN))

         ACERROR("failed to start EtherDune");


     ACINFO("waiting for link...");


     while (!net::isLinkUp());


     ACINFO("link is up");


     server.listen(80);


     Serial.print("HTTP Server listening on ");

     Serial.print(net::localIP.toString());

     Serial.print(":");

     Serial.println(server.localPort);

 }


 void loop()

 {

     net::loop();


 }


 /// \endcond

HTTP_RESPONSE_METHOD_NOT_ALLOWED_STR
static const char HTTP_RESPONSE_METHOD_NOT_ALLOWED_STR[]
Definition: HTTPConstants.h:147

Socket::localPort
nint16_t localPort
local TCP or UDP port
Definition: Socket.h:54

HTTPServer::writeHeader
void writeHeader(const String &headerName, const String &headerValue)
Writes an HTTP header to the ongoing response stream.
Definition: HTTPServer.cpp:225

HTTPServer::beginResponse
void beginResponse(uint16_t statusCode, const String &message="")
Sends out the response line, e.g.
Definition: HTTPServer.cpp:203

MACAddress_P
#define MACAddress_P
Definition: inet.h:242

TCPListener::listen
void listen(uint16_t port)
Starts to listen on the specified TCP port.
Definition: TCPListener.h:83

IPAddress_P
#define IPAddress_P
helper macro to store an IP address in PROGMEM
Definition: inet.h:170

HTTPServer::onBodyBegin
virtual void onBodyBegin()
Called when all HTTP headers have been received and the body of the request is about to arrive...
Definition: HTTPServer.cpp:49

Socket::write
uint16_t write(uint16_t len, const byte *data)
In the case of TCP, writes the given data buffer to the socket.
Definition: Socket.cpp:54

gatewayIP
static IPAddress_P gatewayIP
Definition: EtherSocketTest.ino:36

HTTPServer::beginResponse_P
void beginResponse_P(uint16_t statusCode, PGM_P message)
Sends out the response line, e.g.
Definition: HTTPServer.cpp:214

HTTP_METHOD_GET
static const uint8_t HTTP_METHOD_GET
Definition: HTTPConstants.h:40

NetworkService::begin
static bool begin(uint8_t cspin)
Initializes EtherDune and the underlying hardware
Definition: NetworkService.cpp:67

HTTP_RESPONSE_FOUND_STR
static const char HTTP_RESPONSE_FOUND_STR[]
Definition: HTTPConstants.h:135

HTTPServer.h

NetworkService::netmask
static IPAddress netmask
Subnet mask.
Definition: NetworkService.h:138

NetworkService::gatewayIP
static IPAddress gatewayIP
IP address of the gateway in this network.
Definition: NetworkService.h:137

ACROSS_MODULE
ACROSS_MODULE("ARP")

CS_PIN
static const uint8_t CS_PIN
Definition: EtherSocketTest.ino:34

HTTPServer::onHeaderReceived
virtual void onHeaderReceived(const char *headerName, const char *headerValue)
Called once for each header in the request, as they arrive.
Definition: HTTPServer.cpp:43

HTTP_RESPONSE_FOUND
static const uint16_t HTTP_RESPONSE_FOUND
This response code means that URI of requested resource has been changed temporarily.
Definition: HTTPConstants.h:86

HTTP_HEADER_LOCATION
static const char HTTP_HEADER_LOCATION[]
Used in redirection, or when a new resource has been created.
Definition: HTTPConstants.h:219

HTTPServer::beginResponseBody
void beginResponseBody()
Indicates to the client that all headers have been written and that the response body follows...
Definition: HTTPServer.cpp:266

mymac
static MACAddress_P mymac
Definition: EtherSocketTest.ino:35

HTTP_RESPONSE_NOT_FOUND_STR
static const char HTTP_RESPONSE_NOT_FOUND_STR[]
Definition: HTTPConstants.h:146

TCPListener
Maintains a list of available sockets, also listening and spawning sockets to serve multiple clients ...
Definition: TCPListener.h:45

ENC28J60::isLinkUp
static bool isLinkUp()
Determines whether the network link is ready
Definition: ENC28J60.cpp:306

HTTP_RESPONSE_OK
static const uint16_t HTTP_RESPONSE_OK
The request has succeeded.
Definition: HTTPConstants.h:77

setup
void setup()
Definition: EtherSocketTest.ino:43

HTTPServer::writeContentTypeHeader_P
void writeContentTypeHeader_P(PGM_P contentType)
Convenient function to write the Content-Type header.
Definition: HTTPServer.cpp:257

Checksum.h

HTTP_RESPONSE_OK_STR
static const char HTTP_RESPONSE_OK_STR[]
Definition: HTTPConstants.h:126

NetworkService::localMAC
static MACAddress localMAC
Ethernet MAC address.
Definition: NetworkService.h:135

myIP
static IPAddress_P myIP
Definition: EtherSocketTest.ino:37

inet.h
Base data structures for Internet communication.

HTTPServer
Provides an easy way to build a web server.
Definition: HTTPServer.h:57

TCPListener.h

HTTPServer::onRequestEnd
virtual void onRequestEnd()
Called after all the body has been received
Definition: HTTPServer.cpp:59

HTTPServer::endResponse
void endResponse()
Ends the connection and finalizes the response.
Definition: HTTPServer.cpp:275

HTTP_RESPONSE_NOT_FOUND
static const uint16_t HTTP_RESPONSE_NOT_FOUND
Server can not find requested resource.
Definition: HTTPConstants.h:97

NetworkService::loop
static void loop()
Gives processing time to EtherDune so that it can check for incoming packets or send queued packets...
Definition: NetworkService.cpp:114

HTTPServer::onRequest
virtual void onRequest(char *queryString)
Called immediately after the first line that contains the HTTP method and query string is received ...
Definition: HTTPServer.cpp:55

NetworkService::localIP
static IPAddress localIP
IP address of this application.
Definition: NetworkService.h:136

ENC28J60.h

HTTP_RESPONSE_METHOD_NOT_ALLOWED
static const uint16_t HTTP_RESPONSE_METHOD_NOT_ALLOWED
The request method is known by the server but has been disabled and cannot be used.
Definition: HTTPConstants.h:98

TCPSocket.h

netmask
static IPAddress_P netmask
Definition: EtherSocketTest.ino:38

loop
void loop()
Definition: EtherSocketTest.ino:82

CONTENT_TYPE_TEXT_HTML
static const char CONTENT_TYPE_TEXT_HTML[]
Definition: HTTPConstants.h:30