Poniżej opisany projekt przedstawia “wrap” biblioteki EtherCard https://github.com/njh/EtherCard.

Biblioteka EtherCard bardzo ładnie rozwiązuje konfigurację modułu ethernet opartego na układzie ENC28J60, pozwala ona m.in. na zestawienie połączenia ze statycznym IP lub uzyskanym poprzez DHCP.

Dzięki bibliotece EtherCard w łatwy sposób można zrobić aplikację serwer/klient obsługującą powiadomienia lub dostarczającą dane telemetryczne, a nawet prostą aplikację IoT.

Brakowało mi jednak przejrzystości w sketch-u i prostoty obsługi żądań HTTP. Bazując na przykładach udostępnionych przez EtherCard i ogólnodostępnej wiedzy, dopisałem wrap tej biblioteki i nazwałem ją EtherDevice.

Spis treści:

Opis nagłówka
Przykładowe użycie
1. Sposób połączenia modułu ethernet i arduino
2. Sketch z komentarzami
3. Sketch bez komentarzy
Wady/Zalety
Załączniki

1. Opis nagłówka

Na początku postanowiłem zamknąć fragmenty kodu, które pierwotnie zmniejszały czytelność sketch-a właściwego.
Utworzyłem klasę EtherDevice dziedziczącą publicznie po EtherCard, a w niej zawarłem poniżej opisane metody.

Inicializacja z adresem IP przydzielanym przez DHCP:

    //DHCP IP init
    // mac - MAC adres urządzenia
    // slaveSelect - określa pin dla chip select układu gdy płyta Arduino inna niż UNO 
    int init(byte mac[], int slaveSelect)
    {
      if (begin(sizeof Ethernet::buffer, mac, slaveSelect) == 0)
        return 1;//Failed to access Ethernet controller
    
      if (!dhcpSetup())
        return 2;//DHCP failed
    
      return 0;
    }

//DHCP IP init

// mac - MAC adres urządzenia

// slaveSelect - określa pin dla chip select układu gdy płyta Arduino inna niż UNO

int init(byte mac[], int slaveSelect)

{

if (begin(sizeof Ethernet::buffer, mac, slaveSelect) == 0)

return 1;//Failed to access Ethernet controller

if (!dhcpSetup())

return 2;//DHCP failed

return 0;

}

Inicializacja z adresem IP ustawionym statycznie:

    //STATIC IP init
    // mac - MAC adres urządzenia 
    // myip - adres IP, wymaga dodania w sketch-u:
    //        static byte myip[] = { 192,168,1,200 };<br />    // gateway - adres bramy domyślnej, wymaga dodania w sketch-u:<br />    //        static byte gwip[] = { 192,168,1,1 };
    // slaveSelect - określa pin dla chip select układu gdy płyta Arduino inna niż UNO
    int init(byte mac[], byte ip[], byte gateway[], int slaveSelect)
    {
      if (begin(sizeof Ethernet::buffer, mac, slaveSelect) == 0)
        return 1;//Failed to access Ethernet controller

      staticSetup(ip, gateway);
      return 0;
    }

//STATIC IP init

// mac - MAC adres urządzenia

// myip - adres IP, wymaga dodania w sketch-u:

// static byte myip[] = { 192,168,1,200 };<br /> // gateway - adres bramy domyślnej, wymaga dodania w sketch-u:<br /> // static byte gwip[] = { 192,168,1,1 };

// slaveSelect - określa pin dla chip select układu gdy płyta Arduino inna niż UNO

int init(byte mac[], byte ip[], byte gateway[], int slaveSelect)

{

if (begin(sizeof Ethernet::buffer, mac, slaveSelect) == 0)

return 1;//Failed to access Ethernet controller

staticSetup(ip, gateway);

return 0;

}

Metoda ipconfig:

    // Wypisuje poprzez Serial konfigurację IP urządzenia
    void ipconfig()
    {
      printIp("IP:  ", ether.myip);
      printIp("GW:  ", ether.gwip);  
      printIp("DNS: ", ether.dnsip); 
    }

// Wypisuje poprzez Serial konfigurację IP urządzenia

void ipconfig()

{

printIp("IP: ", ether.myip);

printIp("GW: ", ether.gwip);

printIp("DNS: ", ether.dnsip);

}

Metoda statycznej odpowiedzi – staticHttpServerReply:

    // Wysyła statycznie zdefiniowaną odpowiedź na żądanie HTTP 
    // mem - stały zdefiniowany łańcuch
    void staticHttpServerReply(const char mem[])
    {
      bfill = tcpOffset();
      bfill.emit_p(mem);
      httpServerReply(bfill.position());
    }

// Wysyła statycznie zdefiniowaną odpowiedź na żądanie HTTP

// mem - stały zdefiniowany łańcuch

void staticHttpServerReply(const char mem[])

{

bfill = tcpOffset();

bfill.emit_p(mem);

httpServerReply(bfill.position());

}

Powyższa metoda ta wymaga zdefiniowanych stałych łańcuchów, zdefiniowałem typowe odpowiedzi HTTP (200, 401, 404, 405, 406), przydatne w dalszej części usprawnienia biblioteki EtherCard:

const char HTTP200[] PROGMEM =
"HTTP/1.1 200 OK\r\n"
"Server: Arduino Ethernet Devices\r\n"
"Cache-Control: no-store\r\n"
"Connection: Keep-Alive\r\n"
"Content-Type: text/html; charset=utf-8\r\n\r\n";

const char HTTP401[] PROGMEM =
"HTTP/1.0 401 Unauthorized\r\n"
"Content-Type: text/html\r\n\r\n"
"<h1>401 Unauthorized</h1>";

const char HTTP404[] PROGMEM =
"HTTP/1.0 404 Not Found\r\n"
"Content-Type: text/html\r\n\r\n"
"<h1>404 Not Found</h1>";

const char HTTP405[] PROGMEM =
"HTTP/1.0 405 Method Not Allowed\r\n"
"Content-Type: text/html\r\n\r\n"
"<h1>405 Method Not Allowed</h1>";

const char HTTP406[] PROGMEM =
"HTTP/1.0 406 Not Acceptable\r\n"
"Content-Type: text/html\r\n\r\n"
"<h1>406 Not Acceptable</h1>";

const char HTTP200[] PROGMEM =

"HTTP/1.1 200 OK\r\n"

"Server: Arduino Ethernet Devices\r\n"

"Cache-Control: no-store\r\n"

"Connection: Keep-Alive\r\n"

"Content-Type: text/html; charset=utf-8\r\n\r\n";

const char HTTP401[] PROGMEM =

"HTTP/1.0 401 Unauthorized\r\n"

"Content-Type: text/html\r\n\r\n"

"<h1>401 Unauthorized</h1>";

const char HTTP404[] PROGMEM =

"HTTP/1.0 404 Not Found\r\n"

"Content-Type: text/html\r\n\r\n"

"<h1>404 Not Found</h1>";

const char HTTP405[] PROGMEM =

"HTTP/1.0 405 Method Not Allowed\r\n"

"Content-Type: text/html\r\n\r\n"

"<h1>405 Method Not Allowed</h1>";

const char HTTP406[] PROGMEM =

"HTTP/1.0 406 Not Acceptable\r\n"

"Content-Type: text/html\r\n\r\n"

"<h1>406 Not Acceptable</h1>";

