czwartek, 4 czerwca 2020

[39] Arduino - Serwer oraz Klient TCP na ENC28J60

W tym poście chciałbym opisać sposób komunikacji pomiędzy klientem a serwerem TCP.

Podłączenie:

W tym przypadku wykorzystałem gotową nakładkę na Arduino Nano, która pozwala w bardzo łatwy sposób podłączyć ze sobą te układy.


Poniżej podstawowy opis podłączenia:

  • Pin SS (CS) - D10
  • Pin MOSI (SI) - D11
  • Pin MISO (SO) - D12
  • Pin SCK - D13

Dodatkowo należy podłączyć zasilanie do 5V oraz GND. W przykładach wykorzystuje bibliotekę UIPEthernet, która domyślnie posiada przyporządkowanie pinów takie jak powyżej.

Przykłady autora biblioteki:


W celu sprawdzenia działania można wykorzystać przykłady udostępnione przez autora biblioteki. Poniżej zmodyfikowane wersje dla TCP Client oraz TCP Server:

TCP Klient:

  1. #include <UIPEthernet.h>
  2. #include "utility/logging.h"
  4. #define MACADDRESS 0x48,0x53,0x4B,0x03,0x55,0x05
  5. #define MYIPADDR 169,254,24,158
  6. #define MYIPMASK 255,255,255,0
  7. #define MYDNS 192,168,1,1
  8. #define MYGW 169,254,24,20
  9. #define LISTENPORT 1000
  11. EthernetClient client;
  12. unsigned long next;
  14. void PrintNetworkSettings()
  15. {
  16.   Serial.print("localIP: ");
  17.   Serial.println(Ethernet.localIP());
  18.   Serial.print("subnetMask: ");
  19.   Serial.println(Ethernet.subnetMask());
  20.   Serial.print("gatewayIP: ");
  21.   Serial.println(Ethernet.gatewayIP());
  22.   Serial.print("dnsServerIP: ");
  23.   Serial.println(Ethernet.dnsServerIP());
  24. }
  26. void setup() {
  27.   Serial.begin(115200);
  28.   Serial.print("Client start: ");
  29.   uint8_t mac[6] = {0x00,0x01,0x02,0x03,0x04,0x05};
  30.   Ethernet.begin(mac); //Configure IP address via DHCP
  31.   //Ethernet.begin(mac,myIP,myDNS,myGW,myMASK); //Without DHCP
  32.   PrintNetworkSettings();
  33. }
  35. void loop() {
  36.   if (((signed long)(millis() - next)) > 0)
  37.   {
  38.       next = millis() + 5000;
  39.       // replace hostname with name of machine running tcpserver.pl
  40.       // if (client.connect("server.local",5000))
  41.       if (client.connect(IPAddress(192,168,0,1),1000))
  42.       {
  43.           client.println(F("DATA from Client"));
  44.           int size;
  45.           while ((client.available()==0) && (millis()<next)) { }
  46.           while((size = client.available()) > 0)
  47.           {
  48.               uint8_t* msg = (uint8_t*)malloc(size+1);
  49.               memset(msg, 0, size+1);
  50.               size = client.read(msg,size);
  51.               free(msg);
  52.           }
  53.           //disconnect client
  54.           client.stop();
  55.       }
  56.       else
  57.       {
  58.       }
  59.   }
  60. }

TCP Server:

  1. #define MACADDRESS 0x00,0x01,0x02,0x03,0x04,0x05
  2. #define MYIPADDR 192,168,1,6
  3. #define MYIPMASK 255,255,255,0
  4. #define MYDNS 192,168,1,1
  5. #define MYGW 192,168,1,1
  6. #define LISTENPORT 1000
  7. #define UARTBAUD 115200
  9. #include <UIPEthernet.h>
  10. #include "utility/logging.h"
  12. EthernetServer server = EthernetServer(LISTENPORT);
  14. void PrintNetworkSettings()
  15. {
  16.   Serial.print("localIP: ");
  17.   Serial.println(Ethernet.localIP());
  18.   Serial.print("subnetMask: ");
  19.   Serial.println(Ethernet.subnetMask());
  20.   Serial.print("gatewayIP: ");
  21.   Serial.println(Ethernet.gatewayIP());
  22.   Serial.print("dnsServerIP: ");
  23.   Serial.println(Ethernet.dnsServerIP());
  24. }
  26. void setup() {
  27.   Serial.begin(UARTBAUD);
  28.   Serial.println("Start Server");
  29.   uint8_t mac[6] = {MACADDRESS};
  30.   /*
  31.   uint8_t myIP[4] = {MYIPADDR};
  32.   uint8_t myMASK[4] = {MYIPMASK};
  33.   uint8_t myDNS[4] = {MYDNS};
  34.   uint8_t myGW[4] = {MYGW};
  35.   Ethernet.begin(mac,myIP,myDNS,myGW,myMASK);
  36.   */
  37.   Ethernet.begin(mac);  //DHCP
  38.   PrintNetworkSettings();
  39.   server.begin();
  40. }
  42. void loop() {
  43.   size_t size;
  45.   if (EthernetClient client = server.available())
  46.   {
  47.       while((size = client.available()) > 0)
  48.       {
  49.           uint8_t* msg = (uint8_t*)malloc(size+1);
  50.           memset(msg, 0, size+1);
  51.           size = client.read(msg,size);
  52.           free(msg);
  53.       }
  54.       client.stop();
  55.     }
  56. }

