FreeRTOS 多任务第一课：采样、显示和网络通过队列协作

idf.py --version
# 必须为ESP-IDF v5.5.5
idf.py set-target esp32s3
idf.py menuconfig
idf.py build
idf.py -p REPLACE_WITH_UART_PORT flash monitor
# 另在可信局域网电脑执行（需放行自己选择的本地端口）：
python3 collector.py --bind 0.0.0.0 --port 8000

/* SPDX-License-Identifier: MIT */
#include <inttypes.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "freertos/semphr.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "esp_http_client.h"
#include "sdkconfig.h"
#include "sensirion_hal_idf.h"
#include "sensirion_i2c_hal.h"
#include "sht4x_i2c.h"
#include "net.h"
#include "oled.h"
#include "pipeline_policy.h"
static const char *TAG="queue_pipeline";
static QueueHandle_t display_queue, network_queue;
static SemaphoreHandle_t i2c_mutex;
static TaskHandle_t sampler_handle, display_handle, network_handle;
static void sample_task(void *unused) {
 (void)unused; uint32_t sequence=0, drops=0; TickType_t next=xTaskGetTickCount();
 for(;;) {
  sample_t sample={.sequence=++sequence,.error=-1,.dropped_new=drops};
  if(xSemaphoreTake(i2c_mutex,pdMS_TO_TICKS(500))==pdTRUE) {
   if(demo_i2c_ready()) sample.error=sht4x_measure_high_precision(&sample.temperature_milli,&sample.humidity_milli);
   xSemaphoreGive(i2c_mutex);
  }
  sample.sampled_ms=esp_timer_get_time()/1000;
  xQueueOverwrite(display_queue,&sample); /* length one: freshest state wins */
  if(xQueueSend(network_queue,&sample,0)!=pdTRUE) { ++drops; ESP_LOGW(TAG,"NETWORK_QUEUE_FULL drop-new sequence=%"PRIu32" total=%"PRIu32,sequence,drops); }
  ESP_LOGI(TAG,"SAMPLE sequence=%"PRIu32" error=%d producer_drop_new=%"PRIu32,sequence,sample.error,drops);
  xTaskDelayUntil(&next,pdMS_TO_TICKS(2000));
 }
}
static void display_task(void *unused) {
 (void)unused; sample_t sample; uint32_t previous=0; bool seen=false;
 for(;;) if(xQueueReceive(display_queue,&sample,portMAX_DELAY)==pdTRUE) {
  uint32_t gap=seen?sequence_gap(previous,sample.sequence):0; previous=sample.sequence; seen=true;
  esp_err_t e=ESP_ERR_TIMEOUT;
  if(xSemaphoreTake(i2c_mutex,pdMS_TO_TICKS(500))==pdTRUE) {
   e=oled_sample(&sample,esp_timer_get_time()/1000,gap); xSemaphoreGive(i2c_mutex);
  }
  ESP_LOGI(TAG,"DISPLAY sequence=%"PRIu32" skipped_between_receives=%"PRIu32" I2C=%s",sample.sequence,gap,esp_err_to_name(e));
  /* Delay outside the mutex: demonstrate queue policy without owning the bus. */
  vTaskDelay(pdMS_TO_TICKS(CONFIG_DEMO_DISPLAY_DELAY_MS));
 }
}
static void network_task(void *unused) {
 (void)unused; sample_t sample;
 for(;;) if(xQueueReceive(network_queue,&sample,portMAX_DELAY)==pdTRUE) {
  char body[320]; int64_t now=esp_timer_get_time()/1000;
  if(!sample_json(&sample,now,body,sizeof(body))) { ESP_LOGE(TAG,"serialization overflow"); continue; }
  if(net_online()) {
   esp_http_client_config_t config={.url=CONFIG_DEMO_HTTP_URL,.method=HTTP_METHOD_POST,.timeout_ms=3000,.disable_auto_redirect=true};
   esp_http_client_handle_t client=esp_http_client_init(&config);
   if(client) {
    esp_http_client_set_header(client,"Content-Type","application/json");
    esp_http_client_set_post_field(client,body,(int)strlen(body));
    esp_err_t e=esp_http_client_perform(client); int status=esp_http_client_get_status_code(client);
    ESP_LOGI(TAG,"HTTP sequence=%"PRIu32" result=%s status=%d",sample.sequence,esp_err_to_name(e),status);
    esp_http_client_cleanup(client);
   } else ESP_LOGE(TAG,"HTTP allocation failed");
  } else ESP_LOGW(TAG,"OFFLINE discard sequence=%"PRIu32" (no persistent replay)",sample.sequence);
  vTaskDelay(pdMS_TO_TICKS(CONFIG_DEMO_NETWORK_DELAY_MS));
 }
}
void app_main(void) {
 i2c_mutex=xSemaphoreCreateMutex(); display_queue=xQueueCreate(1,sizeof(sample_t)); network_queue=xQueueCreate(4,sizeof(sample_t));
 if(!i2c_mutex || !display_queue || !network_queue) { ESP_LOGE(TAG,"queue/mutex allocation failed"); return; }
 sensirion_i2c_hal_init(); sht4x_init(0x44);
 esp_err_t e=oled_init(demo_i2c_bus()); ESP_LOGI(TAG,"OLED init %s (physical result still unverified)",esp_err_to_name(e));
 net_start();
 if(xTaskCreate(sample_task,"sample",4096,NULL,5,&sampler_handle)!=pdPASS ||
    xTaskCreate(display_task,"display",4096,NULL,4,&display_handle)!=pdPASS ||
    xTaskCreate(network_task,"network",6144,NULL,3,&network_handle)!=pdPASS) {
  ESP_LOGE(TAG,"task allocation failed; stopping created workers");
  if(sampler_handle) vTaskDelete(sampler_handle);
  if(display_handle) vTaskDelete(display_handle);
  if(network_handle) vTaskDelete(network_handle);
  return;
 }
 ESP_LOGI(TAG,"cores=%d tasks unpinned; display queue=latest(1), network=drop-new(4)",portNUM_PROCESSORS);
 for(;;) {
  vTaskDelay(pdMS_TO_TICKS(10000));
  ESP_LOGI(TAG,"minimum-free-stack bytes sample=%u display=%u network=%u; not scheduling latency",(unsigned)uxTaskGetStackHighWaterMark(sampler_handle),(unsigned)uxTaskGetStackHighWaterMark(display_handle),(unsigned)uxTaskGetStackHighWaterMark(network_handle));
 }
}