ESP32

Question

我尝试用两个 ESP32 和两个 LDR 构建一个计时激光器。我有两个 ESP32:

一个人用 LDR 做一个 ACCESS Point
第二次连接AP，有激光计时算法和第二个LDR

在第二个中，我也尝试拥有一个 WebServer，这样我就可以连接到我的 phone 并重新启动 chrono。

我尝试进行多任务处理，但每次我的 ESP32 重启时：

18:10:42.625 -> E (5775) task_wdt: Task watchdog got triggered. The following tasks did not reset the watchdog in time:
18:10:42.672 -> E (5775) task_wdt:  - IDLE0 (CPU 0)
18:10:42.672 -> E (5775) task_wdt: Tasks currently running:
18:10:42.672 -> E (5775) task_wdt: CPU 0: Task1
18:10:42.672 -> E (5775) task_wdt: CPU 1: Task2
18:10:42.672 -> E (5775) task_wdt: Aborting.
18:10:42.672 -> abort() was called at PC 0x400d9033 on core 0

你可以在这里找到我的代码： https://create.arduino.cc/editor/marcoberle/c4762636-36c6-4551-92f2-935021a001c9/preview

我的代码：

// Load Wi-Fi library
#include <WiFi.h>
#include <HTTPClient.h>

//Declaration of PIN
const int departReceiver = 4;  // the number of the pin
const int LED_BUILTIN = 2;

// Replace with your network credentials
const char* ssid = "ESP32-ARRIVE";
const char* password = "123456789";

// Set web server port number to 80
WiFiServer server(80);
WiFiClient client = server.available();

//Your IP address or domain name with URL path
const char* serverNameArrive = "http://192.168.4.1/arrive";

// Variable to store the HTTP request
String header;

// Auxiliar variables to store the current output state
String output26State = "off";
String output27State = "off";

// Assign output variables to GPIO pins
const int output26 = 26;
const int output27 = 27;

// Current time
unsigned long currentTime = millis();
// Previous time
unsigned long previousTime = 0;
// Define timeout time in milliseconds (example: 2000ms = 2s)
const long timeoutTime = 2000;

TaskHandle_t Task1;
TaskHandle_t Task2;

void setup() {
  Serial.begin(115200);
  pinMode(departReceiver, INPUT);
  
  // Initialize the output variables as outputs
  pinMode(output26, OUTPUT);
  pinMode(output27, OUTPUT);
  // Set outputs to LOW
  digitalWrite(output26, LOW);
  digitalWrite(output27, LOW);

  // Connect to Wi-Fi network with SSID and password
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  // Print local IP address and start web server
  Serial.println("");
  Serial.println("WiFi connected.");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
  server.begin();
  client = server.available();

  //create a task that will be executed in the Task1code() function, with priority 1 and executed on core 0
  xTaskCreatePinnedToCore(
                    Task1code,   /* Task function. */
                    "Task1",     /* name of task. */
                    10000,       /* Stack size of task */
                    NULL,        /* parameter of the task */
                    6,           /* priority of the task */
                    &Task1,      /* Task handle to keep track of created task */
                    0);          /* pin task to core 0 */                  
  delay(500); 

  //create a task that will be executed in the Task2code() function, with priority 1 and executed on core 1
  xTaskCreatePinnedToCore(
                    Task2code,   /* Task function. */
                    "Task2",     /* name of task. */
                    10000,       /* Stack size of task */
                    NULL,        /* parameter of the task */
                    7,           /* priority of the task */
                    &Task2,      /* Task handle to keep track of created task */
                    1);          /* pin task to core 1 */
    delay(500);
}





//CHRONO VAR
unsigned int departStatus = 0;
unsigned int arriveStatus = 0;
unsigned int start_time = 0;
unsigned int stop_time = 0;
unsigned int total_time = 0;
const unsigned int OFF = 0;
const unsigned int ON = 1;


String httpGETRequest(const char* serverName) {
  HTTPClient http;

  // Your IP address with path or Domain name with URL path
  http.begin(serverName);

  // Send HTTP POST request
  int httpResponseCode = http.GET();

  String payload = "--";

  if (httpResponseCode > 0) {
    payload = http.getString();
  }
  else {
  }
  // Free resources
  http.end();

  return payload;
}

