上传文件至 /

NEWREADME.md

@@ -0,0 +1,195 @@
+# 8.8升级
+
+## 升级内容
+
+### 增加消防水位检测功能
+
+针对消防水位的的检测，ADC文件路径：/sys/bus/iio/devices/iio:device0/in_voltage2_raw；设置ADC检测值为1000，一小时检测一次；如果超过便输出0；小于1000则输出1
+
+指定IP地址，摄像头本身具有多个IP地址；指定有线网络接口：eth0并读取该IP地址
+
+
+
+# 7.11升级
+
+## 升级内容
+
+**一、*****\*新增消防控制功能\****
+
+摄像头硬件升级后，增加5路IO输出、1路IO报警输入的功能。
+
+1-4路IO输出为电磁阀控制；
+
+5路为水泵电源控制和充电设备断电控制；
+
+1路输入为消防水箱液位报警输入；
+
+| ***\*IO口\**** | ***\*GPIO\**** | ***\*控制\**** |
+| -------------- | -------------- | -------------- |
+| 1              | 116            | 电磁阀1        |
+| 2              | 18             | 电磁阀2        |
+| 3              | 19             | 电磁阀3        |
+| 4              | 103            | 电磁阀4        |
+| 5              | 102            | 水泵、电源控制 |
+
+***\*GPIO控制指令：\****
+
+cd /sys/class/gpio
+
+echo 18 > export // 导出gpio
+
+echo out > gpio18/direction // 设置gpio输出
+
+echo 0 > gpio18/value // 设置gpio输出0 （关闭）
+
+echo 1 > gpio18/value // 设置gpio输出1 （打开）
+
+ 
+
+***\*报警处理：\****
+
+1、摄像头监测到区域报警，调用摄像头IO输出控制相应区域消防喷淋；先打开报警区域对应电磁阀开关、再打开水泵开关。
+
+2、1-4检测报警区域对应1-4号IO口。如1号区域报警，则将1号IO口116输出1打开1号电磁阀，同时打开5号IO口水泵电源。5秒内没有再出现报警则关闭电磁阀。
+
+ 
+
+***\*处理流程：\****
+
+设置一个全局数组保存5个IO口的状态，int state[5] = {0,0,0,0,0}
+
+1、摄像头区域报警时开启喷淋控制：
+
+先判定对应区域状态：如果区域状态为0，则打开区域对应IO口（输出1），同时将区域状态置为6；区域状态不为0，则直接将区域状态置为6；
+
+再判定5号IO口水泵状态：如果水泵状态为0，则打开水泵对应5号IO口（输出1），同时将水泵状态置为6；水泵状态不为0，则直接将水泵状态置为6；
+
+2、开启一个线程处理IO状态和IO关闭处理。
+
+监听所有IO状态，当IO状态不为0时，每间隔1秒状态值减1；
+
+状态值为1时，关闭对应IO口并将状态值置为0。
+
+
+
+## 注意事项：
+
+时间0秒：区域1报警 → state[0] = 6 （电磁阀1打开）
+
+时间1秒：监控线程 → state[0] = 5 （还剩5秒）
+
+时间2秒：监控线程 → state[0] = 4 （还剩4秒）
+
+时间3秒：监控线程 → state[0] = 3 （还剩3秒）
+
+时间4秒：监控线程 → state[0] = 2 （还剩2秒）
+
+时间5秒：监控线程 → state[0] = 1 （还剩1秒，准备关闭）
+
+时间6秒：监控线程 → state[0] = 0 （关闭电磁阀1）
+
+ 
+
+发现问题：
+
+增加成上述内容步骤后，启动线程控制台打印报警信息，接收器没有接收到报警信息并输出
+
+判断：
+
+1.请求的URL地址是否出错
+
+2.测试接收器是否能接收到该网段的信息
+
+结果：
+
+1.强制指定部分URL地址，例如：http://192.168.1.23:9527/device/alarm，2，3 IO口 可以接受信息，更换4，5无法接收
+
+修正：
+
+如何让各个通道都能接收到信息
+
+最终定义：
+
+地址类型转换错误
+
+原1631-1632行
+
+// curl_easy_setopt(curl, CURLOPT_URL, "http://192.168.1.23:9527/device/alarm");
+
+   curl_easy_setopt(curl, CURLOPT_URL,ALARM_URL); 
+
+因为ALARM_URL是需要std::string类型定义地址，所以使用c_str即可；
+
+​    curl_easy_setopt(curl, CURLOPT_URL, ALARM_URL.c_str());
+
+# 5.26修改
+
+## 本串口协议必备要求：先发送在接收
+
+## 注：本项目已经通过串口测试（传感器为115200，摄像头为9500），每次报警前会识别设备名称序号，然后反馈到串口输出序列中
+
+# rknn_yolo_EAI_pic
+
+#### 简要说明
+
+用于跑EAI提供仓库训练出来的yolov5模型的视频检测例程。
+集成了从串口读取红外温度数据，到达阈值后报警并运行rknn模型
+
+需注意运行该例程需要将npu驱动更新为1.7.3版本
+
+本项目只适用于EAI-YOLOV5
+详情请参考EAI官网：https://www.easy-eai.com/document_details/3/342
+
+
+## 准备工作
+根据EAI给出的教程训练、转化得到rknn模型
+有两类检测模型：火焰检测和烟雾检测
+
+
+
+## 安装(install)
+
+通过adb连接设备并将编译结果推送至板端，执行以下命令推送，这里板端默认使用/userdata路径
+
+```
+adb push install/rknn_yolo_demo /userdata/
+```
+
+将前面准备好的RKNN模型推送至板端，这里假设模型名字为 yolov5s_u8.rknn
+
+```
+adb push ./yolov5s_u8.rknn /userdata/rknn_yolo_demo/model/yolov5s_u8.rknn
+```
+
+
+
+## 单图测试执行
+详情请了解官网：9.模型部署实例
+
+进入EAI环境之后编译，将编译文件放置到可执行程序，假设是first_yolov5_detect_demo
+用下列命令将可执行程序推送到开发板端
+
+```
+cp first_yolov5_detect_demo/ /mnt/userdata/ -rf
+```
+
+进入办卡运行环境
+
+```
+adb shell
+```
+
+定位到指定位置后，运行程序
+
+```
+./rknn_yolo_EAI
+```
+
+
+## 编译(build)
+
+在项目文件中，根据设备，调整 GCC_COMPILER 参数，终端执行下面命令进行编译
+
+```
+./build.sh
+```