Następnie napisałem metodę, ułatwiającą parsowanie argumentów żądania HTTP, np:
po wpisaniu w przeglądarce http: //ip_urządzenia/?arg_1=val_1&arg_2=val_2& … &arg_C=val_C
jest C niewygodnych do sparsowania argumentów oddzielonych znakiem “&”.

    // Zwraca liczbę argumentów przychodzących w żądaniu HTTP
    // i zapisuje argumenty pod wskaźnikiem argv
    // argc - dopuszczalna liczba argumentów
    // argv wskaźnik tablicy struktur argumentów
    int getTask(int argc, arg argv[])
    {
      word offset = packetLoop(packetReceive());
      if ( offset ) 
      {
        char *request = (char *) Ethernet::buffer + offset;
        if (strncmp("GET /", request, 5) != 0) 
        {   
          // 405 Unsupported HTTP request
          staticHttpServerReply(HTTP405);
          return -1;
        } else {
          request += 5;
          if (request[0] == ' ') 
          { 
            //Jeżeli nie ma żadnych argumentów
            for(int idx=0; idx<argc; idx++)
            {
              argv[idx].argName = "";
              argv[idx].argValue = "";
            }
            return 0;
          } else {
            if (!strncmp("?",request,1))
            { 
              //Wycinanie rządania od znaku "?" + 1, żeby tego znaku "?" nie było w ciągu,
              //do znaku " " o indeksie endIdx.
              int endIdx = strcspn (request," ");
              request += strcspn (request,"?") + 1;

              int idx = 0;
              int args_valid = 0;
              int args_cnt = 0;
          
              for( idx=0; idx<endIdx; idx++ )
              {
                if(request[idx]=='&')
                  args_cnt++;
                if(request[idx]=='=')
                  args_valid++;
              }

              if( (args_valid == (args_cnt+1)) && (args_valid<=argc) )
              { 
                for( idx=0; idx<argc; idx++)
                {
                  argv[idx].argName = "";
                  argv[idx].argValue = "";
                }

                idx=0;
                bool tictac=0;
                for( int c=0; c<endIdx; c++ )
                {
                  if( tictac == 0)
                  {
                    if( request[c] == '=')
                    {
                      tictac=!tictac;
                    }else{
                      argv[idx].argName += request[c];  
                    }
                  }else{
                    if( request[c] == '&')
                    {
                      tictac=!tictac;
                      idx++;
                    }else{
                      argv[idx].argValue += request[c];
                    }
                  }
                }
                return args_cnt+1;
              }else{
                // 406 Not Acceptable
                staticHttpServerReply(HTTP406);
                return -3;
              }
            } else {
              // 404 Page not found
              staticHttpServerReply(HTTP404);
              return -2;
            }
          }
        }
      } else {
        return -1;
      }
    }

// Zwraca liczbę argumentów przychodzących w żądaniu HTTP

// i zapisuje argumenty pod wskaźnikiem argv

// argc - dopuszczalna liczba argumentów

// argv wskaźnik tablicy struktur argumentów

int getTask(int argc, arg argv[])