String ChronoLog = "";
int reset = 0;
void Chrono () {
  if (reset == 0) {
    reset = 1;
    ChronoLog = "<p>ALGO START</p>";
    Serial.println("ALGO START");
    while (departStatus == OFF) {
      departStatus = digitalRead(departReceiver);
    }
    ChronoLog += "<p>Borne de début prête</p>";
    Serial.println("Borne de début prête");
    while (arriveStatus == OFF) {
      arriveStatus = httpGETRequest(serverNameArrive).toInt();
    }
    ChronoLog += "<p>Borne de fin prête</p>";
    ChronoLog += "<p>En attente du courreur</p>";
    Serial.println("Borne de fin prête");
    Serial.println("En attente du courreur");
    while (departStatus == ON) {
      departStatus = digitalRead(departReceiver);
    }
    ChronoLog += "<p>Courreur en place</p>";
    Serial.println("Courreur en place");
    digitalWrite(LED_BUILTIN, HIGH);

    while (departStatus == OFF) {
      departStatus = digitalRead(departReceiver);
    }
    ChronoLog += "<p>Chrono lancé</p>";
    Serial.println("Chrono lancé");
    start_time = millis();
    while (arriveStatus == ON) {
      arriveStatus = httpGETRequest(serverNameArrive).toInt();
    }
    stop_time = millis();
    total_time = stop_time - start_time;
    ChronoLog += "<p>Courru en </p>";
    float timeSe = total_time * 0.001;
    //ChronoLog += "<p><b>" + String(timeSe) + "</b></p>" ;
    Serial.println("Courru en");
    Serial.println(timeSe);
  }
}

void ResetChrono () {
  reset = 0;
  departStatus = 0;
  arriveStatus = 0;
  start_time = 0;
  stop_time = 0;
  total_time = 0;
}