OLDREADME.md

@@ -1,69 +0,0 @@
-# 本串口协议必备要求：先发送在接收
-
-## 注：本项目已经通过串口测试（传感器为115200，摄像头为9500），每次报警前会识别设备名称序号，然后反馈到串口输出序列中
-
-# rknn_yolo_EAI_pic
-
-#### 简要说明
-
-用于跑EAI提供仓库训练出来的yolov5模型的视频检测例程。
-集成了从串口读取红外温度数据，到达阈值后报警并运行rknn模型
-
-需注意运行该例程需要将npu驱动更新为1.7.3版本
-
-本项目只适用于EAI-YOLOV5
-详情请参考EAI官网：https://www.easy-eai.com/document_details/3/342
-
-
-## 准备工作
-根据EAI给出的教程训练、转化得到rknn模型
-有两类检测模型：火焰检测和烟雾检测
-
-
-
-## 安装(install)
-
-通过adb连接设备并将编译结果推送至板端，执行以下命令推送，这里板端默认使用/userdata路径
-
-```
-adb push install/rknn_yolo_demo /userdata/
-```
-
-将前面准备好的RKNN模型推送至板端，这里假设模型名字为 yolov5s_u8.rknn
-
-```
-adb push ./yolov5s_u8.rknn /userdata/rknn_yolo_demo/model/yolov5s_u8.rknn
-```
-
-
-
-## 单图测试执行
-详情请了解官网：9.模型部署实例
-
-进入EAI环境之后编译，将编译文件放置到可执行程序，假设是first_yolov5_detect_demo
-用下列命令将可执行程序推送到开发板端
-
-```
-cp first_yolov5_detect_demo/ /mnt/userdata/ -rf
-```
-
-进入办卡运行环境
-
-```
-adb shell
-```
-
-定位到指定位置后，运行程序
-
-```
-./rknn_yolo_EAI
-```
-
-
-## 编译(build)
-
-在项目文件中，根据设备，调整 GCC_COMPILER 参数，终端执行下面命令进行编译
-
-```
-./build.sh
-```