{

word offset = packetLoop(packetReceive());

if ( offset )

{

char *request = (char *) Ethernet::buffer + offset;

if (strncmp("GET /", request, 5) != 0)

{

// 405 Unsupported HTTP request

staticHttpServerReply(HTTP405);

return -1;

} else {

request += 5;

if (request[0] == ' ')

{

//Jeżeli nie ma żadnych argumentów

for(int idx=0; idx<argc; idx++)

{

argv[idx].argName = "";

argv[idx].argValue = "";

}

return 0;

} else {

if (!strncmp("?",request,1))

{

//Wycinanie rządania od znaku "?" + 1, żeby tego znaku "?" nie było w ciągu,

//do znaku " " o indeksie endIdx.

int endIdx = strcspn (request," ");

request += strcspn (request,"?") + 1;

int idx = 0;

int args_valid = 0;

int args_cnt = 0;

for( idx=0; idx<endIdx; idx++ )

{

if(request[idx]=='&')

args_cnt++;

if(request[idx]=='=')

args_valid++;

}

if( (args_valid == (args_cnt+1)) && (args_valid<=argc) )

{

for( idx=0; idx<argc; idx++)

{

argv[idx].argName = "";

argv[idx].argValue = "";

}

idx=0;

bool tictac=0;

for( int c=0; c<endIdx; c++ )

{

if( tictac == 0)

{

if( request[c] == '=')

{

tictac=!tictac;

}else{

argv[idx].argName += request[c];

}

}else{

if( request[c] == '&')

{

tictac=!tictac;

idx++;

}else{

argv[idx].argValue += request[c];

}

return args_cnt+1;

}else{

// 406 Not Acceptable

staticHttpServerReply(HTTP406);

return -3;

}

} else {

// 404 Page not found

staticHttpServerReply(HTTP404);

return -2;

}

} else {

return -1;

}

Powyższa metoda wymaga zdefiniowanej struktury dla argumentów argv:

// Struktura przechowywania argumentów żądania
struct arg
{
  String argName;
  String argValue;
};

// Struktura przechowywania argumentów żądania

struct arg

{

String argName;

String argValue;

};

Kolejno dopisałem metodę pozwalającą w przyjazny sposób wypisać w Serial wszystkie argumenty żądania, mając już je sparsowane przy użyciu metody getTask:

    // Wypisuje w Serial wszystkie argumenty przychodzące
    // argc - aktualna liczba argumentów 
    // argv wskaźnik tablicy struktur argumentów
    void printArg(int argc, arg argv[])
    {
      for(int i=0;i<argc;i++)
      {
        Serial.print("[");
        Serial.print(argv[i].argName);
        Serial.print(" = ");
        Serial.print(argv[i].argValue);
        Serial.println("]");
      }
    }

// Wypisuje w Serial wszystkie argumenty przychodzące

// argc - aktualna liczba argumentów

// argv wskaźnik tablicy struktur argumentów

void printArg(int argc, arg argv[])

{

for(int i=0;i<argc;i++)

{

Serial.print("[");

Serial.print(argv[i].argName);

Serial.print(" = ");

Serial.print(argv[i].argValue);

Serial.println("]");

}

Nie mogło zabraknąć też metody wyszukującej czy dany argument zaistniał w żądaniu i zwracającej jego wartość:

    // Zwraca wartość argumentu o nazwie argName jeżeli istnieje 
    // argc - aktualna liczba argumentów 
    // argv wskaźnik tablicy struktur argumentów
    String getArg(int argc, arg argv[], String argName)
    {
      argName.trim();
      for(int i=0;i<argc;i++)
      {
        argv[i].argName.trim();                      
        if(argv[i].argName.compareTo(argName)==0)
        {
          argv[i].argValue.trim();
          return argv[i].argValue;
        }
      }
      return "";
    }

// Zwraca wartość argumentu o nazwie argName jeżeli istnieje

// argc - aktualna liczba argumentów

// argv wskaźnik tablicy struktur argumentów

String getArg(int argc, arg argv[], String argName)

{

argName.trim();

for(int i=0;i<argc;i++)

{

argv[i].argName.trim();

if(argv[i].argName.compareTo(argName)==0)

{

argv[i].argValue.trim();

return argv[i].argValue;

}

return "";

}

Dodatkowo napisałem metodę sprawdzającą i porównującą czy istnieje dany argument o danej wartości:

    // Sprawdza czy argument o podanej nazwie argName zawiera argValue
    // argc - aktualna liczba argumentów 
    // argv wskaźnik tablicy struktur argumentów
    int checkArg(int argc, arg argv[], String argName, String argValue)
    {
      argName.trim();
      argValue.trim();
      if(getArg(argc, argv, argName).compareTo(argValue)==0)
      {
        return 0;
      }
      return 1;
    }

// Sprawdza czy argument o podanej nazwie argName zawiera argValue

// argc - aktualna liczba argumentów

// argv wskaźnik tablicy struktur argumentów

int checkArg(int argc, arg argv[], String argName, String argValue)

{

argName.trim();

argValue.trim();

if(getArg(argc, argv, argName).compareTo(argValue)==0)

{

return 0;

}

return 1;

}

Wewnątrz klasy jest zadeklarowana metoda webPage służąca wygenerowaniu odpowiedzi na żądanie:

    // Służy wygenerowaniu odpowiedzi na żądanie HTTP
    // Definicja musi być w pliku .ino (w sketch-u) jako:
    // word EtherDevice::webPage()
    // {
    //   // Ustawia offset w BufferFiller
    //   bfill = tcpOffset();
    //
    //   // Wewnątrz PSTR(...) możesz używać następujących typów:
    //   //  $D = word data type
    //   //  $L = long data type
    //   //  $S = c string
    //   //  $F = progmem string
    //   //  $E = byte from the eeprom
    //   bfill.emit_p(
    //     PSTR(
    //       "$F"// Tego $F nie zmieniaj i nie usuwaj - to nagłówek odpowiedzi HTTP OK
    //       " jakiś tekst html $D jakiś tekst html "
    //       " jakiś tekst html $D jakiś tekst html"
    //       "..."
    //       ...
    //     ),
    //     HTTP200,// Tego HTTP200 nie zmieniaj i nie usuwaj - to nagłówek odpowiedzi HTTP OK
    //     ..., // potrzebne zmienne
    //     ...
    //   );
    //
    //  // Zwraca aktualny offset BufferFiller
    //  return bfill.position();
    // }
    word webPage();

// Służy wygenerowaniu odpowiedzi na żądanie HTTP

// Definicja musi być w pliku .ino (w sketch-u) jako:

// word EtherDevice::webPage()

// {

// // Ustawia offset w BufferFiller

// bfill = tcpOffset();

// // Wewnątrz PSTR(...) możesz używać następujących typów:

// // $D = word data type

// // $L = long data type

// // $S = c string

// // $F = progmem string

// // $E = byte from the eeprom

// bfill.emit_p(

// PSTR(

// "$F"// Tego $F nie zmieniaj i nie usuwaj - to nagłówek odpowiedzi HTTP OK

// " jakiś tekst html $D jakiś tekst html "

// " jakiś tekst html $D jakiś tekst html"

// "..."

// ...

// ),

// HTTP200,// Tego HTTP200 nie zmieniaj i nie usuwaj - to nagłówek odpowiedzi HTTP OK

// ..., // potrzebne zmienne

// ...

// );

// // Zwraca aktualny offset BufferFiller

// return bfill.position();

// }

word webPage();

Natomiast definicja powyższej metody jest realizowana w sketch-u, po to by użytkownik opisywanego tutaj wrap-a nie musiał grzebać w kodzie nagłówka.

Cały plik nagłówkowy “EtherDevice.h” prezentuje się następująco:

/*
 * Autor: Cezary Wernik
 * Szczecin 2018 Polska 
 */
#ifndef EtherDevice_h
#define EtherDevice_h

#include <EtherCard.h>
byte Ethernet::buffer[500]; // tcp/ip buffer
BufferFiller bfill;

const char HTTP200[] PROGMEM =
"HTTP/1.1 200 OK\r\n"
"Server: Arduino Ethernet Devices\r\n"
"Cache-Control: no-store\r\n"
"Connection: Keep-Alive\r\n"
"Content-Type: text/html; charset=utf-8\r\n\r\n";

const char HTTP401[] PROGMEM =
"HTTP/1.0 401 Unauthorized\r\n"
"Content-Type: text/html\r\n\r\n"
"<h1>401 Unauthorized</h1>";

const char HTTP404[] PROGMEM =
"HTTP/1.0 404 Not Found\r\n"
"Content-Type: text/html\r\n\r\n"
"<h1>404 Not Found</h1>";

const char HTTP405[] PROGMEM =
"HTTP/1.0 405 Method Not Allowed\r\n"
"Content-Type: text/html\r\n\r\n"
"<h1>405 Method Not Allowed</h1>";

const char HTTP406[] PROGMEM =
"HTTP/1.0 406 Not Acceptable\r\n"
"Content-Type: text/html\r\n\r\n"
"<h1>406 Not Acceptable</h1>";

// Struktura przechowywania argumentów żądania
struct arg
{
  String argName;
  String argValue;
};

class EtherDevice : public EtherCard
{
  public:
    //DHCP IP init
    // mac - MAC adres urządzenia
    // slaveSelect - określa pin dla chip select układu gdy płyta Arduino inna niż UNO 
    int init(byte mac[], int slaveSelect)
    {
      if (begin(sizeof Ethernet::buffer, mac, slaveSelect) == 0)
        return 1;//Failed to access Ethernet controller
    
      if (!dhcpSetup())
        return 2;//DHCP failed
    
      return 0;
    }

    //STATIC IP init
    // mac - MAC adres urządzenia 
    // myip - adres IP, wymaga dodania w sketch-u:
    //        static byte myip[] = { 192,168,1,200 };
    // gateway - adres bramy domyślnej, wymaga dodania w sketch-u:
    //        static byte gwip[] = { 192,168,1,1 };
    // slaveSelect - określa pin dla chip select układu gdy płyta Arduino inna niż UNO
    int init(byte mac[], byte ip[], byte gateway[], int slaveSelect)
    {
      if (begin(sizeof Ethernet::buffer, mac, slaveSelect) == 0)
        return 1;//Failed to access Ethernet controller

      staticSetup(ip, gateway);
      return 0;
    } 

    // Wypisuje poprzez Serial konfigurację IP urządzenia
    void ipconfig()
    {
      printIp("IP:  ", ether.myip);
      printIp("GW:  ", ether.gwip);  
      printIp("DNS: ", ether.dnsip); 
    }
    
    // Wysyła statycznie zdefiniowaną odpowiedź na żądanie HTTP 
    // mem - stały zdefiniowany łańcuch
    void staticHttpServerReply(const char mem[])
    {
      bfill = tcpOffset();
      bfill.emit_p(mem);
      httpServerReply(bfill.position());
    }

    // Wypisuje w Serial wszystkie argumenty przychodzące
    // argc - aktualna liczba argumentów 
    // argv wskaźnik tablicy struktur argumentów
    void printArg(int argc, arg argv[])
    {
      for(int i=0;i<argc;i++)
      {
        Serial.print("[");
        Serial.print(argv[i].argName);
        Serial.print(" = ");
        Serial.print(argv[i].argValue);
        Serial.println("]");
      }
    }

    // Zwraca wartość argumentu o nazwie argName jeżeli istnieje 
    // argc - aktualna liczba argumentów 
    // argv wskaźnik tablicy struktur argumentów
    String getArg(int argc, arg argv[], String argName)
    {
      argName.trim();
      for(int i=0;i<argc;i++)
      {
        argv[i].argName.trim();                      
        if(argv[i].argName.compareTo(argName)==0)
        {
          argv[i].argValue.trim();
          return argv[i].argValue;
        }
      }
      return "";
    }

    // Sprawdza czy argument o podanej nazwie argName zawiera argValue
    // argc - aktualna liczba argumentów 
    // argv wskaźnik tablicy struktur argumentów
    int checkArg(int argc, arg argv[], String argName, String argValue)
    {
      argName.trim();
      argValue.trim();
      if(getArg(argc, argv, argName).compareTo(argValue)==0)
      {
        return 0;
      }
      return 1;
    }

    // Zwraca liczbę argumentów przychodzących w żądaniu HTTP
    // i zapisuje argumenty pod wskaźnikiem argv
    // argc - dopuszczalna liczba argumentów
    // argv wskaźnik tablicy struktur argumentów
    int getTask(int argc, arg argv[])
    {
      word offset = packetLoop(packetReceive());
      if ( offset ) 
      {
        char *request = (char *) Ethernet::buffer + offset;
        if (strncmp("GET /", request, 5) != 0) 
        {   
          // 405 Unsupported HTTP request
          staticHttpServerReply(HTTP405);
          return -1;
        } else {
          request += 5;
          if (request[0] == ' ') 
          { 
            //Jeżeli nie ma żadnych argumentów
            for(int idx=0; idx<argc; idx++)
            {
              argv[idx].argName = "";
              argv[idx].argValue = "";
            }
            return 0;
          } else {
            if (!strncmp("?",request,1))
            { 
              //Wycinanie rządania od znaku "?" + 1, żeby tego znaku "?" nie było w ciągu,
              //do znaku " " o indeksie endIdx.
              int endIdx = strcspn (request," ");
              request += strcspn (request,"?") + 1;

              int idx = 0;
              int args_valid = 0;
              int args_cnt = 0;
          
              for( idx=0; idx<endIdx; idx++ )
              {
                if(request[idx]=='&')
                  args_cnt++;
                if(request[idx]=='=')
                  args_valid++;
              }

              if( (args_valid == (args_cnt+1)) && (args_valid<=argc) )
              { 
                for( idx=0; idx<argc; idx++)
                {
                  argv[idx].argName = "";
                  argv[idx].argValue = "";
                }

                idx=0;
                bool tictac=0;
                for( int c=0; c<endIdx; c++ )
                {
                  if( tictac == 0)
                  {
                    if( request[c] == '=')
                    {
                      tictac=!tictac;
                    }else{
                      argv[idx].argName += request[c];  
                    }
                  }else{
                    if( request[c] == '&')
                    {
                      tictac=!tictac;
                      idx++;
                    }else{
                      argv[idx].argValue += request[c];
                    }
                  }
                }
                return args_cnt+1;
              }else{
                // 406 Not Acceptable
                staticHttpServerReply(HTTP406);
                return -3;
              }
            } else {
              // 404 Page not found
              staticHttpServerReply(HTTP404);
              return -2;
            }
          }
        }
      } else {
        return -1;
      }
    }

    // Służy wygenerowaniu odpowiedzi na żądanie HTTP  
    // Definicja musi być w pliku .ino (w sketch-u) jako:
    // word EtherDevice::webPage()
    // {
    //   // Ustawia offset w BufferFiller
    //   bfill = tcpOffset();
    //
    //   // Wewnątrz PSTR(...) możesz używać następujących typów:
    //   //  $D = word data type
    //   //  $L = long data type
    //   //  $S = c string
    //   //  $F = progmem string
    //   //  $E = byte from the eeprom
    //   bfill.emit_p(
    //     PSTR(
    //       "$F"// Tego $F nie zmieniaj i nie usuwaj - to nagłówek odpowiedzi HTTP OK
    //       " jakiś tekst html $D jakiś tekst html " 
    //       " jakiś tekst html $D jakiś tekst html" 
    //       "..."
    //       ...
    //     ),
    //     HTTP200,// Tego HTTP200 nie zmieniaj i nie usuwaj - to nagłówek odpowiedzi HTTP OK
    //     ..., // potrzebne zmienne
    //     ...
    //   );
    //
    //  // Zwraca aktualny offset BufferFiller
    //  return bfill.position();
    // }
    word webPage();
};

extern EtherDevice eth;

#endif

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

* Autor: Cezary Wernik

* Szczecin 2018 Polska

#ifndef EtherDevice_h

#define EtherDevice_h

#include <EtherCard.h>

byte Ethernet::buffer[500]; // tcp/ip buffer

BufferFiller bfill;

const char HTTP200[] PROGMEM =

"HTTP/1.1 200 OK\r\n"

"Server: Arduino Ethernet Devices\r\n"

"Cache-Control: no-store\r\n"

"Connection: Keep-Alive\r\n"

"Content-Type: text/html; charset=utf-8\r\n\r\n";

const char HTTP401[] PROGMEM =

"HTTP/1.0 401 Unauthorized\r\n"

"Content-Type: text/html\r\n\r\n"

"<h1>401 Unauthorized</h1>";

const char HTTP404[] PROGMEM =

"HTTP/1.0 404 Not Found\r\n"

"Content-Type: text/html\r\n\r\n"

"<h1>404 Not Found</h1>";

const char HTTP405[] PROGMEM =

"HTTP/1.0 405 Method Not Allowed\r\n"

"Content-Type: text/html\r\n\r\n"

"<h1>405 Method Not Allowed</h1>";

const char HTTP406[] PROGMEM =

"HTTP/1.0 406 Not Acceptable\r\n"

"Content-Type: text/html\r\n\r\n"

"<h1>406 Not Acceptable</h1>";

// Struktura przechowywania argumentów żądania

struct arg

{

String argName;

String argValue;

};

class EtherDevice : public EtherCard

{

public:

//DHCP IP init

// mac - MAC adres urządzenia

// slaveSelect - określa pin dla chip select układu gdy płyta Arduino inna niż UNO

int init(byte mac[], int slaveSelect)

{

if (begin(sizeof Ethernet::buffer, mac, slaveSelect) == 0)

return 1;//Failed to access Ethernet controller

if (!dhcpSetup())

return 2;//DHCP failed

return 0;

}

//STATIC IP init

// mac - MAC adres urządzenia

// myip - adres IP, wymaga dodania w sketch-u:

// static byte myip[] = { 192,168,1,200 };

// gateway - adres bramy domyślnej, wymaga dodania w sketch-u:

// static byte gwip[] = { 192,168,1,1 };

// slaveSelect - określa pin dla chip select układu gdy płyta Arduino inna niż UNO

int init(byte mac[], byte ip[], byte gateway[], int slaveSelect)

{

if (begin(sizeof Ethernet::buffer, mac, slaveSelect) == 0)

return 1;//Failed to access Ethernet controller

staticSetup(ip, gateway);

return 0;

}

// Wypisuje poprzez Serial konfigurację IP urządzenia

void ipconfig()

{

printIp("IP: ", ether.myip);

printIp("GW: ", ether.gwip);

printIp("DNS: ", ether.dnsip);

}

// Wysyła statycznie zdefiniowaną odpowiedź na żądanie HTTP

// mem - stały zdefiniowany łańcuch

void staticHttpServerReply(const char mem[])

{

bfill = tcpOffset();

bfill.emit_p(mem);

httpServerReply(bfill.position());

}

// Wypisuje w Serial wszystkie argumenty przychodzące

// argc - aktualna liczba argumentów

// argv wskaźnik tablicy struktur argumentów

void printArg(int argc, arg argv[])

{

for(int i=0;i<argc;i++)

{

Serial.print("[");

Serial.print(argv[i].argName);

Serial.print(" = ");

Serial.print(argv[i].argValue);

Serial.println("]");

}

// Zwraca wartość argumentu o nazwie argName jeżeli istnieje

// argc - aktualna liczba argumentów

// argv wskaźnik tablicy struktur argumentów

String getArg(int argc, arg argv[], String argName)

{

argName.trim();

for(int i=0;i<argc;i++)

{

argv[i].argName.trim();

if(argv[i].argName.compareTo(argName)==0)

{

argv[i].argValue.trim();

return argv[i].argValue;

}

return "";

}

// Sprawdza czy argument o podanej nazwie argName zawiera argValue

// argc - aktualna liczba argumentów

// argv wskaźnik tablicy struktur argumentów

int checkArg(int argc, arg argv[], String argName, String argValue)

{

argName.trim();

argValue.trim();

if(getArg(argc, argv, argName).compareTo(argValue)==0)

{

return 0;

}

return 1;

}

// Zwraca liczbę argumentów przychodzących w żądaniu HTTP

// i zapisuje argumenty pod wskaźnikiem argv

// argc - dopuszczalna liczba argumentów

// argv wskaźnik tablicy struktur argumentów

int getTask(int argc, arg argv[])

{

word offset = packetLoop(packetReceive());

if ( offset )

{

char *request = (char *) Ethernet::buffer + offset;

if (strncmp("GET /", request, 5) != 0)

{

// 405 Unsupported HTTP request

staticHttpServerReply(HTTP405);

return -1;

} else {

request += 5;

if (request[0] == ' ')

{

//Jeżeli nie ma żadnych argumentów

for(int idx=0; idx<argc; idx++)

{

argv[idx].argName = "";

argv[idx].argValue = "";

}

return 0;

} else {

if (!strncmp("?",request,1))

{

//Wycinanie rządania od znaku "?" + 1, żeby tego znaku "?" nie było w ciągu,

//do znaku " " o indeksie endIdx.

int endIdx = strcspn (request," ");

request += strcspn (request,"?") + 1;

int idx = 0;

int args_valid = 0;

int args_cnt = 0;

for( idx=0; idx<endIdx; idx++ )

{

if(request[idx]=='&')

args_cnt++;

if(request[idx]=='=')

args_valid++;

}

if( (args_valid == (args_cnt+1)) && (args_valid<=argc) )

{

for( idx=0; idx<argc; idx++)

{

argv[idx].argName = "";

argv[idx].argValue = "";

}

idx=0;

bool tictac=0;

for( int c=0; c<endIdx; c++ )

{

if( tictac == 0)

{

if( request[c] == '=')

{

tictac=!tictac;

}else{

argv[idx].argName += request[c];

}

}else{

if( request[c] == '&')

{

tictac=!tictac;

idx++;

}else{

argv[idx].argValue += request[c];

}

return args_cnt+1;

}else{

// 406 Not Acceptable

staticHttpServerReply(HTTP406);

return -3;

}

} else {

// 404 Page not found

staticHttpServerReply(HTTP404);

return -2;

}

} else {

return -1;

}

// Służy wygenerowaniu odpowiedzi na żądanie HTTP

// Definicja musi być w pliku .ino (w sketch-u) jako:

// word EtherDevice::webPage()

// {

// // Ustawia offset w BufferFiller

// bfill = tcpOffset();

// // Wewnątrz PSTR(...) możesz używać następujących typów:

// // $D = word data type

// // $L = long data type

// // $S = c string

// // $F = progmem string

// // $E = byte from the eeprom

// bfill.emit_p(

// PSTR(

// "$F"// Tego $F nie zmieniaj i nie usuwaj - to nagłówek odpowiedzi HTTP OK

// " jakiś tekst html $D jakiś tekst html "

// " jakiś tekst html $D jakiś tekst html"

// "..."

// ...

// ),

// HTTP200,// Tego HTTP200 nie zmieniaj i nie usuwaj - to nagłówek odpowiedzi HTTP OK

// ..., // potrzebne zmienne

// ...

// );

// // Zwraca aktualny offset BufferFiller

// return bfill.position();

// }

word webPage();

};

extern EtherDevice eth;

#endif

2. Przykładowe użycie

Poniżej przedstawiony zostanie schemat połączeń oraz sketch z komentarzami i bez, aby ukazać zaletę wrap-a, jaką jest przejrzystość sketcha przy nieco rozbudowanej funkcjonalności.

Założenia do przykładu użycia:

W przykładzie przyjęte jest założenie, że ktoś kto nie zna “tajnego klucza”, nie może ani odczytać nic z Arduino za pomocą protokołu HTTP, ani nic zmienić w jego ustawieniach.
Jako przykład wyobraźmy sobie wentylator sterowny PWM, wraz z termometrem podpiętym do pinu A0 Arduino – taka “wentylacja IoT”.
W kodzie temperaturę reprezentuje zmienna “int temperatura”, obroty wiatraka zmienna “int pwm_wentylatora”.
Chcielibyśmy po wpisaniu w przeglądarce IP urządzenia i odpowiedniego klucza zobaczyć aktualną temperaturę (0-100 stopni) i obecne obroty wiatraka (0-255) podane w formacie “temperatur|pwm_wentylatora”.
Wpisanie w przeglądarce samego adresu IP powinno zwrócić komunikat 401 Unauthorized.
Dopiero wpisanie adresu IP opatrzonego w secretKey
np. http://192.168.0.10/?secretKey=7rHvCGd59C
wyświetli stan temperatury odczytanej z pinu analogowego A0 i aktualnie ustawione PWM wentylatora.
Natomiast dopisanie do adresu cmd=changepwm i pwm=255 ustawi zmienną pwm_wentylatora na 255.
http://192.168.0.10/?secretKey=7rHvCGd59C&cmd=changepwm&pwm=255
Wyzerowanie pwm_wentylatora mogłoby być poprzez dopisanie cmd=resetpwm do adresu IP
np. http://192.168.0.10/?secretKey=7rHvCGd59C&cmd=resetpwm

Wybrany sposób łączności z urządzeniem jest ze względu na łatwość pobrania stanu urządzenia i jedno czesne sterowanie z innego urządzenia (np. NanoPi) za pomocą linuksowego polecenia wget. Z myślą o Arduino jako element większego systemu IoT.

2.1. Sposób połączenia modułu ethernet i Arduino

Schemat połączeń jest taki sam jak oryginalnie w bibliotece EtherCard https://github.com/njh/EtherCard

Dla Arduino UNO:

ENC28J60	Arduino Uno	Adnotacje
VCC	3.3V
GND	GND
SCK	Pin 13
MISO	Pin 12
MOSI	Pin 11
CS	Pin 10	Modyfikowalny przez eth.init()

Dla Arduino Mega:

ENC28J60	Arduino Mega	Adnotacje
VCC	3.3V
GND	GND
SCK	Pin 52
MISO	Pin 50
MOSI	Pin 51
CS	Pin 53	Modyfikowalny przez eth.init()

Odpowiednio zgodnie do przykładu użycia, do pinu A0 czujnik temperatury np. analogowy czujnik temperatury LM35 i do wybranego pinu PWM sterowanie wentylatora.

2.2. Sketch z komentarzami

/*
 * Autor: Cezary Wernik
 * Szczecin 2018 Polska 
 */
// Dołączenie wrap-a biblioteki EtherCard
#include "EtherDevice.h"

// Adres MAC urządzenia,
// w tym miejscu wstaw unikalny adres. 
static byte mac[] = {0x74, 0x69, 0x69, 0x2D, 0x30, 0x31 }; 

// Tajny klucz do odczytu "telemetrii" i wykonywania akcji,
// w tym miejscu wstaw tajny klucz.
String secretKey = "7rHvCGd59C"; 

// Deklaracja ilu maksymalnie argumentów urządzenie powinno się spodziewać.
// Przykład żądania HTTP:
// http: //192.168.0.10/?arg_1=val_1&arg_2=val_2& ... &arg_C=val_C
// W tym miejscu wpisz ile wynosi spodziewane C.
static const int argc=3;
// Argumentów wejściowych może przyjść c <= C;

// Obsługa tego przykładu:
//
// Wpisanie w przeglądarce samego adresu IP powinno zwrócić
// komunikat 401 Unauthorized.
//
// Dopiero wpisanie adres IP opatrzonego w secretKey 
// http ://192.168.0.10/?secretKey=7rHvCGd59C  
// wyświetli stan temperatury odczytanej z pinu analogowego A0 i aktualnie ustawione PWM wentylatora.
//
// Natomiast dopisanie do adresu cmd=changepwm i pwm=255 ustawi zmienną pwm_wentylatora na 255.
// http ://192.168.0.10/?secretKey=7rHvCGd59C&cmd=changepwm&pwm=255
//
// Można też wyzerować pwm_wentylatora dopisując cmd=resetpwm
// http ://192.168.0.10/?secretKey=7rHvCGd59C&cmd=resetpwm
// wyzeruje to zmienną pwm_wentylatora.

// Deklaracja przestrzeni na wejściowe argumenty. 
arg argv[argc];
// Struktura argumentów wygląda następująco: 
// struct arg
// {
//   String argName;
//   String argValue;
// };

// Zmienne do obsługi czujnika.
int temperatura = 0;
int pwm_wentylatora = 0;

void setup()
{
  Serial.begin( 57600 );
  Serial.println( "Arduino ethernet device" );

  // Dopóki urządzenie ethernet nie zainicjuje się po DHCP, 
  // wstrzymaj dalsze wykonywanie programu.
  while( eth.init( mac, SS ) != 0 );

  // Wyświetl w konsoli konfigurację IP uzyskaną z DHCP.
  eth.ipconfig();
}

void loop()
{
  // Pseudo odczyt temperatury.
  temperatura = map(analogRead(A0),0,1023,0,100);
  // Obsługa wentylatora w/g zmiennej pwm_wentylatora 
  /* 
    ... tu wyobraź sobie kod obsługi wentylatora :) ...
  */

  // Sprawdzenie przychodzących żądań,
  // jeżeli są to zwraca ilość argumentów wejściowych.
  int c = eth.getTask(argc, argv);
  
  if(c>=0)
  {
    // Funkcja w warunku sprawdza czy w argumentach wejściowych
    // jest argument o nazwie "secretKey", jeżeli jest to sprawdza czy 
    // zgodny ze zmienną secretKey zdefiniowaną na początku sketch-a.
    if(eth.checkArg(c, argv, "secretKey", secretKey)==0)
    {
      // Opcjonalnie wypisuje w Serial argumenty wejściowe.
      eth.printArg(c, argv);

      // Metoda checkArg sprawdza czy argument o podanej nazwie "cmd" zawiera "changepwm"
      if(eth.checkArg(c, argv, "cmd", "changepwm")==0)
      {
        // Funkcja getArg zwraca wartość argumentu wejściowego o podanej nazwie "pwm".
        String pwm = eth.getArg(c, argv, "pwm");
        if(pwm.length()>0)//Sprawdzam czy zwrócona wartość argumentu jest niepusta
        {
          //Sprawdzam czy rzutowana do int-a wartość argumentu jest w zakresie 0-255.
          if(pwm.toInt()>=0 && pwm.toInt()<=255)
            pwm_wentylatora = pwm.toInt(); //Modyfikuję PWM 
        }
      }

      if(eth.checkArg(c, argv, "cmd", "resetpwm")==0)
        pwm_wentylatora = 0;

      // Ta funkcja generuje dynamiczną odpowiedź HTTP,
      // zgodną z definicją funkcji webPage() umieszczoną na końcu pliku.
      eth.httpServerReply(eth.webPage());
    }else{
      // Ta funkcja generuje statyczną odpowiedź HTTP - 401 Unauthorized
      // gdy "secretKey" jest niezgodne lub gdy go nie ma. 
      eth.staticHttpServerReply(HTTP401);
    }
  }
}

// Funkcja webPage służy do zdefiniowania bufora,
// który zostanie przesłany jako odpowiedź żądania HTTP.
// Modyfikuj tylko bfill.emit_p(...).
// Definicja tej funkcji powinna znaleźć się na końcu tego pliku,
// ponieważ musi mieć zasięg do deklaracji wszystkich używanych zmiennych globalnych.
word EtherDevice::webPage()
{
  // Ustawia offset w BufferFiller
  bfill = tcpOffset();

  // Wewnątrz PSTR(...) możesz używać następujących typów:
  //  $D = word data type
  //  $L = long data type
  //  $S = c string
  //  $F = progmem string
  //  $E = byte from the eeprom
  bfill.emit_p(
    PSTR(
      "$F"// Tego $F nie zmieniaj i nie usuwaj - to nagłówek odpowiedzi HTTP OK
      "$D|" 
      "$D" 
    ),
    HTTP200,// Tego HTTP200 nie zmieniaj i nie usuwaj - to nagłówek odpowiedzi HTTP OK
    temperatura,
    pwm_wentylatora
  );

  // Zwraca aktualny offset BufferFiller
  return bfill.position();
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

* Autor: Cezary Wernik

* Szczecin 2018 Polska

// Dołączenie wrap-a biblioteki EtherCard

#include "EtherDevice.h"

// Adres MAC urządzenia,

// w tym miejscu wstaw unikalny adres.

static byte mac[] = {0x74, 0x69, 0x69, 0x2D, 0x30, 0x31 };

// Tajny klucz do odczytu "telemetrii" i wykonywania akcji,

// w tym miejscu wstaw tajny klucz.

String secretKey = "7rHvCGd59C";

// Deklaracja ilu maksymalnie argumentów urządzenie powinno się spodziewać.

// Przykład żądania HTTP:

// http: //192.168.0.10/?arg_1=val_1&arg_2=val_2& ... &arg_C=val_C

// W tym miejscu wpisz ile wynosi spodziewane C.

static const int argc=3;

// Argumentów wejściowych może przyjść c <= C;

// Obsługa tego przykładu:

// Wpisanie w przeglądarce samego adresu IP powinno zwrócić

// komunikat 401 Unauthorized.

// Dopiero wpisanie adres IP opatrzonego w secretKey

// http ://192.168.0.10/?secretKey=7rHvCGd59C

// wyświetli stan temperatury odczytanej z pinu analogowego A0 i aktualnie ustawione PWM wentylatora.

// Natomiast dopisanie do adresu cmd=changepwm i pwm=255 ustawi zmienną pwm_wentylatora na 255.

// http ://192.168.0.10/?secretKey=7rHvCGd59C&cmd=changepwm&pwm=255

// Można też wyzerować pwm_wentylatora dopisując cmd=resetpwm

// http ://192.168.0.10/?secretKey=7rHvCGd59C&cmd=resetpwm

// wyzeruje to zmienną pwm_wentylatora.

// Deklaracja przestrzeni na wejściowe argumenty.

arg argv[argc];

// Struktura argumentów wygląda następująco:

// struct arg

// {

// String argName;

// String argValue;

// };

// Zmienne do obsługi czujnika.

int temperatura = 0;

int pwm_wentylatora = 0;

void setup()

{

Serial.begin( 57600 );

Serial.println( "Arduino ethernet device" );

// Dopóki urządzenie ethernet nie zainicjuje się po DHCP,

// wstrzymaj dalsze wykonywanie programu.

while( eth.init( mac, SS ) != 0 );

// Wyświetl w konsoli konfigurację IP uzyskaną z DHCP.

eth.ipconfig();

}

void loop()

{

// Pseudo odczyt temperatury.

temperatura = map(analogRead(A0),0,1023,0,100);

// Obsługa wentylatora w/g zmiennej pwm_wentylatora

... tu wyobraź sobie kod obsługi wentylatora :) ...

// Sprawdzenie przychodzących żądań,

// jeżeli są to zwraca ilość argumentów wejściowych.

int c = eth.getTask(argc, argv);

if(c>=0)

{

// Funkcja w warunku sprawdza czy w argumentach wejściowych

// jest argument o nazwie "secretKey", jeżeli jest to sprawdza czy

// zgodny ze zmienną secretKey zdefiniowaną na początku sketch-a.

if(eth.checkArg(c, argv, "secretKey", secretKey)==0)

{

// Opcjonalnie wypisuje w Serial argumenty wejściowe.

eth.printArg(c, argv);

// Metoda checkArg sprawdza czy argument o podanej nazwie "cmd" zawiera "changepwm"

if(eth.checkArg(c, argv, "cmd", "changepwm")==0)

{

// Funkcja getArg zwraca wartość argumentu wejściowego o podanej nazwie "pwm".

String pwm = eth.getArg(c, argv, "pwm");

if(pwm.length()>0)//Sprawdzam czy zwrócona wartość argumentu jest niepusta

{

//Sprawdzam czy rzutowana do int-a wartość argumentu jest w zakresie 0-255.

if(pwm.toInt()>=0 && pwm.toInt()<=255)

pwm_wentylatora = pwm.toInt(); //Modyfikuję PWM

}

if(eth.checkArg(c, argv, "cmd", "resetpwm")==0)

pwm_wentylatora = 0;

// Ta funkcja generuje dynamiczną odpowiedź HTTP,

// zgodną z definicją funkcji webPage() umieszczoną na końcu pliku.

eth.httpServerReply(eth.webPage());

}else{

// Ta funkcja generuje statyczną odpowiedź HTTP - 401 Unauthorized

// gdy "secretKey" jest niezgodne lub gdy go nie ma.

eth.staticHttpServerReply(HTTP401);

}

// Funkcja webPage służy do zdefiniowania bufora,

// który zostanie przesłany jako odpowiedź żądania HTTP.

// Modyfikuj tylko bfill.emit_p(...).

// Definicja tej funkcji powinna znaleźć się na końcu tego pliku,

// ponieważ musi mieć zasięg do deklaracji wszystkich używanych zmiennych globalnych.

word EtherDevice::webPage()

{

// Ustawia offset w BufferFiller

bfill = tcpOffset();

// Wewnątrz PSTR(...) możesz używać następujących typów:

// $D = word data type

// $L = long data type

// $S = c string

// $F = progmem string

// $E = byte from the eeprom

bfill.emit_p(

PSTR(

"$F"// Tego $F nie zmieniaj i nie usuwaj - to nagłówek odpowiedzi HTTP OK

"$D|"

"$D"

HTTP200,// Tego HTTP200 nie zmieniaj i nie usuwaj - to nagłówek odpowiedzi HTTP OK

temperatura,

pwm_wentylatora

);

// Zwraca aktualny offset BufferFiller

return bfill.position();

}

2.3. Sketch bez komentarzy

/*
 * Autor: Cezary Wernik
 * Szczecin 2018 Polska 
 */
#include "EtherDevice.h"
static byte mac[] = {0x74, 0x69, 0x69, 0x2D, 0x30, 0x31 }; 
String secretKey = "7rHvCGd59C"; 
static const int argc=3;
arg argv[argc];

// Zmienne do obsługi czujnika.
int temperatura = 0;
int pwm_wentylatora = 0;

void setup()
{
  Serial.begin( 57600 );
  Serial.println( "Arduino ethernet device" );
  while( eth.init( mac, SS ) != 0 );
  eth.ipconfig();
}

void loop()
{
  // Pseudo odczyt temperatury.
  temperatura = map(analogRead(A0),0,1023,0,100);
  // Obsługa wentylatora w/g zmiennej pwm_wentylatora 
  /* 
    ... tu wyobraź sobie kod obsługi wentylatora :) ... 
  */
 
  int c = eth.getTask(argc, argv);  
  if(c>=0)
  {
    if(eth.checkArg(c, argv, "secretKey", secretKey)==0)
    {
      if(eth.checkArg(c, argv, "cmd", "changepwm")==0)
      {
        String pwm = eth.getArg(c, argv, "pwm");
        if(pwm.length()>0)
        {
          if(pwm.toInt()>=0 && pwm.toInt()<=255)
            pwm_wentylatora = pwm.toInt(); 
        }
      }

      if(eth.checkArg(c, argv, "cmd", "resetpwm")==0)
        pwm_wentylatora = 0;

      eth.httpServerReply(eth.webPage());
    }else{
      eth.staticHttpServerReply(HTTP401);
    }
  }
}

word EtherDevice::webPage()
{
  bfill = tcpOffset();
  bfill.emit_p(
    PSTR(
      "$F"
      "$D|" 
      "$D" 
    ),
    HTTP200,
    temperatura,
    pwm_wentylatora
  );
  return bfill.position();
}

* Autor: Cezary Wernik

* Szczecin 2018 Polska

#include "EtherDevice.h"

static byte mac[] = {0x74, 0x69, 0x69, 0x2D, 0x30, 0x31 };

String secretKey = "7rHvCGd59C";

static const int argc=3;

arg argv[argc];

// Zmienne do obsługi czujnika.

int temperatura = 0;

int pwm_wentylatora = 0;

void setup()

{

Serial.begin( 57600 );

Serial.println( "Arduino ethernet device" );

while( eth.init( mac, SS ) != 0 );

eth.ipconfig();

}

void loop()

{

// Pseudo odczyt temperatury.

temperatura = map(analogRead(A0),0,1023,0,100);

// Obsługa wentylatora w/g zmiennej pwm_wentylatora

... tu wyobraź sobie kod obsługi wentylatora :) ...

int c = eth.getTask(argc, argv);

if(c>=0)

{

if(eth.checkArg(c, argv, "secretKey", secretKey)==0)

{

if(eth.checkArg(c, argv, "cmd", "changepwm")==0)

{

String pwm = eth.getArg(c, argv, "pwm");

if(pwm.length()>0)

{

if(pwm.toInt()>=0 && pwm.toInt()<=255)

pwm_wentylatora = pwm.toInt();

}

if(eth.checkArg(c, argv, "cmd", "resetpwm")==0)

pwm_wentylatora = 0;

eth.httpServerReply(eth.webPage());

}else{

eth.staticHttpServerReply(HTTP401);

}

word EtherDevice::webPage()

{

bfill = tcpOffset();

bfill.emit_p(

PSTR(

"$F"

"$D|"

"$D"

HTTP200,

temperatura,

pwm_wentylatora

);

return bfill.position();

}

Jak widać sketch bez komentarzy jest już bardzo czytelny a zawiera logikę główną i obsługę ethernet.

3. Zalety/Wady

Do zalet należy:

ułatwiona obsługa modułu ethernet do poziomu “instant”;
przejrzystość kodu, w sketch-u można się skupić na obsłudze zadań/czujników;
gotowe parsowanie argumentów przychodzących w żądaniu;
kilka gotowych odpowiedzi (HTTP 401, 404, 405, 406) na błędnie wpisany w pasku adresu IP z argumentami.

Do wad należy:

zabezpieczenie secretKey jest na laików bo i tak wszystko po http leci plain-text, więc ktoś z Wireshark-iem od razu znajdzie klucz, ale jest to możliwe do załatania/usprawnienia;
jak na programowanie mikrokontrolera trochę za bardzo obiektowo;
z wielu metod HTTP obsłużone tylko część GET https://pl.wikipedia.org/wiki/Hypertext_Transfer_Protocol #Metody_HTTP;
waga sketch-a:
- podobne funkcjonalnie sketch-e z przykładów EtherCard zajmują średnio (na dzień dobry) około 30% pamięci programu i około 40% pamięci dynamicznej;
- sketch po owrapowaniu już jako EtherDevice zajmuje 38% pamięci programu i 48% pamięci dynamicznej.

4. Załączniki

Do wpisu załączam paczuszkę z sketch-em (.ino) i plikiem nagłówkowym (.h).

Pliki załączone do artykułu:

etherdevice.zip

Ocena: 5/5 (głosów: 5)

4 komentarzy do “Arduino ethernet device”

r.blaszczak 12 listopada 2018, godz. 21:58

Bardzo dokładny i ładny opis. Ocena 5*.
Odpowiedz
- Cezar Autor 12 listopada 2018, godz. 22:23
  
  Dziękuję :)
  Mimo małego projekciku, starałem się go dobrze opisać, aby każdy mógł zrozumieć, użycie moich dopisanych metod do biblioteki EtherCard.
  Odpowiedz
mielmar 2 stycznia 2019, godz. 23:42

Sam zrobiłem kilka projektów z ENC28J60 i mimo że działają już ponad dwa lata – to nie jest to najlepszy wybór – są ciągłe problemy ze stabilnością modułu. Ostatnio wypróbowałem USR-ES1 na chipie W5500 i bibliotekę Ethernet3 https://github.com/sstaub/Ethernet3 – jest to dużo lepsze rozwiązanie niż ENC28J60.
Odpowiedz
yawamdam 14 lipca 2019, godz. 21:54

Witam,
jak osiągnąć “narastanie” / “opadanie” PWM na sztyno o okresie np 1 sek ? lub – co było by najmilsze, jako parametr, coś na wzór z kit AVT1825 (niestety to nie jest superkonstrukcja, wiesza się)
Odpowiedz

Poszukujesz fachowców od prefabrykacji rozdzielnic elektrycznych? Wybierz firmę Auster!

Jak kłaść płytki podłogowe? 5 praktycznych wskazówek

Zasilanie, moc, moment obrotowy… Sprawdź, co musisz wiedzieć, wybierając wkrętarkę

Druk 3D w służbie zwierzakom: niezwykłe możliwości dla majsterkowiczów i miłośników zwierząt

Wieszak na klucze kategorii 5e

Frezarka CNC – Profesjonalne sterowanie amatorskimi maszynami. (LPT)

Wzmacniacz lampowy DIY na ECL86 EM84

Sony wireless stereo headset w nowym wydaniu

AUDIOREAKTYWACJA czyli REMONT MAŁYCH TONSILI

Druk 3D w służbie zwierzakom: niezwykłe możliwości dla majsterkowiczów i miłośników zwierząt

Koparka – zabawka dla dziecka

Jak zrobić Skuter Elektryczny (350W dla dziecka)Z niezłym Kopem!

Wieszak na klucze kategorii 5e

Psi zaprzęg dla dziecka.

Lampy ze starych megafonów

Frezarka CNC – Profesjonalne sterowanie amatorskimi maszynami. (LPT)

Jak Zrobić Teleskop. Amatorski teleskop dla początkujących. Teleskop Newtona Zrobiony w Domu.

Cloud for my Sunshine | Lampka dla dziecka DIY

Stanowisko do gier samochodowych na bazie arduino.

Zabezpieczenie gniazda 230V za pomoca Arduino Nano

Arduino – współpraca z projektorami NEC, EPSON

Smart listwa zasilająca

Asystent Google na Raspberry Pi

Czujnik Parkowania

Budowa zgrzewarki Li-ion

Smart listwa zasilająca

Disc VUmetr by hetm4n

Smart listwa zasilająca

Inteligentna listwa zasilająca – IoT

Raspberry Pi instalacja Domoticza – systemu inteligentnego domu

Supla.org Termometr z podwójnym pomiarem

SUPLA, Nodemcu v3, cztery gniazdka plus DHT22 plus sterowanie głosem (Google Home)

Monitoring temperatury przez internet: WEMOS D1 (esp8266) + SUPLA

Rejestrowanie wskazań liczników wody, gazu i prądu – opis trzech sposobów zliczania impulsów

Arduino – współpraca z projektorami NEC, EPSON

Tenso 2019 – czyli taka waga z Arduino, loggerem SD i wyświetlaczem na Androidzie

Stanowisko do gier samochodowych na bazie arduino.

Zasilacz uniwersalny 1,2V do 24V o mocy 120 W

Budowa zgrzewarki Li-ion

Black&Decker 18V Li-ion – wymiana ogniw

Telegraf

ZASILACZ POMOCNICZY

Renowacja zniszczonego parapetu- czyli mała rewolucja tuż przed remontem

Odbudowa zniszczonego stołu barowego

Ratowanie starego zniszczonego mebla, czyli renowacja DIY

Otis’owe legowisko. Legowisko dla psa

Ramka z mosiężnymi wstawkami

Biurko z rurek i desek paletowych

Krzesełko dla dziecka. Jak odnowić

Samolot z drewna – prosty model z patyczków do lodów.

Mikołaj z orzecha

Niebanalny Regał Z Drzewem

Otis’owe legowisko. Legowisko dla psa

Tablica „ORGANIZER”

Lampka nocna. Rakieta Saturn V

DaVinci PRO – Tuning Sprzętu

Łatwy do druku uchwyt na komputer rowerowy.

Drukarka Prusa i3 MK3 – rozwiązanie problemu z ekstruderem