poniedziałek, 15 lipca 2019

[4] ESP32 - Konwerter Wifi UART

W tym poście chciałbym przedstawić zmodyfikowany projekt konwertera UART na WIFI jako TCP Serwer.

Znalezione obrazy dla zapytania arduino esp32
[Źródło: http://paulobrien.co.nz/2017/03/16/esp32-programming-with-arduino-on-windows/]

Oryginalny projekt na którym opierałem tą modyfikację można pobrać z serwisu Github od użytkownika AlphaLima.

Program:


Na samym początku przetestuję samą komunikację po RS485:

  1. #define RXD2  16
  2. #define TXD2  17
  3. #define RDE   26
  4. #define TXE   27
  6. void setup() {
  7.   Serial.begin(115200);
  9.   pinMode(RDE, OUTPUT);
  10.   pinMode(TXE, OUTPUT);
  12.   delay(20);
  14.   digitalWrite(26, HIGH);
  15.   digitalWrite(27, HIGH);
  17.   delay(5);
  19.   Serial2.begin(115200, SERIAL_8N1, RXD2, TXD2);
  20.   Serial.println("Test Serial Send");
  21.   Serial2.println("Test Serial2 Send");
  23.   delay(10);
  24.    
  25.   digitalWrite(26, LOW);
  26.   digitalWrite(27, LOW);
  27. }
  29. void loop() {
  30.   while (Serial2.available()) {
  31.     Serial.print(char(Serial2.read()));
  32.   }
  34.   while (Serial.available()) {
  35.     digitalWrite(26, HIGH);
  36.     digitalWrite(27, HIGH);
  37.     delay(2);
  38.     Serial2.print(char(Serial.read()));
  39.     delay(2);
  40.     digitalWrite(26, LOW);
  41.     digitalWrite(27, LOW);
  42.     delay(2);
  43.   }
  44. }

Wynik działania programu powinien przesyłać dane pomiędzy UART2 a UART0. Dane przesłane przez UART0 przekazywane są na UART2, dane nadane na UART2 są przesyłane na UART0.

Dodatkowo posiadany prze zemnie konwerter jest 5V. Co oznaczało konieczność zastosowania konwertera poziomów logicznych z 3V3 na 5V. Ponieważ ESP32 akceptuje i operuje na napięciach 3V3.

Poniżej znajduje się projekt podstawowy pozwalający na podłączenie do sieci zdefiniowanej w programie:

  1. //-------------------------------------------------------------
  2. #include "config.h"
  3. #include <esp_wifi.h>
  4. #include <WiFi.h>
  5. #include <WiFiClient.h>
  6. //-------------------------------------------------------------
  7. #ifdef OTA_HANDLER
  8. #include <ArduinoOTA.h>
  9. #endif // OTA_HANDLER
  10. //-------------------------------------------------------------
  11. HardwareSerial* COM[NUM_COM] = {&Serial, &Serial1};
  12. //-------------------------------------------------------------
  13. WiFiServer server_0(SERIAL0_TCP_PORT);
  14. WiFiServer *server[NUM_COM]={&server_0};
  15. WiFiClient TCPClient[NUM_COM][1];
  16. //-------------------------------------------------------------
  17. uint8_t buf1[NUM_COM][bufferSize];
  18. uint16_t i1[NUM_COM]={0};
  19. uint8_t buf2[NUM_COM][bufferSize];
  20. uint16_t i2[NUM_COM]={0};
  21. //-------------------------------------------------------------
  22. void setup() {
  23.   delay(500);
  24.   Start_Uart_0();
  25.   Start_Uart_1();
  26.   EnableWifiStationMode();
  27.   WifiStart();
  28.   ArduinoOta_Setup();
  29.   EnableAndSetDefaultRS485Pins();
  30. }
  32. void loop()
  33. {
  34.   ArduinoOTA_Handle_Loop();
  35.   ClientConnection_Loop();
  36.   WriteRS485Data();
  37. }
  38. //------------------------------------------------------
  39. static void SetRS485ControlPinsDirection()
  40. {
  41.   #ifdef RS485_ENABLE
  42.   pinMode(RE_PIN, OUTPUT);
  43.   pinMode(DE_PIN, OUTPUT);
  44.   #endif
  45. }
  47. static void SetRS485PinToSendData()
  48. {
  49.   #ifdef RS485_ENABLE
  50.   digitalWrite(RE_PIN, HIGH);
  51.   digitalWrite(DE_PIN, HIGH);
  52.   #endif
  53. }
  55. static void SetRS485PinToReceiveData()
  56. {
  57.   #ifdef RS485_ENABLE
  58.   digitalWrite(RE_PIN, LOW);
  59.   digitalWrite(DE_PIN, LOW);
  60.   #endif
  61. }
  62. static void Start_Uart_0(void)
  63. {
  64.   COM[0]->begin(UART_BAUD0, SERIAL_PARAM0, SERIAL0_RXPIN, SERIAL0_TXPIN);
  65. }
  67. static void Start_Uart_1(void)
  68. {
  69.   COM[1]->begin(UART_BAUD1, SERIAL_PARAM1, SERIAL1_RXPIN, SERIAL1_TXPIN);
  70. }
  71. //------------------------------------------------------
  72. //Initialization functions
  73. static void EnableAndSetDefaultRS485Pins(void)
  74. {
  75.   #ifdef RS485_ENABLE
  76.   SetRS485ControlPinsDirection();
  77.   delay(5);
  78.   SetRS485PinToReceiveData();
  79.   delay(3);
  80.   #endif
  81. }
  83. static void EnableWifiStationMode(void)
  84. {
  85.   if(debug) COM[DEBUG_COM]->println("Open ESP Station mode Test Project v1.0");
  86.   WiFi.mode(WIFI_STA);
  87.   WiFi.begin(ssid, pw);//ssidArray, passwordArray);
  88.   if(debug) { COM[DEBUG_COM]->print("try to Connect to Wireless network: "); }
  89.   if(debug) { COM[DEBUG_COM]->println(ssid); }
  90.   while (WiFi.status() != WL_CONNECTED) {
  91.     delay(500);
  92.     if(debug) COM[DEBUG_COM]->print(".");
  93.   }
  94.   if(debug) COM[DEBUG_COM]->println("\nWiFi connected");
  95. }
  97. static void WifiStart()
  98. {
  99.   if(debug) COM[DEBUG_COM]->println("Starting TCP Server 1");
  100.   server[0]->begin(); // start TCP server
  101.   server[0]->setNoDelay(true);
  102. }
  104. static void ArduinoOta_Setup()
  105. {
  106.   #ifdef OTA_HANDLER
  107.   ArduinoOTA
  108.     .onStart([]() {
  109.       String type;
  110.       if (ArduinoOTA.getCommand() == U_FLASH)
  111.         type = "sketch";
  112.       else // U_SPIFFS
  113.         type = "filesystem";
  114.       // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
  115.       Serial.println("Start updating " + type);
  116.     })
  117.     .onEnd([]() {
  118.       Serial.println("\nEnd");
  119.     })
  120.     .onProgress([](unsigned int progress, unsigned int total) {
  121.       Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
  122.     })
  123.     .onError([](ota_error_t error) {
  124.       Serial.printf("Error[%u]: ", error);
  125.       if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
  126.       else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
  127.       else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
  128.       else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
  129.       else if (error == OTA_END_ERROR) Serial.println("End Failed");
  130.     });
  131.   // if DNSServer is started with "*" for domain name, it will reply with
  132.   // provided IP to all DNS reques
  133.   ArduinoOTA.begin();
  134.   #endif // OTA_HANDLER
  135. }
  136. //------------------------------------------------------
  137. static void ArduinoOTA_Handle_Loop(void)
  138. {
  139.   #ifdef OTA_HANDLER
  140.   ArduinoOTA.handle();
  141.   #endif // OTA_HANDLER
  142. }
  144. static void ClientConnection_Loop()
  145. {
  146.   if(server[0]->hasClient())
  147.   {
  148.       if (!TCPClient[0][0] || !TCPClient[0][0].connected())
  149.       {
  150.         if(TCPClient[0][0])
  151.         {
  152.           TCPClient[0][0].stop();
  153.         }
  154.         TCPClient[0][0] = server[0]->available();
  155.        
  156.         if(debug) COM[DEBUG_COM]->print("New client for COM");
  157.         if(debug) COM[DEBUG_COM]->print(0);
  158.         if(debug) COM[DEBUG_COM]->println(0);
  159.        }
  160.     //no free/disconnected spot so reject
  161.     WiFiClient TmpserverClient = server[0]->available();
  162.     TmpserverClient.stop();
  163.   }
  164. }
  166. static void WriteRS485Data(void)
  167. {
  168.     if(COM[1] != NULL)        
  169.   {        
  170.       if(TCPClient[0][0])
  171.       {
  172.         while(TCPClient[0][0].available())
  173.         {
  174.           buf1[1][i1[1]] = TCPClient[0][0].read(); // read char from client (LK8000 app)
  175.           if(i1[1]<bufferSize-1)
  176.           {
  177.             i1[1]++;
  178.           }
  179.         }
  181.         if(i1[1] != 0x00)
  182.         {
  183.           SetRS485PinToSendData();
  184.           delay(5);
  185.           COM[1]->write(buf1[1], i1[1]); // now send to UART(num):
  186.           delay(5);
  187.           SetRS485PinToReceiveData();
  188.           i1[1] = 0;
  189.         }
  190.       }
  191.    
  192.       if(COM[1]->available())
  193.       {
  194.         while(COM[1]->available())
  195.         {  
  196.           buf2[1][i2[1]] = COM[1]->read(); // read char from UART(num)
  197.           if(i2[1]<bufferSize-1)
  198.           {
  199.             i2[1]++;
  200.           }
  201.         }
  202.      
  203.         if(TCPClient[0][0])  
  204.         {              
  205.           TCPClient[0][0].write(buf2[1], i2[1]);
  206.         }
  207.         i2[1] = 0;
  208.       }
  209.    }
  210. }

Powyższy program pobiera i przesyłane odebrane ramki danych pomiędzy portem 8880 TCP Serwer a RS485. Dodatkowo umieszczona jest w nim obsługa ArduinoOta tak aby można było wgrać program bez konieczności podłączania urządzenia do komputera.

Kolejnym elementem jest przesyłanie ustawień sieciowych tak aby można było przełączyć sieć wifi bez konieczności przeprogramowania urządzenia. Tutaj można rozwiązać problem na dwa sposoby.
Pierwszy z nich to wpisywanie danych przez UART do układu gdzie w ramce podawana jest nazwa sieci oraz hasło. Drugi sposób polega na uruchomieniu ESP jako AP po nim wyświetlana jest strona internetowa lub przez program jako TCP Serwer. Po połączeniu wprowadza się dane na stronie lub jako klient podłączony do serwera TCP.

Poniżej przedstawię rozwiązanie opierające się na ustawieniu parametrów przez port UART0. Uruchomienie wprowadzania ustawień następuje przez zwarcie pinu 18 do masy i zresetowaniu konwertera.

Zacznijmy od ustawiania parametrów za pomocą ramki danych. Przykładowy format ramki:

Ramka służąca do ustawienia SSID sieci:
  • Bajt Startu - 0x01
  • Kod Rozkazu - 0xB6
  • Dlugość SSID - od 1 do 255
  • SSID[Długość SSID] - bajty w kodzie ASCII zawierające nazwę sieci z którą zamierzamy się połączyć.

Ramka służąca do ustawienia hasła sieci:
  • Bajt Startu - 0x01
  • Kod Rozkazu - 0xA5
  • Dlugość hasła - od 1 do 255
  • Hasło[Długość hasła] - bajty w kodzie ASCII z hasłem do sieci

Podobnie można wykonać inne rozkazy. Do powyższych rozkazów dołożyłem jeszcze następujące ustawienia:
  • wybór portu dla serwera - 0xD8;
  • wybór prędkości dla RS485 - 0xE7;

Odpowiedzią na powyższe funkcję będzie retransmisja otrzymanej ramki danych tak aby ewentualny program ustawiający parametry mógł zweryfikować poprawność nadawanych i odebranych danych.

Poniżej znajduje się cały projekt odpowiadający za pełną obsługę powyższego konwertera:

  1. //ESP32 UART -> TCP Server Converter V1.0
  2. //-------------------------------------------------------------
  3. #include "config.h"
  4. #include <esp_wifi.h>
  5. #include <WiFi.h>
  6. #include <WiFiClient.h>
  7. #include <Preferences.h>
  8. //-------------------------------------------------------------
  9. #ifdef OTA_HANDLER
  10. #include <ArduinoOTA.h>
  11. #endif // OTA_HANDLER
  12. //-------------------------------------------------------------
  13. HardwareSerial* COM[NUM_COM] = {&Serial, &Serial1};
  14. //-------------------------------------------------------------
  15. String wifiSSID;
  16. String wifiPassword;
  17. uint32_t Baudrate_RS485;
  18. uint32_t ConnectionPort;
  19. //-------------------------------------------------------------
  20. WiFiServer server_0(SERIAL0_TCP_PORT);
  21. WiFiServer *server[NUM_COM]={&server_0};
  22. WiFiClient TCPClient[NUM_COM][1];
  23. Preferences preferences;      /* For NVS with contains SSID and Password*/
  24. //-------------------------------------------------------------
  25. uint8_t buf1[NUM_COM][bufferSize];
  26. uint16_t i1[NUM_COM]={0};
  27. uint8_t buf2[NUM_COM][bufferSize];
  28. uint16_t i2[NUM_COM]={0};
  29. //-------------------------------------------------------------
  30. uint8_t specialSettingProgramFlag = 0;
  31. //-------------------------------------------------------------
  32. void setup() {
  33.   delay(300);
  34.   EnableTestWriteSettingsPin();
  35.   delay(200);
  37.   if(digitalRead(WRITE_SETTINGS_PIN_NUM) == LOW)    //Start special program with setting network/rs485 parameters
  38.   {
  39.     Start_Uart_0();
  40.     NonVolatileStorageRead();
  41.     if(debug) COM[DEBUG_COM]->println(wifiSSID);
  42.     if(debug) COM[DEBUG_COM]->println(wifiPassword);
  43.     NonVolatileStorageReadPort();
  44.     NonVolatileStorageReadBaudrate();
  45.     Serial.println(ConnectionPort,HEX);
  46.     Serial.println(Baudrate_RS485,HEX);
  47.    
  48.     specialSettingProgramFlag = 1;
  49.   }
  50.   else                          //Start normal program execution
  51.   {
  52.     Start_Uart_0();
  54.     NonVolatileStorageRead();
  55.     if(debug) COM[DEBUG_COM]->println(wifiSSID.c_str());
  56.     if(debug) COM[DEBUG_COM]->println(wifiPassword.c_str());
  57.    
  58.     NonVolatileStorageReadPort();
  59.     NonVolatileStorageReadBaudrate();
  60.     if(debug) COM[DEBUG_COM]->println(ConnectionPort,HEX);
  61.     if(debug) COM[DEBUG_COM]->println(Baudrate_RS485,HEX);
  62.    
  63.     Start_Uart_1();
  65.     EnableWifiStationMode();
  66.     WifiStart();
  67.     ArduinoOta_Setup();
  68.     EnableAndSetDefaultRS485Pins();
  69.   }
  70. }
  72. void loop()
  73. {
  74.   if(specialSettingProgramFlag == 1)    //Special program for settings
  75.   {
  76.     SetParametersFrameAnalyse();
  77.   }
  78.   else                                  //Standard conversion program
  79.   {
  80.     ArduinoOTA_Handle_Loop();
  81.     ClientConnection_Loop();
  82.     WriteRS485Data();  
  83.   }
  84. }
  85. //------------------------------------------------------
  86. static void Start_Uart_0(void)
  87. {
  88.   COM[0]->begin(UART_BAUD0, SERIAL_PARAM0, SERIAL0_RXPIN, SERIAL0_TXPIN);
  89. }
  91. static void Start_Uart_1(void)
  92. {
  93.   COM[1]->begin(SelectBaudrate((uint8_t)Baudrate_RS485),
  94.               SERIAL_PARAM2,
  95.               SERIAL2_RXPIN,
  96.               SERIAL2_TXPIN);
  97. }
  98. //------------------------------------------------------
  99. //Initialization functions
  100. void EnableAndSetDefaultRS485Pins(void)
  101. {
  102.   #ifdef RS485_ENABLE
  103.   SetRS485ControlPinsDirection();
  104.   delay(5);
  105.   SetRS485PinToReceiveData();
  106.   delay(3);
  107.   #endif
  108. }
  110. void SetRS485ControlPinsDirection()
  111. {
  112.   #ifdef RS485_ENABLE
  113.   pinMode(RE_PIN, OUTPUT);
  114.   pinMode(DE_PIN, OUTPUT);
  115.   #endif
  116. }
  118. static void SetRS485PinToSendData()
  119. {
  120.   #ifdef RS485_ENABLE
  121.   digitalWrite(RE_PIN, HIGH);
  122.   digitalWrite(DE_PIN, HIGH);
  123.   #endif
  124. }
  126. static void SetRS485PinToReceiveData()
  127. {
  128.   #ifdef RS485_ENABLE
  129.   digitalWrite(RE_PIN, LOW);
  130.   digitalWrite(DE_PIN, LOW);
  131.   #endif
  132. }
  134. void EnableTestWriteSettingsPin(void)
  135. {
  136.   pinMode(18, INPUT_PULLUP);
  137. }
  139. static void EnableWifiStationMode(void)
  140. {
  141.   if(debug) COM[DEBUG_COM]->println("Open ESP Station mode Test Project v1.0");
  143.   WiFi.mode(WIFI_STA);
  144.   WiFi.begin(wifiSSID.c_str(), wifiPassword.c_str());//ssidArray, passwordArray);
  146.   if(debug) { COM[DEBUG_COM]->print("try to Connect to Wireless network: "); }
  147.   if(debug) { COM[DEBUG_COM]->println(wifiSSID); }
  149.   while (WiFi.status() != WL_CONNECTED) {
  150.     delay(500);
  151.     if(debug) COM[DEBUG_COM]->print(".");
  152.   }
  153.   if(debug) COM[DEBUG_COM]->println("\nWiFi connected");
  154. }
  156. static void WifiStart()
  157. {
  158.   if(debug) COM[DEBUG_COM]->println("Starting TCP Server 1");
  159.    
  160.   if(ConnectionPort == 0x00){ server[0]->begin(); }
  161.   else { server[0]->begin(ConnectionPort); }
  163.   server[0]->begin(ConnectionPort); // start TCP server
  164.   server[0]->setNoDelay(true);
  165. }
  167. static void ArduinoOta_Setup()
  168. {
  169.   #ifdef OTA_HANDLER
  170.   ArduinoOTA
  171.     .onStart([]() {
  172.       String type;
  173.       if (ArduinoOTA.getCommand() == U_FLASH)
  174.         type = "sketch";
  175.       else // U_SPIFFS
  176.         type = "filesystem";
  177.       // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
  178.       Serial.println("Start updating " + type);
  179.     })
  180.     .onEnd([]() {
  181.       Serial.println("\nEnd");
  182.     })
  183.     .onProgress([](unsigned int progress, unsigned int total) {
  184.       Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
  185.     })
  186.     .onError([](ota_error_t error) {
  187.       Serial.printf("Error[%u]: ", error);
  188.       if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
  189.       else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
  190.       else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
  191.       else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
  192.       else if (error == OTA_END_ERROR) Serial.println("End Failed");
  193.     });
  194.   // if DNSServer is started with "*" for domain name, it will reply with
  195.   // provided IP to all DNS reques
  196.   ArduinoOTA.begin();
  197.   #endif // OTA_HANDLER
  198. }
  199. //------------------------------------------------------
  200. static void ArduinoOTA_Handle_Loop(void)
  201. {
  202.   #ifdef OTA_HANDLER
  203.   ArduinoOTA.handle();
  204.   #endif // OTA_HANDLER
  205. }
  207. static void ClientConnection_Loop()
  208. {
  209.   if(server[0]->hasClient())
  210.   {
  211.       if (!TCPClient[0][0] || !TCPClient[0][0].connected())
  212.       {
  213.         if(TCPClient[0][0])
  214.         {
  215.           TCPClient[0][0].stop();
  216.         }
  217.         TCPClient[0][0] = server[0]->available();
  218.        
  219.         if(debug) COM[DEBUG_COM]->print("New client for COM");
  220.         if(debug) COM[DEBUG_COM]->print(0);
  221.         if(debug) COM[DEBUG_COM]->println(0);
  222.        }
  223.     //no free/disconnected spot so reject
  224.     WiFiClient TmpserverClient = server[0]->available();
  225.     TmpserverClient.stop();
  226.   }
  227. }
  229. static void WriteRS485Data(void)
  230. {
  231.   if(COM[1] != NULL)        
  232.   {        
  233.       if(TCPClient[0][0])
  234.       {
  235.         while(TCPClient[0][0].available())
  236.         {
  237.           buf1[1][i1[1]] = TCPClient[0][0].read(); // read char from client (LK8000 app)
  238.           if(i1[1]<bufferSize-1)
  239.           {
  240.             i1[1]++;
  241.           }
  242.         }
  244.         if(i1[1] != 0x00)
  245.         {
  246.           SetRS485PinToSendData();
  247.           delay(5);
  248.           COM[1]->write(buf1[1], i1[1]);
  249.           COM[1]->flush();


  250. delay(3);
  251.           //delay(7);
  252.           SetRS485PinToReceiveData();
  253.           i1[1] = 0;
  254.         }
  255.       }
  256.    
  257.       if(COM[1]->available())
  258.       {
  259.         while(COM[1]->available())
  260.         {  
  261.           buf2[1][i2[1]] = COM[1]->read(); // read char from UART(num)
  262.           if(i2[1]<bufferSize-1)
  263.           {
  264.             i2[1]++;
  265.           }
  266.         }
  267.      
  268.         if(TCPClient[0][0])  
  269.         {              
  270.           TCPClient[0][0].write(buf2[1], i2[1]);
  271.         }
  272.         i2[1] = 0;
  273.       }
  274.    }
  275. }
  276. //None volatile storage read & write */
  277. void NonVolatileStorageRead(void)
  278. {
  279.   preferences.begin("wifi", false);
  280.   wifiSSID = preferences.getString("ssid", "none");          
  281.   wifiPassword = preferences.getString("password", "none");
  282.   preferences.end();
  283. }
  285. void NonVolatileStorageWrite(void)
  286. {
  287.   preferences.clear();
  288.   preferences.begin("wifi", false);
  289.   preferences.putString("ssid", wifiSSID);
  290.   preferences.putString("password", wifiPassword);
  291.   preferences.end();
  292. }
  293. //-------------------------------------------------
  294. void NonVolatileStorageWriteBaudrate(void)
  295. {
  296.   preferences.clear();
  297.   preferences.begin("Baudrate", false);
  298.   preferences.putUInt("baudrate", Baudrate_RS485);
  299.   preferences.end();
  300. }
  302. void NonVolatileStorageReadBaudrate(void)
  303. {
  304.   preferences.begin("Baudrate", false);
  305.   Baudrate_RS485 = preferences.getUInt("baudrate", 0x0);          
  306.   preferences.end();
  307. }
  308. //-------------------------------------------------
  309. void NonVolatileStorageWritePort(void)
  310. {
  311.   preferences.clear();
  312.   preferences.begin("Port", false);
  313.   preferences.putUInt("port", ConnectionPort);
  314.   preferences.end();
  315. }
  317. void NonVolatileStorageReadPort(void)
  318. {
  319.   preferences.begin("Port", false);
  320.   ConnectionPort = preferences.getUInt("port", 0);          
  321.   preferences.end();
  322. }
  324. uint32_t SelectBaudrate(uint8_t baudrate)
  325. {
  326.   if(baudrate == 0x01) { return 9600; }
  327.   else if(baudrate == 0x02) { return 14400; }
  328.   else if(baudrate == 0x03) { return 19200; }
  329.   else if(baudrate == 0x04) { return 28800; }
  330.   else if(baudrate == 0x05) { return 38400; }
  331.   else if(baudrate == 0x05) { return 56000; }
  332.   else if(baudrate == 0x06) { return 57600; }
  333.   else if(baudrate == 0x07) { return 115200; }
  334.   else if(baudrate == 0x08) { return 128000; }
  335.   else if(baudrate == 0x09) { return 256000; }
  336. }
  338. /*
  339.   * Protocol:
  340.   * 0x01 0xB6 <LEN> [data]  Set SSID
  341.   * 0x01 0xA5 <LEN> [data]  Set Password
  342.   * 0x01 0xE7 0x02 0xXX 0xXX  Set Baudrate
  343.   * 0x01 0xD8 0x01 0xXX  Set PortNum
  344. */
  346. void SetParametersFrameAnalyse()
  347. {
  348.   if(COM[0] != NULL)
  349.   {
  350.       if(COM[0]->available())
  351.       {
  352.         while(COM[0]->available())
  353.         {  
  354.           buf2[1][i2[1]] = COM[0]->read(); // read char from UART(num)
  355.           if(i2[1]<bufferSize-1)
  356.           {
  357.             i2[1]++;
  358.           }
  359.         }
  361.         if(buf2[1][0] == _SOH)
  362.         {
  363.           uint8_t sendResponseFrame = 0;
  364.          
  365.           if(buf2[1][1] == _SET_SSID)
  366.           {
  367.             if(debug) COM[DEBUG_COM]->print("_SET_SSID");
  368.             String testname = "";
  369.            
  370.             for(uint8_t i=0; i<buf2[1][2]; i++)
  371.             {
  372.                testname += char(buf2[1][i + 3]);
  373.                wifiSSID = testname;
  374.             }
  376.             NonVolatileStorageWrite();
  377.           }
  378.           else if(buf2[1][1] == _SET_PASSWORD)
  379.           {
  380.             if(debug) COM[DEBUG_COM]->print("_SET_PASSWORD");
  382.             String testname = "";
  383.            
  384.             for(uint8_t i=0; i<buf2[1][2]; i++)
  385.             {
  386.                testname += char(buf2[1][i + 3]);
  387.                wifiPassword = testname;
  388.             }
  390.             NonVolatileStorageWrite();
  391.           }
  392.           else if(buf2[1][1] == _SET_BUAURATE)
  393.           {
  394.             if(debug) COM[DEBUG_COM]->print("_SET_BUAURATE");
  395.             Baudrate_RS485 = (uint32_t)buf2[1][3];
  396.             NonVolatileStorageWriteBaudrate();
  397.           }
  398.           else if(buf2[1][1] == _SET_PORT)
  399.           {
  400.             if(debug) COM[DEBUG_COM]->print("_SET_PORT");
  401.             ConnectionPort = (buf2[1][3] << 8) | buf2[1][4];
  402.             NonVolatileStorageWritePort();
  403.           }
  405.           if(sendResponseFrame == 1)
  406.           {
  407.             if(i2[1] != 0x00)
  408.             {
  409.               COM[0]->write(buf2[1], i2[1]); // now send to UART(num):
  410.             }
  411.           }
  412.         }
  413.         i2[1] = 0;
  414.       }
  415.   }
  416. }


Poniżej znajduje się plik .h zawierający ustawienia kody rozkazów itp:

  1. #define OTA_HANDLER
  2. #define RS485_ENABLE
  4. #define PROTOCOL_TCP
  6. const bool debug = true;
  8. const char *ssid = "ssid";
  9. const char *pw = "password";
  11. #define SSID_BUFFER_SIZE      32
  12. #define PASSWORD_BUFFER_SIZE  64
  14. #define NEW_SETTINGS_PIN      22
  15. #define RESET_PIN             13
  17. #define RE_PIN  26
  18. #define DE_PIN  27
  20. #define WRITE_SETTINGS_PIN_NUM  18
  22. #define NUM_COM   2                 // total number of COM Ports
  23. #define DEBUG_COM 0                 // debug output to COM0
  24. /*************************  COM Port 0 ON ESP BOARD *******************************/
  25. #define UART_BAUD0 115200           // Baudrate
  26. #define SERIAL_PARAM0 SERIAL_8N1    // Data/Parity/Stop
  27. #define SERIAL0_RXPIN 3             // receive Pin
  28. #define SERIAL0_TXPIN 1             // transmit Pin
  29. #define SERIAL0_TCP_PORT 8880       // Wifi Port
  30. /*************************  COM Port 2 ON ESP BOART *******************************/
  31. #define UART_BAUD2 115200           // Baudrate
  32. #define SERIAL_PARAM2 SERIAL_8N1    // Data/Parity/Stop
  33. #define SERIAL2_RXPIN 16            // receive Pin
  34. #define SERIAL2_TXPIN 17            // transmit Pin
  35. #define SERIAL2_TCP_PORT 8881       // Wifi Port
  37. #define bufferSize 1024
  39. /* Set network Parameters */
  40. #define _SOH            0x01
  41. #define _SET_SSID       0xB6
  42. #define _SET_PASSWORD   0xA5
  43. #define _SET_STATIC_IP  0xC5
  44. #define _SET_BUAURATE   0xE7
  45. #define _SET_PORT       0xD8
  47. //////////////////////////////////////////////////////////////////////////

Projekty opisane w tym poście można pobrać z dysku Google pod tym linkiem.
Autor: o
Etykiety: , , , ,