src/8.8main.cpp

@@ -49,6 +49,12 @@
 #include <nlohmann/json.hpp>
 #include <mutex>
 
+#include <ifaddrs.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
 #define MSS_TEST_BUS_NAME "yolov5test"
 static jbus_hdl_t g_jbus;
 static jmss_hdl_t g_jmss;
@@ -92,6 +98,7 @@ using json = nlohmann::json;
 #define RELAY_GPIO_PIN 116  // 使用GPIO 72控制继电器
 
 
+#define curl_global_init(CURL_GLOBAL_ALL);
 
 
 void hexdump(const char *buf, int len)
@@ -104,20 +111,150 @@ void hexdump(const char *buf, int len)
     printf("\n");
 }
 
-
+int relay_state[5]={0,0,0,0,0};
 // 控制继电器复位的函数
-void reset_relay() {
-    // 导出GPIO引脚
-    system("echo 116 > /sys/class/gpio/export");
+void reset_relay(int zone,int cone) {
+    std::cout << "Relay zone 开启!" <<zone<< std::endl;
+    std::cout << "Relay cone 开启!" <<cone<< std::endl;
 
+    switch (zone)
+    {
+    case 1:
+       
+            system("echo 116 > /sys/class/gpio/export");
                 // 设置GPIO引脚为输出
             system("echo out > /sys/class/gpio/gpio116/direction");
 
             // 复位继电器
-    system("echo 1 > /sys/class/gpio/gpio116/value"); // 设置高电平
-    usleep(1000000); // 等待1秒
+            if(cone==0){
                 system("echo 0 > /sys/class/gpio/gpio116/value"); // 设置低电平
+            }else{
+            system("echo 1 > /sys/class/gpio/gpio116/value"); // 设置高电平
+            }
             std::cout << "Relay reset!" << std::endl;
+                
+        break;
+    case 2:
+        system("echo 18 > /sys/class/gpio/export");
+                // 设置GPIO引脚为输出
+            system("echo out > /sys/class/gpio/gpio18/direction");
+
+            // 复位继电器
+            if(cone==0){
+                system("echo 0 > /sys/class/gpio/gpio18/value"); // 设置低电平
+            }else{
+            system("echo 1 > /sys/class/gpio/gpio18/value"); // 设置高电平
+            }
+            std::cout << "Relay reset!" << std::endl;
+       
+        break;
+    case 3:
+        system("echo 19 > /sys/class/gpio/export");
+                // 设置GPIO引脚为输出
+            system("echo out > /sys/class/gpio/gpio19/direction");
+
+            // 复位继电器
+            if(cone==0){
+                system("echo 0 > /sys/class/gpio/gpio19/value"); // 设置低电平
+            }else{
+            system("echo 1 > /sys/class/gpio/gpio19/value"); // 设置高电平
+            }
+            std::cout << "Relay reset!" << std::endl;
+    
+        break;
+    case 4:
+        system("echo 103 > /sys/class/gpio/export");
+                // 设置GPIO引脚为输出
+            system("echo out > /sys/class/gpio/gpio103/direction");
+
+            // 复位继电器
+            if(cone==0){
+                system("echo 0 > /sys/class/gpio/gpio103/value"); // 设置低电平
+            }else{
+            system("echo 1 > /sys/class/gpio/gpio103/value"); // 设置高电平
+            }
+            std::cout << "Relay reset!" << std::endl;
+            
+    case 5:
+        system("echo 102 > /sys/class/gpio/export");
+                // 设置GPIO引脚为输出
+            system("echo out > /sys/class/gpio/gpio102/direction");
+
+            // 复位继电器
+            if(cone==0){
+                system("echo 0 > /sys/class/gpio/gpio102/value"); // 设置低电平
+            }else{
+            system("echo 1 > /sys/class/gpio/gpio102/value"); // 设置高电平
+            }
+            std::cout << "Relay reset!" << std::endl;
+
+        break;
+    default:
+        break;
+    }
+}
+
+
+// 添加ADC相关函数
+int readADCValue() {
+    const std::string adc_path = "/sys/bus/iio/devices/iio:device0/in_voltage2_raw";
+    std::ifstream file(adc_path);
+    if (!file.is_open()) {
+        std::cerr << "无法打开ADC文件" << std::endl;
+        return -1;
+    }
+    
+    int adc_value;
+    if (file >> adc_value) {
+        file.close();
+        return adc_value;
+    } else {
+        std::cerr << "读取ADC值失败" << std::endl;
+        file.close();
+        return -1;
+    }
+}
+
+
+void upload_WaterLevel(int _type,string msg);
+
+// 修改后的IO线程，集成ADC监控
+void* IO_serial_thread(void* args){
+    const int adc_threshold = 1000;
+    int adc_check_counter = 0; // 用于控制ADC检查频率
+    
+    while (true) {
+        this_thread::sleep_for(chrono::seconds(1));
+        
+        // ADC监控 - 每秒检查一次（可调整频率）
+        adc_check_counter++;
+        if (adc_check_counter >= 3600) { // 每一小时检查一次ADC，可修改频率
+            adc_check_counter = 0;
+            int adc_value = readADCValue();
+            if (adc_value != -1) {
+                std::cout << "ADC值: " << adc_value << std::endl;
+                
+                if (adc_value >= adc_threshold) {
+                    upload_WaterLevel(0,"Water_Normal");
+                }else{
+                    upload_WaterLevel(1,"Water_Lower");
+                }
+            }
+        }
+        
+        // 原有的继电器倒计时逻辑
+        for (int i = 0; i < 5; ++i) {
+            int Solenoid_valve = relay_state[i];
+            if (Solenoid_valve > 0) {
+                if (Solenoid_valve == 1) {
+                    // 倒计时结束，关闭 IO
+                    reset_relay(i+1, 0);
+                    std::cout << "继电器" << (i+1) << " 已关闭" << std::endl;
+                }
+                relay_state[i] = Solenoid_valve - 1;
+            }
+        }
+    }
 }
 
 // 播放音频的函数
@@ -482,6 +619,8 @@ int ALARM_TEMPERATURE;
 int WARN_TEMPERATURE;
 int MOVE_THRESHOLD;
 int IGNORE_TEMPERATURE;
+string ALARM_URL;
+string upload_url;
 double Confidence_Threshold;
 
 vector<vector<int>> last_result;
@@ -592,7 +731,7 @@ bool _geturlFromfile(const char* filepath, char* url, int maxLength) {
             while (*pline == ' ') {
                 pline++;
             }
-            int pline_len = strlen(pline) - 1;
+            int pline_len = strlen(pline);
             int version_len = (pline_len > maxLength ? maxLength : pline_len);
             memcpy(url, pline, version_len);
             printf("upload_url = %s\n", url);
@@ -871,11 +1010,12 @@ int main(int argc, char** argv)
         MOVE_THRESHOLD = Config_jsonData["MOVE_THRESHOLD"];
         IGNORE_TEMPERATURE = Config_jsonData["IGNORE_TEMPERATURE"];
         Confidence_Threshold = Config_jsonData["Confidence_Threshold"];
+        // ALARM_URL = Config_jsonData["alarm_URL"];
     }
     catch (const json::parse_error& e)
     {
         std::cerr << "JSON parsing error: " << e.what() << std::endl;
-        return 0;
+        //return 0;
     }
     file.close();
 
@@ -884,6 +1024,7 @@ int main(int argc, char** argv)
     cout << "配置 MOVE_THRESHOLD :" << MOVE_THRESHOLD << endl;
     cout << "配置 IGNORE_TEMPERATURE :" << IGNORE_TEMPERATURE << endl;
     cout << "配置 Confidence_Threshold :" << Confidence_Threshold << endl;
+    // cout << "配置 ALARM_URL :" << ALARM_URL << endl;//加入这一行
     cout << SERIAL_PORT_INFRARED_SENSOR << endl;
     cout << SERIAL_PORT_SOLENOID << endl;
 
@@ -947,16 +1088,22 @@ int main(int argc, char** argv)
         pthread_t heart_beat_tidp;
 
         pthread_t storage_serial;
+        pthread_t IO_serial;
         pthread_create(&storage_serial, NULL, storage_serial_thread, NULL);
+        pthread_create(&IO_serial, NULL, IO_serial_thread, NULL);
+
 
         pthread_create(&fire_rknn_tidp, NULL, rkmedia_rknn_thread, model_fire);
-        // pthread_create(&heart_beat_tidp, NULL, heart_beat, NULL);
+        pthread_create(&heart_beat_tidp, NULL, heart_beat, NULL);
         //串口读数据线程
         pthread_t read_serial;
         pthread_create(&read_serial, NULL, read_serial_thread, NULL);
         printf("%s initial finish\n", __func__);
 
  
+
+
+
         while (!quit)
         {
             usleep(500000);
@@ -1304,10 +1451,51 @@ void* rkmedia_rknn_thread(void* args)
             //if (result[1] == '1') ControlInstructions[(g_camera_number - 1) * 4 + 1] = 0x01;
             //if (result[2] == '1') ControlInstructions[(g_camera_number - 1) * 4 + 2] = 0x01;
             //if (result[3] == '1') ControlInstructions[(g_camera_number - 1) * 4 + 3] = 0x01;
-            if (result[0] == '1') ControlInstructions[0] = 0x01;
-            if (result[1] == '1') ControlInstructions[1] = 0x01;
-            if (result[2] == '1') ControlInstructions[2] = 0x01;
-            if (result[3] == '1') ControlInstructions[3] = 0x01;
+            if (result[0] == '1') {
+                ControlInstructions[0] = 0x01;
+                if(relay_state[0]==0){
+                    reset_relay(1,1);
+                }
+                relay_state[0]=6;
+                if(relay_state[4]==0){
+                    reset_relay(5,1);
+                }
+                relay_state[4]=6;
+            }
+            if (result[1] == '1') {
+                ControlInstructions[1] = 0x01;
+                if(relay_state[1]==0){
+                    reset_relay(2,1);
+                }
+                relay_state[1]=6;
+                if(relay_state[4]==0){
+                    reset_relay(5,1);
+                }
+                relay_state[4]=6;
+            }
+            if (result[2] == '1') {
+                ControlInstructions[2] = 0x01;
+                if(relay_state[2]==0){
+                    reset_relay(3,1);
+                }
+                relay_state[2]=6;
+                if(relay_state[4]==0){
+                    reset_relay(5,1);
+                }
+                relay_state[4]=6;
+            }
+            if (result[3] == '1') {
+                ControlInstructions[3] = 0x01;
+                if(relay_state[3]==0){
+                    reset_relay(4,1);
+                }
+                relay_state[3]=6;
+                if(relay_state[4]==0){
+                    reset_relay(5,1);
+                }
+                relay_state[4]=6;
+            }
+            
             std::string indices = generateIndices(result, &Alarm);
             std::cout << "结果: " << indices << std::endl;
             Alarm.alarmCoverage = indices;
@@ -1321,7 +1509,7 @@ void* rkmedia_rknn_thread(void* args)
             pid_t relay_pid = fork();
             if (relay_pid == 0) {
                 printf("kongzhi jidianqi\n");
-                reset_relay();
+                // reset_relay();    //电梯
                 exit(0);  // 子进程完成继电器控制后退出
             }
 
@@ -1391,6 +1579,7 @@ void* upload_message(void* args)
     pthread_detach(pthread_self());
     // 获取上报url
     char upload_url[200] = { 0 };
+    memset(upload_url,0,sizeof(upload_url));
     if (!_geturlFromfile(DOWNLOAD_VERSION_PATH, upload_url, sizeof(upload_url))) {
         printf("结束进程\n");
         return 0;
@@ -1467,9 +1656,6 @@ void* upload_message(void* args)
         curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
 
         res = curl_easy_perform(curl);
-        /* Check for errors */
-        // if(res != CURLE_OK)
-        //     fprintf(stderr, "curl_easy_perform() failed: %s\n",curl_easy_strerror(res));
         if (res != CURLE_OK) {
             std::cerr << "Failed to perform cURL request: " << curl_easy_strerror(res) << std::endl;
         }
@@ -1478,10 +1664,9 @@ void* upload_message(void* args)
             std::cout << "Response: " << response << std::endl;
         }
 
-
         curl_easy_cleanup(curl);
     }
-    curl_global_cleanup();
+    // curl_global_cleanup();
 }
 
 void* upload_message_controller(void* args)