void Webserver() {
  // Listen for incoming clients
  client = server.available();
  if (client) {                             // If a new client connects,
    currentTime = millis();
    previousTime = currentTime;
    Serial.println("New Client.");          // print a message out in the serial port
    String currentLine = "";                // make a String to hold incoming data from the client
    while (client.connected() && currentTime - previousTime <= timeoutTime) {  // loop while the client's connected
      currentTime = millis();
      if (client.available()) {             // if there's bytes to read from the client,
        char c = client.read();             // read a byte, then
        Serial.write(c);                    // print it out the serial monitor
        header += c;
        if (c == '\n') {                    // if the byte is a newline character
          // if the current line is blank, you got two newline characters in a row.
          // that's the end of the client HTTP request, so send a response:
          if (currentLine.length() == 0) {
            // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
            // and a content-type so the client knows what's coming, then a blank line:
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");
            client.println("Connection: close");
            client.println();

            //RESET CHRONO
            if (header.indexOf("GET /RESET") >= 0) {
              ResetChrono();
            }

            // turns the GPIOs on and off
            if (header.indexOf("GET /26/on") >= 0) {
              Serial.println("GPIO 26 on");
              output26State = "on";
              digitalWrite(output26, HIGH);
            } else if (header.indexOf("GET /26/off") >= 0) {
              Serial.println("GPIO 26 off");
              output26State = "off";
              digitalWrite(output26, LOW);
            } else if (header.indexOf("GET /27/on") >= 0) {
              Serial.println("GPIO 27 on");
              output27State = "on";
              digitalWrite(output27, HIGH);
            } else if (header.indexOf("GET /27/off") >= 0) {
              Serial.println("GPIO 27 off");
              output27State = "off";
              digitalWrite(output27, LOW);
            }

            // Display the HTML web page
            client.println("<!DOCTYPE html><html>");
            client.println("<head><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">");
            //Chrono(client);
            client.println("<link rel=\"icon\" href=\"data:,\">");
            // CSS to style the on/off buttons
            // Feel free to change the background-color and font-size attributes to fit your preferences
            client.println("<style>html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}");
            client.println(".button { background-color: #4CAF50; border: none; color: white; padding: 16px 40px;");
            client.println("text-decoration: none; font-size: 30px; margin: 2px; cursor: pointer;}");
            client.println(".button2 {background-color: #555555;}</style></head>");

            // Web Page Heading
            client.println("<body><h1>CHRONO</h1>");
            client.println(ChronoLog);


            client.println("<p><a href=\"/RESET\"><button class=\"button\">RESET</button></a></p>");

            // Display current state, and ON/OFF buttons for GPIO 26
            client.println("<p>GPIO 26 - State " + output26State + "</p>");
            // If the output26State is off, it displays the ON button
            if (output26State == "off") {
              client.println("<p><a href=\"/26/on\"><button class=\"button\">ON</button></a></p>");
            } else {
              client.println("<p><a href=\"/26/off\"><button class=\"button button2\">OFF</button></a></p>");
            }

            // Display current state, and ON/OFF buttons for GPIO 27
            client.println("<p>GPIO 27 - State " + output27State + "</p>");
            // If the output27State is off, it displays the ON button
            if (output27State == "off") {
              client.println("<p><a href=\"/27/on\"><button class=\"button\">ON</button></a></p>");
            } else {
              client.println("<p><a href=\"/27/off\"><button class=\"button button2\">OFF</button></a></p>");
            }
            client.println("</body></html>");

            // The HTTP response ends with another blank line
            client.println();
            // Break out of the while loop
            break;
          } else { // if you got a newline, then clear currentLine
            currentLine = "";
          }
        } else if (c != '\r') {  // if you got anything else but a carriage return character,
          currentLine += c;      // add it to the end of the currentLine
        }
      }
    }
    // Clear the header variable
    header = "";
    // Close the connection
    client.stop();
    Serial.println("Client disconnected.");
    Serial.println("");
  }
}

//Task1code: blinks an LED every 1000 ms
void Task1code( void * pvParameters ){
  Serial.print("Task1 running on core ");
  Serial.println(xPortGetCoreID());

  for(;;){
    Chrono();
  } 
}

//Task2code: blinks an LED every 700 ms
void Task2code( void * Parameters ){
  Serial.print("Task2 running on core ");
  Serial.println(xPortGetCoreID());

  for(;;){
    Webserver();
  }
}

void loop() {
}

您有什么建议可以优化我的代码或解决问题吗？

Answer 1

您正在重置看门狗定时器。这意味着您的代码已经运行ning 太久而没有重置用于从崩溃和无限循环中恢复的计时器。该计时器由 Arduino Core 中的底层代码自动处理。

您的 Chrono 和 Webserver 任务根本不会像您编写的那样工作。他们从不放弃处理器。 ESP32 不像 Linux 或 Windows 那样进行多任务处理。 ESP32 上的多任务处理是非抢占式的。一个任务运行直到它说“好的，我已经做够了，其他人现在可以运行”。这两个任务从不这样做，所以看门狗定时器关闭。即使看门狗定时器没有关闭，这也行不通，因为没有其他东西有机会运行.

至少你需要在每个任务中让出处理器：

  for(;;){
    Chrono();
  }

应该是：

  for(;;){
    Chrono();
    delay(1);
  }

和

  for(;;){
    Webserver();
  }

应该是

  for(;;){
    Webserver();
    delay(1);
  }

你的代码也有很多地方可以做这样的事情：

    while (departStatus == OFF) {
      departStatus = digitalRead(departReceiver);
    }

如果departStatus停留在OFF的时间过长，这将触发看门狗定时器。

任何时候你有这样的循环，你需要确保底层系统偶尔更改为运行。

重写您拥有的每个 while 循环来调用 delay(1); - 这将使 Arduino Core 有机会重置看门狗定时器。

像这样：

    while (departStatus == OFF) {
      departStatus = digitalRead(departReceiver);
      delay(1);
    }

Answer 2

我尝试了一种我在网上找到的方法，它很有效。添加库：

#include "soc/timer_group_struct.h"
#include "soc/timer_group_reg.h"

创建方法：

  void feedthedog () {
      TIMERG0.wdt_wprotect = TIMG_WDT_WKEY_VALUE;
      TIMERG0.wdt_feed = 1;
      TIMERG0.wdt_wprotect = 0;
    }

添加每隔一段时间执行一次方法

while (departStatus == OFF) {
      feedthedog();
      departStatus = digitalRead(departReceiver);
    }

我可以等待，刷新网络服务器上的页面，我没有收到错误:

19:38:40.321 -> Task1 running on core 0
19:38:40.321 -> ALGO START
19:39:20.937 -> Borne de début prête
19:39:39.093 -> Borne de fin prête
19:39:39.093 -> En attente du courreur
19:39:39.140 -> Courreur en place
19:39:51.840 -> Chrono lanc&eacute;
19:39:58.804 -> Courru en
19:39:58.804 -> 6.99
19:39:58.804 -> Tâche fini

我把我的更新代码放在这里： https://create.arduino.cc/editor/marcoberle/cb88dff8-d56c-422d-9f2e-4011ea2b80f4/preview

ESP32 - 在任务中进行多任务处理

ESP32 - Multi Tasking with while in a task

arduino