Oby przypadki można zweryfikować pojedynczo np. przez użycie programu hercules.

Wersja pierwsza:


Po wciśnięciu przycisku klient lub serwer wysyłają informację o wciśnięciu przycisku. W zależności od tego gdzie dany przycisk został wciśnięty.

TCP Server:

  1. #include <UIPEthernet.h>
  2. //---------------------------------------
  3. /* Define protocol frame */
  4. #define START_ACK 0x01
  5. #define CONTOL_IN_OUT_FRAME 0x23
  6. #define KEEP_ALIVE_FRAME 0x45
  7. //-------------------------------------
  8. #define IN_1 2
  9. #define IN_2 3
  10. #define IN_3 4
  11. #define IN_4 5
  12. #define OUT_1 6
  13. #define OUT_2 7
  14. #define OUT_3 8
  15. #define OUT_4 9
  16. #define OUT_STATUS_DIODE 15
  17. //----------------------------------------
  18. #define MACADDRESS 0x48,0x53,0x4B,0x03,0x55,0x05
  19. #define MYIPADDR 169,254,24,158
  20. #define MYIPMASK 255,255,255,0
  21. #define MYDNS 192,168,1,1
  22. #define MYGW 169,254,24,20
  23. #define LISTENPORT 1000
  24. #define UARTBAUD 115200
  25. //----------------------------------------
  26. EthernetServer server = EthernetServer(LISTENPORT);
  28. uint16_t countConnection = 0;
  29. uint8_t sendFlag = 0;
  30. unsigned long time_now;
  32. int buttonPrevState1 = 0;
  33. int buttonPrevState2 = 0;
  34. int buttonPrevState3 = 0;
  35. int buttonPrevState4 = 0;
  37. void CheckBtnMonostable(int * buttonPrevState, int buttonState, uint8_t pinNumber)
  38. {
  39.     if (buttonState == LOW && *buttonPrevState == 0)
  40.     {
  41.       *buttonPrevState = 1;
  42.       Serial.print("Wcisniety: ");
  43.       Serial.println(pinNumber, DEC);
  44.       uint8_t buf[5] = {0x01, 0x02, 0x34, pinNumber, 0x01};
  45.       int val = server.write(buf, 5);
  46.     }
  47.     else if (buttonState == HIGH && *buttonPrevState == 1)
  48.     {
  49.       *buttonPrevState = 0;
  50.       Serial.print("Puszczony: ");
  51.       Serial.println(pinNumber, DEC);
  52.       uint8_t buf[5] = {0x01, 0x02, 0x34, pinNumber, 0x00};
  53.       int val = server.write(buf, 5);
  54.     }
  55. }
  57. void InitGpio(uint8_t gpioInOut)
  58. {
  59.   if(gpioInOut == 0) //Input
  60.   {
  61.     pinMode(IN_1, INPUT_PULLUP);
  62.     pinMode(IN_2, INPUT_PULLUP);
  63.     pinMode(IN_3, INPUT_PULLUP);
  64.     pinMode(IN_4, INPUT_PULLUP);
  65.   }
  66.   else if(gpioInOut == 1) //Output
  67.   {
  68.     pinMode(OUT_1, OUTPUT);
  69.     pinMode(OUT_2, OUTPUT);
  70.     pinMode(OUT_3, OUTPUT);
  71.     pinMode(OUT_4, OUTPUT);
  73.     digitalWrite(OUT_1, LOW);
  74.     digitalWrite(OUT_2, LOW);
  75.     digitalWrite(OUT_3, LOW);
  76.     digitalWrite(OUT_4, LOW);
  77.   }
  78. }
  80. void InitDiodeStatusGpio(void)
  81. {
  82.   pinMode(OUT_STATUS_DIODE, OUTPUT);
  83.   digitalWrite(OUT_STATUS_DIODE, LOW);
  84. }
  86. void SetPinStatus(uint8_t pinNumber, uint8_t pinState)
  87. {
  88.   /*
  89.      msg[3] pin number from 1 to 4
  90.      msg[4] pin state 0 is LOW, 1 is HIGH
  91.   */
  92.   digitalWrite((pinNumber + 5), pinState);
  93. }
  95. void PrintNetworkSettings()
  96. {
  97.   Serial.print("localIP: ");
  98.   Serial.println(Ethernet.localIP());
  99.   Serial.print("subnetMask: ");
  100.   Serial.println(Ethernet.subnetMask());
  101.   Serial.print("gatewayIP: ");
  102.   Serial.println(Ethernet.gatewayIP());
  103.   Serial.print("dnsServerIP: ");
  104.   Serial.println(Ethernet.dnsServerIP());
  105. }
  107. void setup() {
  108.   uint8_t mac[6] = {MACADDRESS};
  109.   uint8_t myIP[4] = {MYIPADDR};
  110.   uint8_t myMASK[4] = {MYIPMASK};
  111.   uint8_t myDNS[4] = {MYDNS};
  112.   uint8_t myGW[4] = {MYGW};
  113.   //------------------------------------
  114.   Serial.begin(115200);
  115.   Serial.println("Start");
  116.   //------------------------------------
  117.   InitGpio(0);
  118.   InitGpio(1);
  119.   InitDiodeStatusGpio();
  120.   //------------------------------------
  121.   Ethernet.begin(mac);
  122.   Serial.println("Ethernet.begin");
  123.   //Ethernet.begin(mac,myIP,myDNS,myGW,myMASK);
  124.   //Serial.println( "ServerBegin");
  126.   PrintNetworkSettings();
  127.   server.begin();
  128. }
  130. void loop()
  131. {
  132.   int buttonState1 = digitalRead(IN_1);
  133.   int buttonState2 = digitalRead(IN_2);
  134.   int buttonState3 = digitalRead(IN_3);
  135.   int buttonState4 = digitalRead(IN_4);
  137.   CheckBtnMonostable(&buttonPrevState1, buttonState1, 1);
  138.   CheckBtnMonostable(&buttonPrevState2, buttonState2, 2);
  139.   CheckBtnMonostable(&buttonPrevState3, buttonState3, 3);
  140.   CheckBtnMonostable(&buttonPrevState4, buttonState4, 4);
  142.   size_t size;
  143.   EthernetClient client = server.available();
  145.   if(client)
  146.   {
  147.       digitalWrite(OUT_STATUS_DIODE, HIGH);
  148.       time_now = millis();
  149.       countConnection = 0;
  150.       sendFlag = 0;
  151.      
  152.       while((size = client.available()) > 0)
  153.       {
  154.         uint8_t* msg = (uint8_t*)malloc(size+1);
  155.         memset(msg, 0, size+1);
  156.         size = client.read(msg,size);
  157.        
  158.         if(msg[0] == START_ACK)  /* Sprawdź czy bit startu*/
  159.         {
  160.           if(msg[2] == CONTOL_IN_OUT_FRAME) /* Ramka zmiany stanu wejscia wyjscia*/
  161.           {
  162.             if(msg[1] == 0x02)
  163.             {
  164.               SetPinStatus(msg[3], msg[4]);
  165.               client.write(msg,size);
  166.             }
  167.           }
  168.           else if(msg[2] == KEEP_ALIVE_FRAME)
  169.           {
  170.             countConnection = 0;
  171.             sendFlag = 0;
  172.             digitalWrite(OUT_STATUS_DIODE, HIGH);
  173.           }
  174.         }
  175.         else { client.write("Undefined",9); }
  176.         free(msg);
  177.       }
  178.   }
  180.   //Send Keep Alive Frame if no communication occurs
  181.   if(millis() - time_now > 5000){
  182.     time_now = millis();
  183.     if(sendFlag == 0)
  184.     {
  185.       uint8_t buf[5] = {0x01, 0x02, 0x45};
  186.       int val = server.write(buf, 3);
  187.       sendFlag = 1;
  188.     }
  189.    }
  191.    if(sendFlag == 1 && millis() - time_now > 2000)
  192.    {
  193.         time_now = millis();
  194.         countConnection = 0;
  195.         sendFlag = 0;
  196.         digitalWrite(OUT_STATUS_DIODE, LOW);
  197.    }
  198. }

