FluxDC/components/FluxProtocol/FluxProtocol_data.c

/**
 * @file FluxProtocol_data.c
 * @brief 数据存储c文件
 * 
 * 用于存储部分参数
 * 
 * @author wang xiang en
 * @date 2025-04-24
 * @version 版本号
 * @copyright 版权声明（(C)2025, YUWELL MEDTECH Co.ltd）
 */
#include "FluxProtocol.h"

/* 定义进行tag */
char *TAG = "FluxProtocol_data";

/* 定义用于存储设备名称的数组 */
char *device_name[3] = {
    "Spirit3",
    "Spirit6",
    "YU-Lite8"
};

/* 定义用于存储nominalVolume的数组 单位ml */
float Spirit3_Volume[4] = { 210,420,630,750};
float Spirit6_Volume[6] = { 210,420,630,840,1050,1200};
float YULite8_Volume[8] = { 210,420,630,750,870,990,1110,990};

/* 定义用于存储YU-Lite8上下限的数组 */
float YULite8_UpperLimit[8] = { 22,36,52.5,62.5,72.5,82.5,92.5,24.5};
float YULite8_LowerLimit[8] = { 6,20,31.5,37.5,43.5,49.5,55.5,8.5};

/* 定义用于存储呼吸模拟器频率控制的Modbus寄存器地址 */
uint32_t bs_addr_all[6] = { BS_ADDR_15BPM,BS_ADDR_20BPM,BS_ADDR_25BPM,BS_ADDR_30BPM,BS_ADDR_35BPM,BS_ADDR_40BPM};

/* 用于存储三款机器挡位stage的数据 */
int32_t Spirit3_Stage[4] = { 1,2,3,4};
int32_t Spirit6_Stage[6] = { 1,2,3,4,5,6};
int32_t YULite8_Stage[8] = { 1,2,3,4,5,6,7,8};

/*
 * @brief 拼接测试过程中用于展示的字符串
 * 1.时间设置发送成功 Time setting sent successfully
 * 2.开始测试 start testing
 * 3.等待测试结束 Waiting for the end of the test
 * 4.当前频率测试结束 The current frequency test has ended
 * 5.所有频率测试完毕，请记录。 All frequency tests have been completed, please record.
 * 6.设备已启动成功，请开始测试。 Device started successfully, please start testing.
 */
char *test_info[6] = {"Time setting Send",\
                    "testing...",\
                    "wait for end",\
                    " frequency test finished",\
                    "all done",\
                    "breath command sent"
};

/* 测试呼吸频率 */
char *test_rate[6] = {"15BPM","20BPM","25BPM","30BPM","35BPM","40BPM"};

/* 用于存储breath_rate的数据 单位bpm */
int32_t breath_rate[6] = {15,20,25,30,35,40};

/* 流量计六个挡位测试时间序列 */
//int flux_test_time_series[6] = {40,30,24,20,18,15};
int flux_test_time_series[6] = {41,31,25,21,19,16};

/* 定于用于存储当前测试呼吸频率的枚举变量 */
enum Bs_test_Rate currentTestRate = BS_RATE_15BPM;

/* 定义存储各挡位是否测试成功的标志变量 事件组 */
EventGroupHandle_t g_bs_test_event_group;

/* 定义事件组在的位置 */
uint32_t g_bs_test_event_group_bits[6] = { BIT0,BIT1,BIT2,BIT3,BIT4,BIT5};

/* 创建任务控制句柄 */
TaskHandle_t bs_test_task_handle;
TaskHandle_t nom_test_task_handle;

/* 创建用于表征当前是否进行BS测试的全局变量 */
bool is_bs_test_ing = false;
bool is_nom_test_ing = false;

/* 定义用于存储当前工作模式的变量,默认是bs模式 */
bool is_test_mode_nom = false;

/* 定义控制LED小灯的任务句柄 */
TaskHandle_t bs_stateLED_task_handle;
TaskHandle_t nom_stateLED_task_handle;

/* 定义用于UDP通讯的服务器地址结构体 */
struct sockaddr_in server_addr = {
            .sin_family = AF_INET,
            .sin_port = htons(5656)
        };
int udp_socket = -1;

/**
 * @brief 新建用于进行套接字通讯的任务函数
 *
 * 用于进行数据接收和发送的线程
 * 
 * @param[in] arg not used
 * 
 */
static const char *payload = "Message from ESP32 ";
#define CONFIG_EXAMPLE_IPV4
void socket_com_task(void* arg)
{
    char rx_buffer[128];
    char host_ip[] = "192.168.155.238";
    int addr_family = 0;
    int ip_protocol = 0;

    while (1) {

#if defined(CONFIG_EXAMPLE_IPV4)
        struct sockaddr_in dest_addr;
        dest_addr.sin_addr.s_addr = inet_addr("192.168.155.238");
        dest_addr.sin_family = AF_INET;
        dest_addr.sin_port = htons(5656);
        addr_family = AF_INET;
        ip_protocol = IPPROTO_IP;
#elif defined(CONFIG_EXAMPLE_IPV6)
        struct sockaddr_in6 dest_addr = { 0 };
        inet6_aton(HOST_IP_ADDR, &dest_addr.sin6_addr);
        dest_addr.sin6_family = AF_INET6;
        dest_addr.sin6_port = htons(PORT);
        dest_addr.sin6_scope_id = esp_netif_get_netif_impl_index(EXAMPLE_INTERFACE);
        addr_family = AF_INET6;
        ip_protocol = IPPROTO_IPV6;
#elif defined(CONFIG_EXAMPLE_SOCKET_IP_INPUT_STDIN)
        struct sockaddr_storage dest_addr = { 0 };
        ESP_ERROR_CHECK(get_addr_from_stdin(PORT, SOCK_DGRAM, &ip_protocol, &addr_family, &dest_addr));
#endif

        int sock = socket(addr_family, SOCK_DGRAM, ip_protocol);
        if (sock < 0) {
            ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
            break;
        }

        // Set timeout
        struct timeval timeout;
        timeout.tv_sec = 10;
        timeout.tv_usec = 0;
        setsockopt (sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof timeout);

        ESP_LOGI(TAG, "Socket created, sending to %s:%d", "HOST_IP_ADDR", 5656);

        while (1) {

            int err = sendto(sock, payload, strlen(payload), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
            if (err < 0) {
                ESP_LOGE(TAG, "Error occurred during sending: errno %d", errno);
                break;
            }
            ESP_LOGI(TAG, "Message sent");

            struct sockaddr_storage source_addr; // Large enough for both IPv4 or IPv6
            socklen_t socklen = sizeof(source_addr);
            int len = recvfrom(sock, rx_buffer, sizeof(rx_buffer) - 1, 0, (struct sockaddr *)&source_addr, &socklen);

            // Error occurred during receiving
            if (len < 0) {
                ESP_LOGE(TAG, "recvfrom failed: errno %d", errno);
                break;
            }
            // Data received
            else {
                rx_buffer[len] = 0; // Null-terminate whatever we received and treat like a string
                ESP_LOGI(TAG, "Received %d bytes from %s:", len, host_ip);
                ESP_LOGI(TAG, "%s", rx_buffer);
                if (strncmp(rx_buffer, "OK: ", 4) == 0) {
                    ESP_LOGI(TAG, "Received expected message, reconnecting");
                    break;
                }
            }

            vTaskDelay(2000 / portTICK_PERIOD_MS);
        }

        if (sock != -1) {
            ESP_LOGE(TAG, "Shutting down socket and restarting...");
            shutdown(sock, 0);
            close(sock);
        }
    }
    vTaskDelete(NULL);
}