@@ -1543,10 +1728,6 @@ void* upload_message_controller(void* args)
         curl_easy_setopt(curl, CURLOPT_POSTFIELDS, MessageString.c_str());
         curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
 
-        // std::string response;
-        // curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
-        // curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
-
         res = curl_easy_perform(curl);
         /* Check for errors */
         // if(res != CURLE_OK)
@@ -1562,37 +1743,55 @@ void* upload_message_controller(void* args)
 
         curl_easy_cleanup(curl);
     }
-    curl_global_cleanup();
+    // curl_global_cleanup();
 }
 
-void* heart_beat(void* args) {
-    pthread_detach(pthread_self());
-    auto last_time = std::chrono::high_resolution_clock::now();// 记录开始时间
-    int time2run = 1;
-    while (!quit) {
+void upload_WaterLevel(int _type,string msg)
+{
+    char upload_url[200] = { 0 };
 
-        auto current_time = std::chrono::high_resolution_clock::now();
-        auto elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(current_time - last_time);// 计算距离开始时间的时间差
-
-        if (elapsed_time.count() - 30000 > 0) {
-            last_time = current_time;
-            time2run = 1;
+    memset(upload_url,0,sizeof(upload_url));
+    if (!_geturlFromfile(DOWNLOAD_VERSION_PATH, upload_url, sizeof(upload_url))) {
+        printf("结束进程\n");
     }
+    // 获取当前系统时间
+    std::time_t alarmTime_std = std::time(nullptr);
+
+    // 将时间转换为本地时间
+    std::tm* localTime = std::localtime(&alarmTime_std);
+
+    // 从本地时间结构中获取时间信息
+    int year = localTime->tm_year + 1900;
+    int month = localTime->tm_mon + 1;
+    int day = localTime->tm_mday;
+    int hour = localTime->tm_hour;
+    int minute = localTime->tm_min;
+    int second = localTime->tm_sec;
+
+    // 拼接成字符串
+    std::ostringstream oss_alarmTime;
+    oss_alarmTime << std::setfill('0')
+        << std::setw(4) << year << "-"
+        << std::setw(2) << month << "-"
+        << std::setw(2) << day << " "
+        << std::setw(2) << hour << ":"
+        << std::setw(2) << minute << ":"
+        << std::setw(2) << second;
+
+    // 获取拼接后的字符串
+    std::string formattedTime = oss_alarmTime.str();
 
-        if (time2run) {
-            std::cout << "心跳上报" << std::endl;
     std::string cameraId = DeviceID;
-            std::string IP = "987654";
-            int state = 1;
-            std::string http_address = "http";
+std::string type = std::to_string(_type);
+    std::cout << "cameraid: " << cameraId << " msg: " << msg << std::endl;
 
     std::string MessageString =
-                R"({
-  "cameraId": ")" + cameraId + R"(",
-  "IP": ")" + IP + R"(",
-  "state": )" + std::to_string(state) + R"(,
-  "http_address": ")" + http_address + R"("
+        R"({"cameraid": ")" + cameraId + R"(",
+  "msg": ")" + msg + R"(",
+  "type": ")" + type + R"(",
+  "time": ")" + formattedTime +R"("
 })";
+
     CURL* curl;
     CURLcode res;
     curl_global_init(CURL_GLOBAL_ALL);
@@ -1600,8 +1799,8 @@ void* heart_beat(void* args) {
 
     if (curl)
     {
-                curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
-                curl_easy_setopt(curl, CURLOPT_URL, "http://192.168.1.23:9527/device/heartbeat");
+        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
+        curl_easy_setopt(curl, CURLOPT_URL, upload_url);
         /* Now specify the POST data */
         struct curl_slist* plist = nullptr;
         plist = curl_slist_append(plist, "Content-Type:application/json;charset=UTF-8");
@@ -1609,16 +1808,118 @@ void* heart_beat(void* args) {
         curl_easy_setopt(curl, CURLOPT_POSTFIELDS, MessageString.c_str());
 
         std::string response;
-                curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
         curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
         curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
+        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
 
         res = curl_easy_perform(curl);
         /* Check for errors */
         // if(res != CURLE_OK)
         //     fprintf(stderr, "curl_easy_perform() failed: %s\n",curl_easy_strerror(res));
         if (res != CURLE_OK) {
-                    std::cerr << "heart beat: Failed to perform cURL request: " << curl_easy_strerror(res) << std::endl;
+            std::cerr << "WaterLevel: Failed to perform cURL request: " << curl_easy_strerror(res) << std::endl;
+        }
+        else {
+            std::cout << "Request successful!" << std::endl;
+            std::cout << "Response: " << response << std::endl;
+        }
+
+        curl_easy_cleanup(curl);
+    }
+    // curl_global_cleanup();
+}
+
+
+std::string getEth0IPAddress() {
+    struct ifaddrs *ifaddrs_ptr, *ifa;
+    
+    // 获取所有网络接口信息
+    if (getifaddrs(&ifaddrs_ptr) == -1) {
+        std::cerr << "获取网络接口失败" << std::endl;
+        return "";
+    }
+
+    // 遍历所有网络接口
+    for (ifa = ifaddrs_ptr; ifa != nullptr; ifa = ifa->ifa_next) {
+        if (ifa->ifa_addr == nullptr) continue;
+
+        // 只处理eth0接口的IPv4地址
+        if (ifa->ifa_addr->sa_family == AF_INET && 
+            strcmp(ifa->ifa_name, "eth0") == 0) {
+
+            struct sockaddr_in* addr_in = (struct sockaddr_in*)ifa->ifa_addr;
+            char ip_str[INET_ADDRSTRLEN];
+            
+            // 将IP地址转换为字符串
+            if (inet_ntop(AF_INET, &(addr_in->sin_addr), ip_str, INET_ADDRSTRLEN)) {
+                return std::string(ip_str);
+            }
+        }
+    }
+    
+    freeifaddrs(ifaddrs_ptr);
+    return "";
+}
+
+//心跳
+void* heart_beat(void* args) {
+    char upload_url[200] = { 0 };
+    memset(upload_url,0,sizeof(upload_url));
+    if (!_geturlFromfile(DOWNLOAD_VERSION_PATH, upload_url, sizeof(upload_url))) {
+        printf("结束进程\n");
+    }
+    pthread_detach(pthread_self());
+    auto last_time = std::chrono::high_resolution_clock::now();// 记录开始时间
+    int time2run = 1;
+    while (!quit) {
+        // auto current_time = std::chrono::high_resolution_clock::now();
+        // auto elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(current_time - last_time);// 计算距离开始时间的时间差
+
+        // if (elapsed_time.count() - 30000 > 0) {
+        //     last_time = current_time;
+        //     time2run = 1;
+        // }
+
+        // if (time2run) {
+            std::cout << "心跳上报" << std::endl;
+            std::string cameraId = DeviceID;
+            std::string IP = getEth0IPAddress();
+            std::cout << "使用IP地址: " << IP << std::endl;
+            int state = 1;
+            std::string http_address = "http";
+
+            std::string MessageString =
+                R"({
+  "ID": ")" + cameraId + R"(",
+  "IP": ")" + IP + R"("
+})";
+            CURL* curl;
+            CURLcode res;
+            curl = curl_easy_init();
+
+            if (curl)
+            {
+        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
+        curl_easy_setopt(curl, CURLOPT_URL, upload_url);
+            std::cout << "upload_url地址: " << upload_url << std::endl;
+        /* Now specify the POST data */
+        struct curl_slist* plist = nullptr;
+        plist = curl_slist_append(plist, "Content-Type:application/json;charset=UTF-8");
+        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, plist);
+        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, MessageString.c_str());
+
+        std::string response;
+        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
+        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
+        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
+
+
+                res = curl_easy_perform(curl);
+                /* Check for errors */
+                // if(res != CURLE_OK)
+                //     fprintf(stderr, "curl_easy_perform() failed: %s\n",curl_easy_strerror(res));
+                if (res != CURLE_OK) {
+                    std::cerr << "heart beat: Failed to perform cURL request: " << res << std::endl;
                 }
                 else {
                     std::cout << "heart beat: Request successful!" << std::endl;
@@ -1640,9 +1941,11 @@ void* heart_beat(void* args) {
 
                 curl_easy_cleanup(curl);
             }
-            curl_global_cleanup();
-        }
-        time2run = 0;
+            // curl_global_cleanup();
+        // }
+        // time2run = 0;
+
+        this_thread::sleep_for(chrono::seconds(30));
     }
 }