TCP Klient:

  1. #include <UIPEthernet.h>
  2. //---------------------------------------
  3. /* Define protocol frame */
  4. #define START_ACK 0x01
  5. #define CONTROL_IN_OUT_FRAME 0x23
  6. #define BTN_SERVER_CLICK 0x34
  7. #define KEEP_ALIVE_FRAME 0x45
  8. //---------------------------------------
  9. /* Define pin numbers */
  10. #define IN_1 2
  11. #define IN_2 3
  12. #define IN_3 4
  13. #define IN_4 5
  14. #define OUT_1 6
  15. #define OUT_2 7
  16. #define OUT_3 8
  17. #define OUT_4 9
  18. #define OUT_SER_1 16
  19. #define OUT_SER_2 17
  20. #define OUT_SER_3 18
  21. #define OUT_SER_4 19
  22. #define OUT_STATUS_DIODE 15
  23. //---------------------------------------
  24. EthernetClient client;
  25. unsigned long time_now;
  26. uint16_t keepAliceMillisPeriod = 6000;
  27. //---------------------------------------
  28. int buttonPrevState1 = 0;
  29. int buttonPrevState2 = 0;
  30. int buttonPrevState3 = 0;
  31. int buttonPrevState4 = 0;
  32. //----------------------------------------------------------------
  33. void CheckBtnMonostable(int * buttonPrevState, int buttonState, uint8_t pinNumber)
  34. {
  35.     if (buttonState == LOW && *buttonPrevState == 0)
  36.     {
  37.       *buttonPrevState = 1;
  38.       uint8_t buf[5] = {0x01, 0x02, 0x23, pinNumber, 0x01};
  39.       int val = client.write(buf, 5);
  40.       Serial.println(val, DEC);
  41.     }
  42.     else if (buttonState == HIGH && *buttonPrevState == 1)
  43.     {
  44.       *buttonPrevState = 0;
  45.       uint8_t buf[5] = {0x01, 0x02, 0x23, pinNumber, 0x00};
  46.       int val = client.write(buf, 5);
  47.       Serial.println(val, DEC);
  48.     }
  49. }
  51. void CheckBtnBistable(int * buttonPrevState, int buttonState, uint8_t pinNumber)
  52. {
  53.    if (buttonState == LOW)
  54.    {
  55.      *buttonPrevState = 1;
  56.      uint8_t buf[5] = {0x01, 0x02, 0x23, pinNumber, 0x01};
  57.      int val = client.write(buf, 5);
  58.      Serial.println(val, DEC);
  59.    }
  60. }
  62. void SetPinStatus(uint8_t pinNumber, uint8_t pinState)
  63. {
  64.   /*
  65.      msg[3] pin number from 1 to 4
  66.      msg[4] pin state 0 is LOW, 1 is HIGH
  67.   */
  68.   digitalWrite((pinNumber + 5), pinState);
  69. }
  71. void DefineInputOutput_SetDefaultState(void)
  72. {
  73.   pinMode(IN_1, INPUT_PULLUP);
  74.   pinMode(IN_2, INPUT_PULLUP);
  75.   pinMode(IN_3, INPUT_PULLUP);
  76.   pinMode(IN_4, INPUT_PULLUP);
  78.   pinMode(OUT_1, OUTPUT);
  79.   pinMode(OUT_2, OUTPUT);
  80.   pinMode(OUT_3, OUTPUT);
  81.   pinMode(OUT_4, OUTPUT);
  83.   digitalWrite(OUT_1, LOW);
  84.   digitalWrite(OUT_2, LOW);
  85.   digitalWrite(OUT_3, LOW);
  86.   digitalWrite(OUT_4, LOW);
  88.   pinMode(OUT_SER_1, OUTPUT);
  89.   pinMode(OUT_SER_2, OUTPUT);
  90.   pinMode(OUT_SER_3, OUTPUT);
  91.   pinMode(OUT_SER_4, OUTPUT);
  93.   digitalWrite(OUT_SER_1, HIGH);
  94.   digitalWrite(OUT_SER_2, HIGH);
  95.   digitalWrite(OUT_SER_3, HIGH);
  96.   digitalWrite(OUT_SER_4, HIGH);
  98.   pinMode(OUT_STATUS_DIODE, OUTPUT);
  99.   digitalWrite(OUT_STATUS_DIODE, LOW);
  100. }
  101. //----------------------------------------------------------------
  102. void setup()
  103. {
  104.   uint8_t mac[6] = {0x00,0x01,0x02,0x03,0x04,0x05};
  106.   Serial.begin(115200);
  107.   Serial.println("Client start");
  108.   DefineInputOutput_SetDefaultState();
  110.   Ethernet.begin(mac); //Configure IP address via DHCP
  111. }
  113. void loop() {
  114.   //-------------------------------------------
  115.   int buttonState1 = digitalRead(IN_1);
  116.   int buttonState2 = digitalRead(IN_2);
  117.   int buttonState3 = digitalRead(IN_3);
  118.   int buttonState4 = digitalRead(IN_4);
  119.   //-------------------------------------------
  120.   if(!client.connected())
  121.   {
  122.     Serial.println("123");
  123.     digitalWrite(OUT_STATUS_DIODE, LOW);
  124.     client.connect(IPAddress(150,153,100,92),1000);  
  125.   }
  127.   if (client.connected())
  128.   {
  129.     CheckBtnMonostable(&buttonPrevState1, buttonState1, 1);
  130.     CheckBtnMonostable(&buttonPrevState2, buttonState2, 2);
  131.     CheckBtnMonostable(&buttonPrevState3, buttonState3, 3);
  132.     CheckBtnMonostable(&buttonPrevState4, buttonState4, 4);
  134.     int size;
  136.     while((size = client.available()) > 0) {
  137.        uint8_t* msg = (uint8_t*)malloc(size+1);
  138.        memset(msg, 0, size+1);
  139.        size = client.read(msg,size);
  140.        time_now = millis();
  141.        
  142.        if(msg[0] == START_ACK)  /* Sprawdź czy bit startu*/
  143.        {
  144.           if(msg[2] == CONTROL_IN_OUT_FRAME) /* Ramka zmiany stanu wejscia wyjscia*/
  145.           {
  146.             if(msg[1] == 0x02)
  147.             {
  148.               Serial.println("Client zmiana");
  149.               SetPinStatus(msg[3], msg[4]);
  150.               digitalWrite(OUT_STATUS_DIODE, HIGH);
  151.             }
  152.           }
  153.           else if(msg[2] == BTN_SERVER_CLICK)
  154.           {
  155.             digitalWrite((msg[3] + 15), !msg[4]);
  156.           }
  157.           else if(msg[2] == KEEP_ALIVE_FRAME)
  158.           {
  159.             uint8_t buf[5] = {0x01, 0x02, 0x45};
  160.            
  161.             client.write(buf, 3);
  162.             time_now = millis();
  163.             digitalWrite(OUT_STATUS_DIODE, HIGH);
  164.           }
  165.         }
  166.         else {
  167.           Serial.println("Unknown frame");
  168.         }
  169.        free(msg);
  170.      }
  171.    }
  172.    else { }
  174.    if(millis() - time_now > keepAliceMillisPeriod){
  175.       time_now = millis();
  176.       digitalWrite(OUT_STATUS_DIODE, LOW);
  177.       client.stop();
  178.       Serial.println("Con active");
  179.    }
  180. }

Wersja druga:


W tym przykładzie serwer odpytuje dwóch klientów o stan przycisków jak i o stan wyjść. Reakcja nie jest tak szybka jak w przypadku pierwszego przykładu. Natomiast zapewniona jest większa niezawodność przez ciągłą kontrolę i sprawdzanie stanu wejść oraz wyjść. 

Serwer wysyła informację najpierw do jednego a potem do drugiego klienta aby wykonał akcję np. otwarcie drzwi itp itd. Po przesłaniu zapytania do pierwszego urządzenia wysyła taką samą informację do drugiego. Gdy on również nie wykona żadnej akcji to następuje ponowne zaalarmowanie klienta 1.

Konfiguracja dla obu programów jest zapisana w wewnętrznej pamięci EEPROM. Dzięki temu po wysłaniu zmiany do programu, za pomocą odpowiedniej ramki, można układ dowolnie konfigurować.

Programy z tej części posta można pobrać z dysku Google pod tym linkiem. Głównym powodem jest ich dosyć duża objętość, która utrudnia umieszczenie ich bezpośrednio w poście. 
Autor: o
Etykiety: , ,