1822 lines
60 KiB
C++
1822 lines
60 KiB
C++
#include "main.h"
|
||
//4 13 22 31
|
||
#include <opencv2/opencv.hpp>
|
||
#include <stdio.h>
|
||
#include <sys/time.h>
|
||
#include"yolov5_detect.h"
|
||
|
||
#include <iostream>
|
||
#include <chrono>
|
||
#include <thread>
|
||
#include <fstream>
|
||
#include <cstdio>
|
||
#include <iostream>
|
||
#include <fstream>
|
||
#include <cstring>
|
||
#include <vector>
|
||
#include <iomanip>
|
||
#include <filesystem>
|
||
#include <algorithm>
|
||
|
||
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <dlfcn.h>
|
||
#include <vector>
|
||
#include <string>
|
||
#include <stdbool.h>
|
||
#include <iostream>
|
||
#include <sys/stat.h>
|
||
#include <curl/curl.h>
|
||
#include <openssl/rsa.h>
|
||
#include <openssl/pem.h>
|
||
#include <openssl/err.h>
|
||
#include <nlohmann/json.hpp>
|
||
|
||
#include <jvbase/jlog.h>
|
||
#include <jvbase/jvtypes.h>
|
||
#include <jvbase/jstring.h>
|
||
#include <jbus.h>
|
||
#include <jes/jes_mss.h>
|
||
#include <jes/jes_isp.h>
|
||
#include <jes/jes_spk.h>
|
||
#include <jes/jes_bas.h>
|
||
#include "jlinux_uart.h"
|
||
|
||
#include <termios.h>
|
||
#include <cmath>
|
||
|
||
#include <nlohmann/json.hpp>
|
||
#include <mutex>
|
||
|
||
#define MSS_TEST_BUS_NAME "yolov5test"
|
||
static jbus_hdl_t g_jbus;
|
||
static jmss_hdl_t g_jmss;
|
||
static jisp_hdl_t g_jisp;
|
||
static bool g_running;
|
||
jmss_stm_t* g_stm[5];
|
||
static jbas_hdl_t jbas_handle;
|
||
|
||
#define modelpath_fire "/demo/bin/fire2025_pre.rknn"
|
||
#define DOWNLOAD_VERSION_PATH "/tmp/version"
|
||
#define ID_FILE_PWD "/etc/DeviceID"
|
||
std::string DeviceID;
|
||
std::string response_controllerId = "NULL";
|
||
|
||
static char labels_fire[2][20] = { "fire", "any" };
|
||
static char labels_smog[2][20] = { "smog", "any" };
|
||
|
||
#define SERIAL_PORT_INFRARED_SENSOR "/dev/ttyS4"
|
||
#define SERIAL_PORT_SOLENOID "/dev/ttyS5"
|
||
#define BAUD_RATE B115200
|
||
static int serialPortInfraredSensor;
|
||
static int serialPortSolenoid;
|
||
float temperature_img[24][32];
|
||
unsigned char buffer[1544];
|
||
|
||
std::mutex mtx;
|
||
std::vector<uint8_t> ControlInstructions(16, 0x00);
|
||
|
||
|
||
#define BAS_TEST_BUS_NAME "bastest"
|
||
jbas_hdl_t g_jbas;
|
||
|
||
#define PRSTR(val) printf("%s: %s\n", #val, (val) ? (val) : "(null)")
|
||
|
||
using namespace cv;
|
||
using namespace std;
|
||
using json = nlohmann::json;
|
||
|
||
|
||
// 定义GPIO控制引脚（假设GPIO2_B0已经设置好）
|
||
#define RELAY_GPIO_PIN 116 // 使用GPIO 72控制继电器
|
||
|
||
|
||
|
||
|
||
void hexdump(const char *buf, int len)
|
||
{
|
||
//printf("hexdump: len:%d \n", len);
|
||
for (int i = 0; i < len; i++)
|
||
{
|
||
printf("\033[0m\033[1;33m%02X \033[0m", buf[i], buf[i]);
|
||
}
|
||
printf("\n");
|
||
}
|
||
|
||
|
||
// 控制继电器复位的函数
|
||
void reset_relay() {
|
||
// 导出GPIO引脚
|
||
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秒
|
||
system("echo 0 > /sys/class/gpio/gpio116/value"); // 设置低电平
|
||
std::cout << "Relay reset!" << std::endl;
|
||
}
|
||
|
||
// 播放音频的函数
|
||
void play_audio(const std::string& file_path, jspk_hdl_t jspk) {
|
||
JES_SPK_PlayFile(jspk, file_path.c_str());
|
||
while (JES_SPK_IsBusy(jspk)) {
|
||
sleep(1);
|
||
}
|
||
std::cout << "Audio played: " << file_path << std::endl;
|
||
}
|
||
|
||
constexpr auto CONFIG_FILE = "/demo/bin/jh.json";
|
||
constexpr auto ID_FILE_PATH = "/etc/DeviceID";
|
||
constexpr auto LICENSE_FILE = "/demo/bin/activation.lic";
|
||
constexpr auto ENCRYPT_KEY = "YourSecretKey1234567890ABCDEF"; // 24字节密钥
|
||
|
||
// RSA公钥（PEM格式）
|
||
const string PUBLIC_KEY = R"(
|
||
-----BEGIN PUBLIC KEY-----
|
||
MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAK+UGGqE+K12kd5F5AH3GQNMSKZjq0l+IBTzF28YWTz+CWtRQ78eKOp3/fXZ8UBRQc2/nRT9Us24l9kPGJ2qUYECAwEAAQ==
|
||
-----END PUBLIC KEY-----
|
||
)";
|
||
|
||
// 全局变量
|
||
mutex activation_mutex;
|
||
|
||
class Config {
|
||
public:
|
||
static string getActivationUrl() {
|
||
try {
|
||
ifstream file(CONFIG_FILE);
|
||
if (!file) {
|
||
throw runtime_error("Config file not found");
|
||
}
|
||
|
||
json config = json::parse(file);
|
||
if (config.contains("activation_url")) {
|
||
string url = config["activation_url"];
|
||
cout << "[INFO] Using activation URL from JSON config: " << url << endl;
|
||
return url;
|
||
}
|
||
throw runtime_error("activation_url not found in config");
|
||
|
||
}
|
||
catch (const exception& e) {
|
||
cerr << "[WARN] " << e.what() << " - Using default URL" << endl;
|
||
return "http://183.238.1.242:8889/api/label/security";
|
||
}
|
||
}
|
||
};
|
||
|
||
class CryptoUtil {
|
||
public:
|
||
|
||
// 异或加密（保留原有逻辑）
|
||
static string xorEncrypt(const string& plaintext) {
|
||
string encrypted = xorCipher(plaintext, ENCRYPT_KEY);
|
||
return base64Encode(encrypted);
|
||
}
|
||
|
||
static string xorDecrypt(const string& ciphertext) {
|
||
string decoded = base64Decode(ciphertext);
|
||
return xorCipher(decoded, ENCRYPT_KEY);
|
||
}
|
||
|
||
// URL编码
|
||
static string urlEncode(const string& value) {
|
||
ostringstream escaped;
|
||
escaped.fill('0');
|
||
escaped << hex;
|
||
for (char c : value) {
|
||
if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
|
||
escaped << c;
|
||
}
|
||
else {
|
||
escaped << '%' << setw(2) << int((unsigned char)c);
|
||
}
|
||
}
|
||
return escaped.str();
|
||
}
|
||
|
||
// 新增RSA加密
|
||
static string rsaEncrypt(const string& plaintext) {
|
||
RSA* rsa = nullptr;
|
||
BIO* bio = nullptr;
|
||
string result;
|
||
|
||
try {
|
||
bio = BIO_new_mem_buf(PUBLIC_KEY.c_str(), -1);
|
||
// rsa = PEM_read_bio_RSA_PUBKEY(bio, nullptr, nullptr, nullptr);
|
||
rsa = PEM_read_bio_RSA_PUBKEY(bio, nullptr, nullptr, nullptr);
|
||
if (!rsa) throw runtime_error("PEM_read_bio_RSA_PUBKEY failed");
|
||
|
||
int keySize = RSA_size(rsa);
|
||
vector<unsigned char> encrypted(keySize);
|
||
|
||
int len = RSA_public_encrypt(
|
||
plaintext.size(),
|
||
reinterpret_cast<const unsigned char*>(plaintext.c_str()),
|
||
encrypted.data(),
|
||
rsa,
|
||
RSA_PKCS1_PADDING
|
||
);
|
||
|
||
if (len == -1) throw runtime_error("RSA encryption failed");
|
||
|
||
result = base64Encode(encrypted.data(), len);
|
||
|
||
}
|
||
catch (const exception& e) {
|
||
cerr << "[ERROR] RSA encryption failed: " << e.what() << endl;
|
||
ERR_print_errors_fp(stderr);
|
||
result.clear();
|
||
}
|
||
|
||
if (rsa) RSA_free(rsa);
|
||
if (bio) BIO_free_all(bio);
|
||
return result;
|
||
}
|
||
|
||
private:
|
||
static string xorCipher(const string& data, const string& key) {
|
||
string result;
|
||
for (size_t i = 0; i < data.size(); ++i) {
|
||
result += data[i] ^ key[i % key.size()];
|
||
}
|
||
return result;
|
||
}
|
||
|
||
static string base64Encode(const string& data) {
|
||
BIO* bio, * b64;
|
||
BUF_MEM* bufferPtr;
|
||
|
||
b64 = BIO_new(BIO_f_base64());
|
||
bio = BIO_new(BIO_s_mem());
|
||
bio = BIO_push(b64, bio);
|
||
|
||
BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
|
||
BIO_write(bio, data.c_str(), data.size());
|
||
BIO_flush(bio);
|
||
BIO_get_mem_ptr(bio, &bufferPtr);
|
||
BIO_set_close(bio, BIO_NOCLOSE);
|
||
BIO_free_all(bio);
|
||
|
||
return string(bufferPtr->data, bufferPtr->length);
|
||
}
|
||
|
||
static string base64Encode(const unsigned char* data, size_t len) {
|
||
BIO* b64 = BIO_new(BIO_f_base64());
|
||
BIO* mem = BIO_new(BIO_s_mem());
|
||
BIO_push(b64, mem);
|
||
|
||
BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
|
||
BIO_write(b64, data, len);
|
||
BIO_flush(b64);
|
||
|
||
char* ptr;
|
||
long size = BIO_get_mem_data(mem, &ptr);
|
||
string result(ptr, size);
|
||
|
||
BIO_free_all(b64);
|
||
return result;
|
||
}
|
||
|
||
static string base64Decode(const string& encoded) {
|
||
BIO* bio, * b64;
|
||
char* buffer = (char*)malloc(encoded.size());
|
||
memset(buffer, 0, encoded.size());
|
||
|
||
bio = BIO_new_mem_buf(encoded.c_str(), -1);
|
||
b64 = BIO_new(BIO_f_base64());
|
||
bio = BIO_push(b64, bio);
|
||
|
||
BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
|
||
int len = BIO_read(bio, buffer, encoded.size());
|
||
BIO_free_all(bio);
|
||
|
||
string result(buffer, len);
|
||
free(buffer);
|
||
return result;
|
||
}
|
||
};
|
||
|
||
class NetworkUtil {
|
||
public:
|
||
static int postRequest(const string& url, const string& postData, string& response) {
|
||
CURL* curl = curl_easy_init();
|
||
if (!curl) return CURLE_FAILED_INIT;
|
||
|
||
// 使用RSA加密数据
|
||
string encryptedData = CryptoUtil::rsaEncrypt(postData);
|
||
string urlEncodedData = CryptoUtil::urlEncode(encryptedData);
|
||
|
||
struct curl_slist* headers = nullptr;
|
||
headers = curl_slist_append(headers, "Accept: application/json"); // 修改Content-Type
|
||
|
||
const string full_url = url + "?id=" + urlEncodedData;
|
||
// cout << "[DEBUG] full_url: " << full_url << endl;
|
||
|
||
curl_easy_setopt(curl, CURLOPT_URL, full_url.c_str());
|
||
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
|
||
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeCallback);
|
||
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
|
||
curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
|
||
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
|
||
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2L);
|
||
|
||
CURLcode res = curl_easy_perform(curl);
|
||
curl_easy_cleanup(curl);
|
||
curl_slist_free_all(headers);
|
||
return res;
|
||
}
|
||
|
||
private:
|
||
static size_t writeCallback(void* contents, size_t size, size_t nmemb, string* output) {
|
||
output->append(static_cast<char*>(contents), size * nmemb);
|
||
return size * nmemb;
|
||
}
|
||
};
|
||
|
||
class ActivationManager {
|
||
public:
|
||
explicit ActivationManager(string device_id, string mac)
|
||
: device_id_(move(device_id)), mac_(move(mac)) {}
|
||
|
||
bool checkActivation() {
|
||
lock_guard<mutex> lock(activation_mutex);
|
||
|
||
if (checkLocalLicense()) {
|
||
cout << "[INFO] Device already activated" << endl;
|
||
return true;
|
||
}
|
||
return processOnlineActivation();
|
||
}
|
||
|
||
private:
|
||
string device_id_;
|
||
string mac_;
|
||
|
||
bool checkLocalLicense() {
|
||
ifstream file(LICENSE_FILE, ios::binary);
|
||
if (!file) return false;
|
||
|
||
string encrypted((istreambuf_iterator<char>(file)), istreambuf_iterator<char>());
|
||
return validateLicense(encrypted);
|
||
}
|
||
|
||
bool validateLicense(const string& encrypted) {
|
||
// 修改为使用xorDecrypt
|
||
string decrypted = CryptoUtil::xorDecrypt(encrypted);
|
||
auto pos = decrypted.find('|');
|
||
if (pos == string::npos) return false;
|
||
|
||
string storedId = decrypted.substr(0, pos);
|
||
string storedMac = decrypted.substr(pos + 1);
|
||
|
||
return (storedId == device_id_ && storedMac == mac_);
|
||
}
|
||
|
||
bool processOnlineActivation(int retry_count = 3) {
|
||
string activation_url = Config::getActivationUrl();
|
||
const string post_data = device_id_ + "|" + mac_;
|
||
cout << "[DEBUG] Original POST data: " << post_data << endl;
|
||
|
||
for (int i = 0; i < retry_count; ++i) {
|
||
string response;
|
||
int curl_code = NetworkUtil::postRequest(activation_url, post_data, response);
|
||
|
||
if (curl_code != CURLE_OK) {
|
||
cerr << "[ERROR] Network error: " << curl_easy_strerror((CURLcode)curl_code) << endl;
|
||
continue;
|
||
}
|
||
|
||
try {
|
||
auto json_resp = json::parse(response);
|
||
int code = json_resp["code"].get<int>();
|
||
|
||
if (code == 0) {
|
||
generateLicenseFile(device_id_ + "|" + mac_);
|
||
return true;
|
||
}
|
||
|
||
if (code == 60001 || code == 60002) {
|
||
cerr << "[FATAL] Activation failed: " << json_resp["msg"].get<string>() << endl;
|
||
return false;
|
||
}
|
||
|
||
if (code == 60003 && i < retry_count - 1) {
|
||
cout << "[WARN] Retrying... (" << i + 1 << "/" << retry_count << ")" << endl;
|
||
this_thread::sleep_for(chrono::seconds(1));
|
||
continue;
|
||
}
|
||
return false;
|
||
|
||
}
|
||
catch (const json::exception& e) {
|
||
cerr << "[ERROR] JSON parse error: " << e.what() << endl;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void generateLicenseFile(const string& data) {
|
||
ofstream file(LICENSE_FILE, ios::binary);
|
||
// 修改为使用xorEncrypt
|
||
string encrypted = CryptoUtil::xorEncrypt(data);
|
||
file.write(encrypted.data(), encrypted.size());
|
||
cout << "[INFO] License file created successfully" << endl;
|
||
}
|
||
};
|
||
|
||
string getDeviceID() {
|
||
ifstream file(ID_FILE_PATH);
|
||
string id;
|
||
if (!getline(file, id)) throw runtime_error("Failed to read device ID");
|
||
return id;
|
||
}
|
||
|
||
string getMACAddress() {
|
||
const vector<string> interfaces = { "eth0", "eth1", "enp0s3", "wlan0" };
|
||
|
||
for (const auto& iface : interfaces) {
|
||
ifstream file("/sys/class/net/" + iface + "/address");
|
||
if (file) {
|
||
string mac;
|
||
getline(file, mac);
|
||
mac.erase(remove(mac.begin(), mac.end(), '\n'), mac.end());
|
||
|
||
if (mac.length() == 17 && count(mac.begin(), mac.end(), ':') == 5) {
|
||
return mac;
|
||
}
|
||
}
|
||
}
|
||
throw runtime_error("No valid MAC address found");
|
||
}
|
||
|
||
|
||
// 获取设备信息
|
||
int g_camera_number = 1;
|
||
|
||
std::string generateIndices(char result[4], Alarm* Alarm) {
|
||
std::string indices(16, '0');
|
||
|
||
int CA_ID = g_camera_number;
|
||
|
||
int start = (CA_ID - 1) * 4;
|
||
|
||
for (int i = 0; i < 4; ++i) {
|
||
if (result[i] == '1') {
|
||
indices[start + i] = '1';
|
||
Alarm->ifalarm = 1;
|
||
}
|
||
}
|
||
|
||
return indices;
|
||
}
|
||
|
||
|
||
|
||
|
||
int ALARM_TEMPERATURE;
|
||
int WARN_TEMPERATURE;
|
||
int MOVE_THRESHOLD;
|
||
int IGNORE_TEMPERATURE;
|
||
double Confidence_Threshold;
|
||
|
||
vector<vector<int>> last_result;
|
||
auto last_result_time = std::chrono::high_resolution_clock::now();// 时间
|
||
vector<vector<int>> now_result;
|
||
|
||
int width = 1920, height = 1080;
|
||
JMediaRawFrameType_e type = JMEDIA_RAWFRAMETYPE_NV12;
|
||
|
||
|
||
bool check_whether_in_last_result(vector<vector<int>>& last_result, vector<int>& now, std::ofstream& temperature_log) {
|
||
if (last_result.empty()) return true;
|
||
//查找now的框坐标是否有出现在上一帧
|
||
for (auto i : last_result) {
|
||
//范围5像素以内都视为不变
|
||
if (abs(i[0] - now[0]) <= MOVE_THRESHOLD && abs(i[1] - now[1]) <= MOVE_THRESHOLD && abs(i[2] - now[2]) <= MOVE_THRESHOLD && abs(i[3] - now[3]) <= MOVE_THRESHOLD) {
|
||
temperature_log << "有重复 此帧结果：(" << now[0] << " " << now[1] << ") (" << now[2] << " " << now[3] << ")"
|
||
<< " 上帧结果：(" << i[0] << " " << i[1] << ") (" << i[2] << " " << i[3] << ")" << endl;
|
||
cout << "上帧结果：(" << i[0] << " " << i[1] << ") (" << i[2] << " " << i[3] << ")" << endl;
|
||
cout << "此帧结果：(" << now[0] << " " << now[1] << ") (" << now[2] << " " << now[3] << ")" << endl;
|
||
return true;
|
||
}
|
||
}
|
||
cout << "无重复 此帧结果：(" << now[0] << " " << now[1] << ") (" << now[2] << " " << now[3] << ")" << endl;
|
||
temperature_log << "无重复 此帧结果：(" << now[0] << " " << now[1] << ") (" << now[2] << " " << now[3] << ")" << endl;
|
||
return false;
|
||
}
|
||
|
||
|
||
string Get_Time(int input) {
|
||
// 获取当前系统时间
|
||
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;
|
||
if (input == 1) {
|
||
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;
|
||
}
|
||
else {
|
||
oss_alarmTime << std::setfill('0')
|
||
<< 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();
|
||
return formattedTime;
|
||
}
|
||
|
||
|
||
|
||
double calibration(double x) {
|
||
double p1 = -9.052e-08;
|
||
double p2 = 8.313e-05;
|
||
double p3 = -0.02813;
|
||
double p4 = 4.16;
|
||
double p5 = -219.7;
|
||
double res = p1 * pow(x, 4) + p2 * pow(x, 3) + p3 * pow(x, 2) + p4 * x + p5;
|
||
return res;
|
||
}
|
||
|
||
|
||
size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* response) {
|
||
size_t totalSize = size * nmemb;
|
||
response->append(static_cast<char*>(contents), totalSize);
|
||
return totalSize;
|
||
}
|
||
|
||
|
||
bool _geturlFromfile(const char* filepath, char* url, int maxLength) {
|
||
if (filepath == NULL) {
|
||
printf("getrulVersion is error, url == null.\n");
|
||
return false;
|
||
}
|
||
FILE* fp = fopen(filepath, "r");
|
||
if (fp == NULL) {
|
||
printf("open %s failed, error is %s.\n", filepath, strerror(errno));
|
||
return false;
|
||
}
|
||
int iffind = 0;
|
||
char* line = NULL;
|
||
size_t len = 0;
|
||
size_t read;
|
||
while ((read = getline(&line, &len, fp)) != -1) {
|
||
if (read == 0 || line[0] == '#') {
|
||
continue;
|
||
}
|
||
char* pline = strstr(line, "upload_url");
|
||
if (pline != NULL && (pline = strstr(pline, "=")) != NULL) {
|
||
pline++; //过滤掉等于号
|
||
//过滤掉空格
|
||
while (*pline == ' ') {
|
||
pline++;
|
||
}
|
||
int pline_len = strlen(pline) - 1;
|
||
int version_len = (pline_len > maxLength ? maxLength : pline_len);
|
||
memcpy(url, pline, version_len);
|
||
printf("upload_url = %s\n", url);
|
||
iffind = 1;
|
||
break;
|
||
}
|
||
}
|
||
if (iffind == 0) {
|
||
printf("Can not find upload_url\n");
|
||
return false;
|
||
}
|
||
free(line);
|
||
fclose(fp);
|
||
return true;
|
||
}
|
||
|
||
|
||
// 函数用于读取文件并将其内容保存在全局字符串变量中
|
||
void readFileAndStoreInGlobal(const std::string& filename) {
|
||
std::ifstream file(filename);
|
||
if (file.is_open()) {
|
||
std::getline(file, DeviceID); // 读取一行并存储在全局字符串中
|
||
file.close();
|
||
}
|
||
else {
|
||
std::cerr << "无法打开文件: " << filename << std::endl;
|
||
}
|
||
}
|
||
|
||
|
||
// std::string generateIndices(char result[4],Alarm* Alarm) {
|
||
// std::string indices;
|
||
// for (int i = 0; i < 4; ++i) {
|
||
// if (result[i] == '1') {
|
||
// // 将索引值加入到生成的字符串中
|
||
// indices += std::to_string(i + 1);
|
||
// Alarm->ifalarm = 1;
|
||
// }
|
||
// }
|
||
// return indices;
|
||
// }
|
||
|
||
|
||
|
||
|
||
|
||
void checkCoverage(int x1, int x2, int width, char result[4]) {
|
||
// 初始化为 '1'，表示覆盖
|
||
// std::string resultString1(result, 4);
|
||
// std::cout << "result in: " << resultString1 << std::endl;
|
||
char result_now[4] = { '1','1','1','1' };
|
||
int line1 = width * 7 / 32;
|
||
int line2 = width / 2;
|
||
int line3 = width * 25 / 32;
|
||
if (x1 > line1) {
|
||
result_now[3] = '0';
|
||
}
|
||
if (x1 > line2) {
|
||
result_now[3] = '0';
|
||
result_now[2] = '0';
|
||
}
|
||
if (x1 > line3) {
|
||
result_now[3] = '0';
|
||
result_now[2] = '0';
|
||
result_now[1] = '0';
|
||
}
|
||
|
||
if (x2 < line3) {
|
||
result_now[0] = '0';
|
||
}
|
||
if (x2 < line2) {
|
||
result_now[0] = '0';
|
||
result_now[1] = '0';
|
||
}
|
||
if (x2 < line1) {
|
||
result_now[0] = '0';
|
||
result_now[1] = '0';
|
||
result_now[2] = '0';
|
||
}
|
||
result[0] = result[0] | result_now[0];
|
||
result[1] = result[1] | result_now[1];
|
||
result[2] = result[2] | result_now[2];
|
||
result[3] = result[3] | result_now[3];
|
||
}
|
||
|
||
|
||
//用于resul_warn和result_fire的与操作。
|
||
void and_result(char result1[4], char result2[4]) {
|
||
result1[0] = result1[0] & result2[0];
|
||
result1[1] = result1[1] & result2[1];
|
||
result1[2] = result1[2] & result2[2];
|
||
result1[3] = result1[3] & result2[3];
|
||
std::string resultString(result1, 4);
|
||
// 打印结果字符串
|
||
std::cout << "与后结果: " << resultString << std::endl;
|
||
}
|
||
|
||
|
||
//用于resul_warn和result_fire的与操作。
|
||
void or_result(char result1[4], char result2[4]) {
|
||
result1[0] = result1[0] | result2[0];
|
||
result1[1] = result1[1] | result2[1];
|
||
result1[2] = result1[2] | result2[2];
|
||
result1[3] = result1[3] | result2[3];
|
||
std::string resultString(result1, 4);
|
||
// 打印结果字符串
|
||
std::cout << "或后结果: " << resultString << std::endl;
|
||
}
|
||
|
||
|
||
void getLabels(const char* path, char labels[2][20]) {
|
||
if (strcmp(path, modelpath_fire) == 0) {
|
||
std::cout << "Labels for fire model" << std::endl;
|
||
strcpy(labels[0], labels_fire[0]);
|
||
strcpy(labels[1], labels_fire[1]);
|
||
}
|
||
else {
|
||
std::cout << "Null labels" << std::endl;
|
||
strcpy(labels[0], "null");
|
||
strcpy(labels[1], "null");
|
||
}
|
||
}
|
||
|
||
|
||
static Scalar colorArray[10] = {
|
||
Scalar(255, 0, 0, 255),
|
||
Scalar(0, 255, 0, 255),
|
||
Scalar(0,0,139,255),
|
||
Scalar(0,100,0,255),
|
||
Scalar(139,139,0,255),
|
||
Scalar(209,206,0,255),
|
||
Scalar(0,127,255,255),
|
||
Scalar(139,61,72,255),
|
||
Scalar(0,255,0,255),
|
||
Scalar(255,0,0,255),
|
||
};
|
||
|
||
|
||
int plot_one_box(Mat src, int x1, int x2, int y1, int y2, char* label, char colour)
|
||
{
|
||
int tl = round(0.002 * (src.rows + src.cols) / 2) + 1;
|
||
rectangle(src, cv::Point(x1, y1), cv::Point(x2, y2), colorArray[colour], 3);
|
||
int tf = max(tl - 1, 1);
|
||
int base_line = 0;
|
||
cv::Size t_size = getTextSize(label, FONT_HERSHEY_SIMPLEX, (float)tl / 3, tf, &base_line);
|
||
int x3 = x1 + t_size.width;
|
||
int y3 = y1 - t_size.height - 3;
|
||
rectangle(src, cv::Point(x1, y1), cv::Point(x3, y3), colorArray[colour], -1);
|
||
putText(src, label, cv::Point(x1, y1 - 2), FONT_HERSHEY_SIMPLEX, (float)tl / 3, cv::Scalar(255, 255, 255, 255), tf, 8);
|
||
return 0;
|
||
}
|
||
|
||
|
||
bool directoryExists(const std::string& path) {
|
||
struct stat info;
|
||
if (stat(path.c_str(), &info) != 0) {
|
||
return false; // 文件夹不存在
|
||
}
|
||
else if (info.st_mode & S_IFDIR) {
|
||
return true; // 文件夹存在
|
||
}
|
||
return false; // 存在但不是文件夹
|
||
}
|
||
|
||
|
||
bool createDirectory(const std::string& path) {
|
||
if (!directoryExists(path)) {
|
||
if (mkdir(path.c_str(), 0755) == 0) {
|
||
std::cout << "文件夹创建成功: " << path << std::endl;
|
||
return true;
|
||
}
|
||
else {
|
||
std::cerr << "文件夹创建失败: " << strerror(errno) << std::endl;
|
||
return false;
|
||
}
|
||
}
|
||
else {
|
||
std::cout << "文件夹已存在: " << path << std::endl;
|
||
return true;
|
||
}
|
||
}
|
||
|
||
|
||
//计算校验和
|
||
uint8_t calculateChecksum(const std::vector<uint8_t>& data) {
|
||
uint16_t sum = 0;
|
||
for (size_t i = 0; i < data.size() - 1; ++i) {
|
||
sum += data[i];
|
||
}
|
||
return static_cast<uint8_t>(sum & 0xFF);
|
||
}
|
||
|
||
|
||
void printVector(const std::vector<uint8_t>& vec) {
|
||
std::cout << "Vector contents: ";
|
||
for (const auto& byte : vec) {
|
||
std::cout << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(byte) << " ";
|
||
}
|
||
std::cout << std::dec << std::endl; // 切换回十进制
|
||
}
|
||
|
||
|
||
int main(int argc, char** argv)
|
||
{
|
||
std::string folderPath = "/demo/pic";
|
||
if (!createDirectory(folderPath)) {
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
// 获取设备信息
|
||
jbus_hdl_t jbus = jbus_init("devinfo_test_app");
|
||
if (!jbus) {
|
||
fprintf(stderr, "Error: jbus_init() failed.\n");
|
||
return EXIT_FAILURE;
|
||
}
|
||
|
||
jbas_handle = JES_BAS_Init(jbus);
|
||
if (!jbas_handle) {
|
||
fprintf(stderr, "Error: JES_BAS_Init() failed.\n");
|
||
jbus_cleanup(jbus);
|
||
return EXIT_FAILURE;
|
||
}
|
||
|
||
JBASDevInfo_t devinfo;
|
||
int results = JES_BAS_GetDevInfo(jbas_handle, &devinfo, JFALSE);
|
||
|
||
if (results == 0) {
|
||
printf("Successfully retrieved device information:\n");
|
||
PRSTR(devinfo.devname);
|
||
string CA_ID = devinfo.devname;
|
||
PRSTR(devinfo.language);
|
||
|
||
//获取设备
|
||
// 提取设备名称中的摄像头编号
|
||
if (!CA_ID.empty()) {
|
||
char lastChar = CA_ID.back(); // 获取最后一个字符
|
||
if (isdigit(lastChar) && lastChar >= '1' && lastChar <= '4') {
|
||
g_camera_number = lastChar - '0'; // 转换为整数，例如 '2' -> 2
|
||
}
|
||
else {
|
||
g_camera_number = 1; // 默认值
|
||
fprintf(stderr, "Warning: Invalid device name format: %s\n", CA_ID.c_str());
|
||
}
|
||
}
|
||
else {
|
||
g_camera_number = 1; // 默认值
|
||
fprintf(stderr, "Warning: Device name is empty\n");
|
||
}
|
||
|
||
// 打印验证
|
||
printf("Camera number: %d\n", g_camera_number);
|
||
}
|
||
|
||
|
||
// 打开 JSON 文件
|
||
cout << "解析JSON文件" << endl;
|
||
std::ifstream file("/demo/bin/config.json");
|
||
|
||
// 检查文件是否成功打开
|
||
if (!file.is_open()) {
|
||
std::cerr << "Failed to open json file" << std::endl;
|
||
return 1;
|
||
}
|
||
|
||
try {
|
||
// 解析 JSON 文件
|
||
json Config_jsonData;
|
||
file >> Config_jsonData;
|
||
// 关闭文件
|
||
|
||
// 赋值给全局常量
|
||
WARN_TEMPERATURE = Config_jsonData["WARN_TEMPERATURE"];
|
||
ALARM_TEMPERATURE = Config_jsonData["ALARM_TEMPERATURE"];
|
||
MOVE_THRESHOLD = Config_jsonData["MOVE_THRESHOLD"];
|
||
IGNORE_TEMPERATURE = Config_jsonData["IGNORE_TEMPERATURE"];
|
||
Confidence_Threshold = Config_jsonData["Confidence_Threshold"];
|
||
}
|
||
catch (const json::parse_error& e)
|
||
{
|
||
std::cerr << "JSON parsing error: " << e.what() << std::endl;
|
||
return 0;
|
||
}
|
||
file.close();
|
||
|
||
cout << "配置 WARN_TEMPERATURE :" << WARN_TEMPERATURE << endl;
|
||
cout << "配置 ALARM_TEMPERATURE :" << ALARM_TEMPERATURE << endl;
|
||
cout << "配置 MOVE_THRESHOLD :" << MOVE_THRESHOLD << endl;
|
||
cout << "配置 IGNORE_TEMPERATURE :" << IGNORE_TEMPERATURE << endl;
|
||
cout << "配置 Confidence_Threshold :" << Confidence_Threshold << endl;
|
||
cout << SERIAL_PORT_INFRARED_SENSOR << endl;
|
||
cout << SERIAL_PORT_SOLENOID << endl;
|
||
|
||
try {
|
||
const string device_id = getDeviceID();
|
||
const string mac = getMACAddress();
|
||
|
||
cout << "Device ID: " << device_id << "\nMAC: " << mac << endl;
|
||
|
||
// 验证RSA加密
|
||
// cout << "\n--- RSA Encryption Test ---" << endl;
|
||
// string test_data = device_id + "|" + mac;
|
||
// cout << "[TEST] Original data: " << test_data << endl;
|
||
|
||
// string encrypted = CryptoUtil::rsaEncrypt(test_data);
|
||
// cout << "[TEST] Encrypted data (Base64): " << encrypted << endl;
|
||
// cout << "[TEST] URL Encoded data: " << CryptoUtil::urlEncode(encrypted) << endl;
|
||
|
||
|
||
// 执行激活流程
|
||
cout << "\n--- Activation Process ---" << endl;
|
||
ActivationManager activator(device_id, mac);
|
||
if (!activator.checkActivation()) {
|
||
cerr << "[FATAL] Activation failed" << endl;
|
||
return EXIT_FAILURE;
|
||
}
|
||
|
||
cout << "\nStarting algorithm..." << endl;
|
||
// 主程序逻辑
|
||
|
||
|
||
g_jbus = jbus_init(MSS_TEST_BUS_NAME);
|
||
printf("jbus_init success\n");
|
||
g_jmss = JES_MSS_Init(g_jbus);
|
||
printf("JES_MSS_Init success\n");
|
||
g_jisp = JES_ISP_Init(g_jbus);
|
||
printf("JES_ISP_Init success\n");
|
||
char ispver[128] = {};
|
||
JES_ISP_GetVersion(g_jisp, 0, ispver, sizeof(ispver));
|
||
printf("ispver: %s\n", ispver);
|
||
sleep(1);
|
||
|
||
|
||
JMediaRawFrameType_e type = argc >= 2 ? (JMediaRawFrameType_e)atoi(argv[1]) : JMEDIA_RAWFRAMETYPE_NV12;
|
||
int width = 1920, height = 1080;
|
||
jmss_raw_t* rawchn = JES_MSS_RawOpen(g_jmss, 0, width, height, type);
|
||
if (rawchn == NULL) {
|
||
printf("==============>>>: %s:%d open rawchn failed\n", strrchr(__FILE__, '/'), __LINE__);
|
||
return -1;
|
||
}
|
||
int ret;
|
||
|
||
|
||
readFileAndStoreInGlobal((char*)ID_FILE_PWD);
|
||
// 打印全局字符串变量
|
||
std::cout << "ID内容：" << DeviceID << std::endl;
|
||
char model_fire[] = modelpath_fire;
|
||
pthread_t rtsp_tidp;
|
||
pthread_t fire_rknn_tidp;
|
||
pthread_t smog_rknn_tidp;
|
||
pthread_t heart_beat_tidp;
|
||
|
||
pthread_t storage_serial;
|
||
pthread_create(&storage_serial, NULL, storage_serial_thread, NULL);
|
||
|
||
pthread_create(&fire_rknn_tidp, NULL, rkmedia_rknn_thread, model_fire);
|
||
// 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);
|
||
}
|
||
|
||
JES_MSS_Deinit(g_jmss);
|
||
JES_ISP_Deinit(g_jisp);
|
||
jbus_cleanup(g_jbus);
|
||
|
||
}
|
||
catch (const exception& e) {
|
||
cerr << "[FATAL] " << e.what() << endl;
|
||
return EXIT_FAILURE;
|
||
}
|
||
return EXIT_SUCCESS;
|
||
}
|
||
|
||
void* rkmedia_rknn_thread(void* args)
|
||
{
|
||
pthread_detach(pthread_self());
|
||
|
||
|
||
//初始化协议信息
|
||
// ControlInstructions[0] = 0xCA; //协议头
|
||
// ControlInstructions[1] = 0x14; //总长度
|
||
// ControlInstructions[2] = 0x01; //操作指令
|
||
|
||
//打开JES的通道
|
||
jmss_raw_t* rawchn = JES_MSS_RawOpen(g_jmss, 0, width, height, type);
|
||
if (rawchn == NULL) {
|
||
printf("==============>>>: %s:%d open rawchn failed\n", strrchr(__FILE__, '/'), __LINE__);
|
||
}
|
||
//日志相关内容
|
||
std::string filename = "/demo/bin/temperature_log.txt";
|
||
std::ofstream temperature_log(filename, std::ios::out | std::ios::trunc);
|
||
temperature_log << "配置 WARN_TEMPERATURE :" << WARN_TEMPERATURE << endl;
|
||
temperature_log << "配置 ALARM_TEMPERATURE :" << ALARM_TEMPERATURE << endl;
|
||
temperature_log << "配置 MOVE_THRESHOLD :" << MOVE_THRESHOLD << endl;
|
||
temperature_log << "配置 IGNORE_TEMPERATURE :" << IGNORE_TEMPERATURE << endl;
|
||
temperature_log << "配置 Confidence_Threshold :" << Confidence_Threshold << endl;
|
||
//环境温度
|
||
double temp_env = 0;
|
||
|
||
auto last_time = std::chrono::high_resolution_clock::now();// 记录开始时间
|
||
// 创建一个 Alarm 结构体对象
|
||
Alarm Alarm;
|
||
// 调用初始化函数来初始化结构体成员
|
||
initializeAlarm(&Alarm);
|
||
//用于从全局buffer中复制数据
|
||
unsigned char copyBuffer[1544];
|
||
|
||
/* 参数初始化 */
|
||
int output_nboxes_left = 0;
|
||
yolov5_detect_result_group_t detect_result_group;
|
||
|
||
/* 算法模型初始化 */
|
||
char* path = reinterpret_cast<char*>(args);
|
||
printf("loading model %s\n", path);
|
||
rknn_context ctx;
|
||
yolov5_detect_init(&ctx, path);
|
||
// yolov5_detect_init(&ctx, "./fire_rv1126.rknn");
|
||
|
||
//配置label
|
||
char labels[2][20];
|
||
getLabels(path, labels);
|
||
// 设置压缩质量
|
||
std::vector<int> compression_params;
|
||
compression_params.push_back(cv::IMWRITE_JPEG_QUALITY);
|
||
compression_params.push_back(30); // 设置压缩质量，范围为 0-100
|
||
int overtem_cnt = 0;
|
||
std::vector<int> over_tmp_deque(10, 0);
|
||
|
||
|
||
/* 算法运行 */
|
||
while (!quit) {
|
||
int time2run = 1;
|
||
// 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() - 1000 > 0) {
|
||
// last_time = current_time;
|
||
// time2run = 1;
|
||
// }
|
||
sleep(2);
|
||
//获取摄像头buffer
|
||
JVMediaFrame_t frm;
|
||
if (JES_MSS_RawGetFrame(rawchn, &frm) < 0) {
|
||
sleep(1);
|
||
continue;
|
||
}
|
||
int overtmp_falg = 0;
|
||
Alarm.ifalarm = 0;
|
||
Alarm.ifwarn = 0;
|
||
|
||
// // int JES_MCS_GetLinkageList(jmcs_hdl_t hdl, JMCSLinkageList_t *list);
|
||
// JBOOL reverse = JTRUE;
|
||
// JBASDevInfo_t devinfo;
|
||
// JES_BAS_GetDevInfo(g_jbas, &devinfo, JTRUE);
|
||
// PRSTR(devinfo.devname);
|
||
// PRSTR(devinfo.language);
|
||
|
||
Mat src;
|
||
NV12ToRGB(width, height, frm.buffer, src);
|
||
//裁剪
|
||
cv::Rect roi(220, 130, 1480, 570);
|
||
src = src(roi);
|
||
//固定时间间隔去处理红外参数
|
||
char result[4] = { '0','0','0','0' };
|
||
char result_warn[4] = { '0','0','0','0' };
|
||
char result_fire_rknn[4] = { '0','0','0','0' };
|
||
//初始化ControlInstructions
|
||
// ControlInstructions[3]=0x00;
|
||
// ControlInstructions[4]=0x00;
|
||
// ControlInstructions[5]=0x00;
|
||
// ControlInstructions[6]=0x00;
|
||
// ControlInstructions[7]=0x00;
|
||
// ControlInstructions[8]=0x00;
|
||
// ControlInstructions[9]=0x00;
|
||
// ControlInstructions[10]=0x00;
|
||
// ControlInstructions[11]=0x00;
|
||
// ControlInstructions[12]=0x00;
|
||
// ControlInstructions[13]=0x00;
|
||
// ControlInstructions[14]=0x00;
|
||
// ControlInstructions[15]=0x00;
|
||
// ControlInstructions[16]=0x00;
|
||
// ControlInstructions[17]=0x00;
|
||
// ControlInstructions[18]=0x00;
|
||
|
||
if (time2run) {
|
||
cout << "run ." << endl;
|
||
mtx.lock();
|
||
memcpy(copyBuffer, buffer, sizeof(buffer));
|
||
mtx.unlock();
|
||
//计算温度
|
||
double temperature;
|
||
int Col, Row;
|
||
int j = 0;
|
||
double max_temperature = 0;
|
||
for (int i = 4; i < 1540; i += 2) {
|
||
// temperature = calibration((buffer[i+1]*256+buffer[i])/100.0);
|
||
temperature = (buffer[i + 1] * 256 + buffer[i]) / 100.0 + 6;
|
||
// cout << (buffer[i+1]*256+buffer[i])/100.0 << " " << temperature << endl;
|
||
|
||
//按视觉顺序存入数组
|
||
Col = 31 - (j) % 32;
|
||
Row = (j) / 32;
|
||
temperature_img[Row][Col] = temperature;
|
||
j++;
|
||
}
|
||
temp_env = (buffer[1541] * 256 + buffer[1540]) / 100.0;
|
||
WARN_TEMPERATURE = (temp_env * 2) > WARN_TEMPERATURE ? (temp_env * 2) : WARN_TEMPERATURE;
|
||
// ALARM_TEMPERATURE = WARN_TEMPERATURE + 20;
|
||
//截去上下5行数据
|
||
for (int i = 5; i < 19; i++) {
|
||
for (j = 0; j < 32; j++) {
|
||
if (temperature_img[i][j] > IGNORE_TEMPERATURE) continue;
|
||
if (temperature_img[i][j] > max_temperature) max_temperature = temperature_img[i][j];
|
||
|
||
if (temperature_img[i][j] > ALARM_TEMPERATURE) {
|
||
overtmp_falg = 1;
|
||
if (0 <= j && j <= 6)
|
||
result[0] = '1';
|
||
else if (6 < j && j <= 15)
|
||
result[1] = '1';
|
||
else if (15 < j && j <= 24)
|
||
result[2] = '1';
|
||
else if (24 < j && j <= 31)
|
||
result[3] = '1';
|
||
}
|
||
|
||
if (temperature_img[i][j] > WARN_TEMPERATURE) {
|
||
Alarm.ifwarn = 1;
|
||
if (0 < j && j <= 6)
|
||
result_warn[0] = '1';
|
||
else if (6 < j && j <= 15)
|
||
result_warn[1] = '1';
|
||
else if (13 < j && j <= 24)
|
||
result_warn[2] = '1';
|
||
else if (24 < j && j <= 31)
|
||
result_warn[3] = '1';
|
||
}
|
||
}
|
||
}
|
||
|
||
int overtem_cnt_for_log;
|
||
if (overtmp_falg) {
|
||
over_tmp_deque.push_back(1);
|
||
if (over_tmp_deque.size() > 10) {
|
||
over_tmp_deque.erase(over_tmp_deque.begin());
|
||
}
|
||
overtem_cnt = 0;
|
||
for (int i = 0; i < over_tmp_deque.size(); ++i) {
|
||
if (over_tmp_deque[i] == 1) {
|
||
overtem_cnt++;
|
||
}
|
||
}
|
||
overtem_cnt_for_log = overtem_cnt;
|
||
|
||
if (overtem_cnt >= 3) {
|
||
Alarm.ifalarm = 1;
|
||
over_tmp_deque.assign(9, 0);
|
||
over_tmp_deque.push_back(1);
|
||
}
|
||
else {
|
||
memset(result, '0', 4 * sizeof(char));
|
||
}
|
||
}
|
||
else {
|
||
over_tmp_deque.push_back(0);
|
||
// 保持队列长度为10，如果超过长度则移除最前面的元素
|
||
if (over_tmp_deque.size() > 10) {
|
||
over_tmp_deque.erase(over_tmp_deque.begin());
|
||
}
|
||
}
|
||
|
||
|
||
// temp_env = (buffer[1541]*256+buffer[1540])/100.0;
|
||
cout << "最大温度: " << max_temperature << endl;
|
||
cout << "环境温度" << temp_env << endl;
|
||
cout << "预警温度: " << WARN_TEMPERATURE << endl;
|
||
cout << "直接喷水温度: " << ALARM_TEMPERATURE << endl;
|
||
if (max_temperature > WARN_TEMPERATURE) {
|
||
temperature_log << endl << "---------------------------------------------------" << endl;
|
||
temperature_log << Get_Time(1) << endl;
|
||
temperature_log << "最大温度: " << max_temperature << endl;
|
||
temperature_log << "环境温度: " << temp_env << endl;
|
||
temperature_log << "预警温度: " << WARN_TEMPERATURE << endl;
|
||
temperature_log << "直接喷水温度: " << ALARM_TEMPERATURE << endl;
|
||
temperature_log << "超温队列：";
|
||
for (int i = 0; i < over_tmp_deque.size(); ++i) {
|
||
temperature_log << over_tmp_deque[i] << " ";
|
||
}
|
||
temperature_log << endl;
|
||
}
|
||
if (Alarm.ifalarm) {
|
||
printf("temprature > %d°C !\n", ALARM_TEMPERATURE);
|
||
// 将字符数组拼接成字符串
|
||
std::string resultString(result, 4);
|
||
std::cout << ALARM_TEMPERATURE << "度结果: " << resultString << std::endl;
|
||
temperature_log << ALARM_TEMPERATURE << "度结果: " << resultString << std::endl;
|
||
std::string resultString_warn(result_warn, 4);
|
||
std::cout << WARN_TEMPERATURE << "度结果: " << resultString_warn << std::endl;
|
||
temperature_log << WARN_TEMPERATURE << "度结果: " << resultString_warn << std::endl;
|
||
}
|
||
else if (Alarm.ifwarn) {
|
||
printf("temprature > %d°C !\n", WARN_TEMPERATURE);
|
||
std::string resultString_warn(result_warn, 4);
|
||
std::cout << WARN_TEMPERATURE << "结果: " << resultString_warn << std::endl;
|
||
temperature_log << WARN_TEMPERATURE << "结果: " << resultString_warn << std::endl;
|
||
}
|
||
}
|
||
|
||
if (Alarm.ifwarn) {
|
||
struct timeval start;
|
||
struct timeval end;
|
||
now_result.clear();
|
||
temperature_log << "上帧总的结果：" << endl;
|
||
for (auto i : last_result) {
|
||
temperature_log << "(" << i[0] << " " << i[1] << ") (" << i[2] << " " << i[3] << ")" << endl;
|
||
}
|
||
printf("%s_rknn_run\n", labels[0]);
|
||
yolov5_detect_run(ctx, src, &detect_result_group);
|
||
}
|
||
|
||
//计算时间差
|
||
if (detect_result_group.count > 0) {
|
||
auto current_time_now = std::chrono::high_resolution_clock::now();// 时间
|
||
auto value_time = std::chrono::duration_cast<std::chrono::milliseconds>(current_time_now - last_result_time);// 计算距离开始时间的时间差
|
||
|
||
if (value_time.count() - 10000 > 0) {
|
||
last_result.clear();
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/* 算法结果在图像中画出并保存 */
|
||
int name_int = 0;
|
||
// char result[4]={'0','0','0','0'};
|
||
for (int i = 0; i < detect_result_group.count; i++)
|
||
{
|
||
yolov5_detect_result_t* det_result = &(detect_result_group.results[i]);
|
||
|
||
if (det_result->prop < Confidence_Threshold)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
|
||
cout << "Detected object: " << det_result->name << endl;
|
||
|
||
|
||
if (Alarm.ifwarn) {
|
||
printf("%s @ (%d %d %d %d) %f\n",
|
||
det_result->name,
|
||
det_result->box.left, det_result->box.top, det_result->box.right, det_result->box.bottom,
|
||
det_result->prop);
|
||
vector<int> now;
|
||
now.push_back(det_result->box.left);
|
||
now.push_back(det_result->box.top);
|
||
now.push_back(det_result->box.right);
|
||
now.push_back(det_result->box.bottom);
|
||
now_result.push_back(now);
|
||
if (check_whether_in_last_result(last_result, now, temperature_log)) {
|
||
continue;
|
||
}
|
||
}
|
||
int x1 = det_result->box.left;
|
||
int y1 = det_result->box.top;
|
||
int x2 = det_result->box.right;
|
||
int y2 = det_result->box.bottom;
|
||
|
||
//检测区域
|
||
if (Alarm.ifwarn) {
|
||
checkCoverage(x1, x2, 1480, result_fire_rknn);
|
||
}
|
||
|
||
char label_text[50];
|
||
memset(label_text, 0, sizeof(label_text));
|
||
sprintf(label_text, "%s %0.2f", det_result->name, det_result->prop);
|
||
plot_one_box(src, x1, x2, y1, y2, label_text, i % 10);
|
||
}
|
||
|
||
if (Alarm.ifwarn) {
|
||
// if(!now_result.empty()){
|
||
// last_result.clear();
|
||
// last_result = now_result;
|
||
// }
|
||
|
||
//若上帧结果为空，依然清理结果队列 --2024.11.4
|
||
last_result.clear();
|
||
last_result = now_result;
|
||
last_result_time = std::chrono::high_resolution_clock::now();// 时间
|
||
std::string resultString_fire(result_fire_rknn, 4);
|
||
std::cout << "rknn检测结果: " << resultString_fire << std::endl;
|
||
temperature_log << "rknn检测结果: " << resultString_fire << std::endl;
|
||
//对45度区域和火焰检测区域做出 与操作
|
||
and_result(result_warn, result_fire_rknn);
|
||
//对火与45度结果 与 60 度结果 做或操作
|
||
or_result(result, result_warn);
|
||
temperature_log << "报警输入：" << string(result, 4) << endl;
|
||
//处理ControlInstructions数据
|
||
|
||
if (result[0] == '1') ControlInstructions[(g_camera_number - 1) * 4] = 0x01;
|
||
if (result[1] == '1') ControlInstructions[(g_camera_number - 1) * 4] = 0x01;
|
||
if (result[2] == '1') ControlInstructions[(g_camera_number - 1) * 4] = 0x01;
|
||
if (result[3] == '1') ControlInstructions[(g_camera_number - 1) * 4] = 0x01;
|
||
std::string indices = generateIndices(result, &Alarm);
|
||
std::cout << "结果: " << indices << std::endl;
|
||
Alarm.alarmCoverage = indices;
|
||
}
|
||
|
||
|
||
if (time2run && Alarm.ifalarm) {
|
||
|
||
printf("******************************\n");
|
||
// 创建第一个子进程：控制继电器
|
||
pid_t relay_pid = fork();
|
||
if (relay_pid == 0) {
|
||
printf("kongzhi jidianqi\n");
|
||
reset_relay();
|
||
exit(0); // 子进程完成继电器控制后退出
|
||
}
|
||
|
||
// 创建第二个子进程：播放音频
|
||
pid_t audio_pid = fork();
|
||
if (audio_pid == 0) {
|
||
printf("yuyin bobao\n");
|
||
jbus_hdl_t jbus = jbus_init("spktest");
|
||
jmss_hdl_t jms = JES_MSS_Init(jbus);
|
||
jspk_hdl_t jspk = JES_SPK_Init(jbus);
|
||
|
||
JMediaAencParam_t adec;
|
||
JES_SPK_GetParam(jspk, &adec, JFALSE);
|
||
adec.attr.volume = 80;
|
||
adec.attr.encType = JVMEDIA_AUDIO_TYPE_G711_A;
|
||
JES_SPK_SetParam(jspk, &adec);
|
||
|
||
// 播放音频
|
||
play_audio("/demo/bin/Sound.g711u", jspk);
|
||
|
||
// 清理
|
||
JES_SPK_Deinit(jspk);
|
||
JES_MSS_Deinit(jms);
|
||
jbus_cleanup(jbus);
|
||
exit(0); // 子进程完成音频播放后退出
|
||
}
|
||
|
||
|
||
|
||
cv::Mat rgb_img;
|
||
cv::cvtColor(src, rgb_img, COLOR_BGR2RGB);
|
||
// std::string filename = "result" + std::string(labels[name_int]) + ".jpg";
|
||
std::string filename = "/demo/pic/" + Get_Time(2) + ".jpg";
|
||
cv::imwrite(filename, rgb_img, compression_params);
|
||
std::ifstream file(filename, std::ios::in | std::ios::binary);
|
||
std::ostringstream oss;
|
||
oss << file.rdbuf();
|
||
std::string orig_data = oss.str();
|
||
// 编码图片数据为base64格式
|
||
std::string encoded_data = base64_encode(reinterpret_cast<const unsigned char*>(orig_data.c_str()), orig_data.length());
|
||
Alarm.alarmBase64 = encoded_data;
|
||
Alarm.alarmMsg = std::string(labels[0]);
|
||
Alarm.alarmMsg = std::string(labels[name_int]);
|
||
pthread_t upload_message_tidp;
|
||
pthread_create(&upload_message_tidp, NULL, upload_message, static_cast<void*>(&Alarm));
|
||
pthread_t upload_message_controller_tidp;
|
||
int ret = pthread_create(&upload_message_controller_tidp, NULL, upload_message_controller, static_cast<void*>(&Alarm));
|
||
if (ret != 0) {
|
||
std::cerr << "Error creating controller thread: " << strerror(ret) << std::endl;
|
||
}
|
||
else {
|
||
std::cerr << "success creating controller thread" << std::endl;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* 算法模型空间释放 */
|
||
yolov5_detect_release(ctx);
|
||
//文件关闭
|
||
temperature_log.close();
|
||
return 0;
|
||
|
||
}
|
||
|
||
void* upload_message(void* args)
|
||
{
|
||
pthread_detach(pthread_self());
|
||
// 获取上报url
|
||
char upload_url[200] = { 0 };
|
||
if (!_geturlFromfile(DOWNLOAD_VERSION_PATH, upload_url, sizeof(upload_url))) {
|
||
printf("结束进程\n");
|
||
return 0;
|
||
}
|
||
|
||
Alarm* alarm = static_cast<Alarm*>(args);
|
||
|
||
// 获取当前系统时间
|
||
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();
|
||
|
||
std::string cameraId = DeviceID;
|
||
std::string controllerId = response_controllerId;
|
||
std::string msg = (alarm->alarmMsg).c_str();
|
||
std::string type = "1";
|
||
std::string time = formattedTime;
|
||
std::string img = (alarm->alarmBase64).c_str();
|
||
std::string Coverage = (alarm->alarmCoverage).c_str();
|
||
|
||
std::cout << "cameraId: " << cameraId << " msg: " << msg << " type: " << type << " time: " << time << std::endl;
|
||
|
||
std::string MessageString =
|
||
R"({
|
||
"cameraid": ")" + cameraId + R"(",
|
||
"controllerId": ")" + controllerId + R"(",
|
||
"msg": ")" + msg + R"(",
|
||
"type": ")" + type + R"(",
|
||
"errNum": ")" + Coverage + R"(",
|
||
"img": ")" + img + R"(",
|
||
"time": ")" + time + R"("
|
||
})";
|
||
|
||
CURL* curl;
|
||
CURLcode res;
|
||
curl_global_init(CURL_GLOBAL_ALL);
|
||
curl = curl_easy_init();
|
||
|
||
if (curl)
|
||
{
|
||
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");
|
||
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 << "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();
|
||
}
|
||
|
||
void* upload_message_controller(void* args)
|
||
{
|
||
pthread_detach(pthread_self());
|
||
Alarm* alarm = static_cast<Alarm*>(args);
|
||
|
||
// 获取当前系统时间
|
||
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();
|
||
|
||
std::string cameraId = DeviceID;
|
||
std::string Coverage = (alarm->alarmCoverage).c_str();
|
||
|
||
std::cout << "cameraid: " << cameraId << " errNum: " << Coverage << std::endl;
|
||
|
||
std::string MessageString =
|
||
R"({
|
||
"cameraid": ")" + cameraId + R"(",
|
||
"errNum": ")" + Coverage + R"("
|
||
})";
|
||
|
||
CURL* curl;
|
||
CURLcode res;
|
||
curl_global_init(CURL_GLOBAL_ALL);
|
||
curl = curl_easy_init();
|
||
|
||
if (curl)
|
||
{
|
||
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
|
||
curl_easy_setopt(curl, CURLOPT_URL, "http://192.168.1.23:9527/device/alarm");
|
||
/* 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());
|
||
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)
|
||
// fprintf(stderr, "curl_easy_perform() failed: %s\n",curl_easy_strerror(res));
|
||
if (res != CURLE_OK) {
|
||
std::cerr << "controller: Failed to perform cURL request: " << curl_easy_strerror(res) << std::endl;
|
||
}
|
||
else {
|
||
std::cout << "controller: Request successful!" << std::endl;
|
||
// std::cout << "controller: Response: " << response << std::endl;
|
||
}
|
||
|
||
|
||
curl_easy_cleanup(curl);
|
||
}
|
||
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) {
|
||
|
||
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 = "987654";
|
||
int state = 1;
|
||
std::string http_address = "http";
|
||
|
||
std::string MessageString =
|
||
R"({
|
||
"cameraId": ")" + cameraId + R"(",
|
||
"IP": ")" + IP + R"(",
|
||
"state": )" + std::to_string(state) + R"(,
|
||
"http_address": ")" + http_address + R"("
|
||
})";
|
||
CURL* curl;
|
||
CURLcode res;
|
||
curl_global_init(CURL_GLOBAL_ALL);
|
||
curl = curl_easy_init();
|
||
|
||
if (curl)
|
||
{
|
||
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
|
||
curl_easy_setopt(curl, CURLOPT_URL, "http://192.168.1.23:9527/device/heartbeat");
|
||
/* 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_TIMEOUT, 10L);
|
||
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)
|
||
// 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;
|
||
}
|
||
else {
|
||
std::cout << "heart beat: Request successful!" << std::endl;
|
||
std::cout << "heart beat: Response: " << response << std::endl;
|
||
// 解析 JSON 字符串
|
||
try {
|
||
json jsonData = json::parse(response);
|
||
|
||
// 提取 controllerId 字段的内容
|
||
response_controllerId = jsonData["controllerId"];
|
||
|
||
std::cout << "Controller ID: " << response_controllerId << std::endl;
|
||
}
|
||
catch (const json::parse_error& e) {
|
||
std::cerr << "JSON parsing error: " << e.what() << std::endl;
|
||
}
|
||
}
|
||
|
||
|
||
curl_easy_cleanup(curl);
|
||
}
|
||
curl_global_cleanup();
|
||
}
|
||
time2run = 0;
|
||
}
|
||
}
|
||
|
||
|
||
void* read_serial_thread(void* args)
|
||
{
|
||
pthread_detach(pthread_self());
|
||
ssize_t bytesRead;
|
||
serialPortInfraredSensor = open(SERIAL_PORT_INFRARED_SENSOR, O_RDWR | O_NOCTTY | O_NDELAY);
|
||
if (serialPortInfraredSensor == -1) {
|
||
printf("Failed to open serial port: %s\n", SERIAL_PORT_INFRARED_SENSOR);
|
||
return 0;
|
||
}
|
||
|
||
struct termios tty;
|
||
memset(&tty, 0, sizeof(tty));
|
||
if (tcgetattr(serialPortInfraredSensor, &tty) != 0) {
|
||
printf("Failed to get serial port attributes\n");
|
||
close(serialPortInfraredSensor);
|
||
return 0;
|
||
}
|
||
cfsetospeed(&tty, BAUD_RATE);
|
||
cfsetispeed(&tty, BAUD_RATE);
|
||
tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8;
|
||
tty.c_cflag &= ~(PARENB | PARODD);
|
||
tty.c_cflag &= ~CSTOPB;
|
||
tty.c_cflag |= CREAD | CLOCAL;
|
||
tty.c_iflag = IGNPAR;
|
||
tty.c_oflag = 0;
|
||
tty.c_lflag = 0;
|
||
if (tcsetattr(serialPortInfraredSensor, TCSANOW, &tty) != 0) {
|
||
printf("Failed to set serial port attributes\n");
|
||
close(serialPortInfraredSensor);
|
||
return 0;
|
||
}
|
||
|
||
fd_set readfds;
|
||
struct timeval timeout;
|
||
int selectResult;
|
||
|
||
while (1) {
|
||
FD_ZERO(&readfds);
|
||
FD_SET(serialPortInfraredSensor, &readfds);
|
||
|
||
timeout.tv_sec = 5; // 5秒超时
|
||
timeout.tv_usec = 0;
|
||
|
||
selectResult = select(serialPortInfraredSensor + 1, &readfds, NULL, NULL, &timeout);
|
||
|
||
if (selectResult > 0) {
|
||
if (FD_ISSET(serialPortInfraredSensor, &readfds)) {
|
||
mtx.lock();
|
||
bytesRead = read(serialPortInfraredSensor, buffer, sizeof(buffer));
|
||
mtx.unlock();
|
||
|
||
if (bytesRead > 0) {
|
||
if (buffer[0] == 0x5a && buffer[1] == 0x5a) {
|
||
// printf("readed serialPortInfraredSensor date\n");
|
||
}
|
||
else {
|
||
// printf("read failed\n");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (selectResult == 0) {
|
||
// 超时，没有数据可读
|
||
// printf("Timeout, no data available\n");
|
||
}
|
||
else {
|
||
// select出错
|
||
printf("select() failed\n");
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// pthread_t storage_serial;
|
||
// pthread_create(&storage_serial, NULL, storage_serial_thread, NULL);
|
||
|
||
// 首先定义协议相关的常量
|
||
#define PROTOCOL_HEAD 0x7E
|
||
#define PROTOCOL_VERSION 1
|
||
#define PROTOCOL_LENGTH 22
|
||
#define SOLENOID_VALVE_COUNT 16
|
||
#define COMMAND_QUERY 1
|
||
#define COMMAND_RESPONSE 2
|
||
|
||
// 定义协议结构体
|
||
typedef struct tagCamera485Protocol {
|
||
uint8_t m_head; // 协议头 0x7e
|
||
uint8_t m_version; // 版本1~255
|
||
uint8_t m_length; // 协议总长度，包含校验位
|
||
uint8_t m_address; // 地址0~255
|
||
uint8_t m_command; // 操作指令
|
||
uint8_t m_solenoidValve[SOLENOID_VALVE_COUNT]; // 电磁阀状态
|
||
uint8_t m_checkSum; // 校验和
|
||
} CCamera485Protocol;
|
||
|
||
// 优化后的storage_serial_thread函数
|
||
void* storage_serial_thread(void* args) {
|
||
pthread_detach(pthread_self());
|
||
|
||
// {
|
||
// test *ptest1 = NULL;
|
||
// test *ptest2[2] = {};
|
||
// if (ptest1 == ptest2[0])
|
||
// {
|
||
// printf("ptest1 == ptest2");
|
||
// }
|
||
// else
|
||
// {
|
||
// printf("ptest1 != ptest2");
|
||
// }
|
||
// return 0;
|
||
// }
|
||
|
||
juart_hdl_t hdl = juart_open("/dev/ttyS5");
|
||
JUartAttr_t attr = {.baudrate = 9600,
|
||
.datawidth = 8,
|
||
.stopbit = 1,
|
||
.parity = 0};
|
||
|
||
juart_set_attr(hdl, &attr);
|
||
juart_set_rs485(hdl, 0);
|
||
|
||
unsigned char hexData[] = {0x01, 0x03, 0x00, 0x00, 0x00, 0x02, 0xC4, 0x0B};
|
||
juart_send(hdl, (char*)hexData, sizeof(hexData));
|
||
printf("send: ");
|
||
hexdump((char*)hexData, sizeof(hexData));
|
||
|
||
while (1)
|
||
{
|
||
CCamera485Protocol protocol;
|
||
int len = juart_recv(hdl, (char *)&protocol, sizeof(CCamera485Protocol), 6000);
|
||
if (len <= 0)
|
||
{
|
||
printf("==============>>>: %s,%d: recv timeout!\n", strrchr(__FILE__,'/'),__LINE__);
|
||
}
|
||
|
||
if (len == sizeof(CCamera485Protocol))
|
||
{
|
||
hexdump((char*)&protocol,len);
|
||
// 处理协议
|
||
if (protocol.m_head == PROTOCOL_HEAD &&
|
||
protocol.m_command == COMMAND_QUERY &&
|
||
protocol.m_address == (g_camera_number - 1))
|
||
{
|
||
// 构造响应
|
||
uint8_t response_array[22] = {0};
|
||
// 1. 填充头部
|
||
response_array[0] = PROTOCOL_HEAD; // 协议头
|
||
response_array[1] = PROTOCOL_VERSION; // 版本
|
||
response_array[2] = PROTOCOL_LENGTH; // 长度
|
||
response_array[3] = g_camera_number - 1; // 地址
|
||
response_array[4] = COMMAND_RESPONSE; // 命令
|
||
|
||
// 2. 填充电磁阀状态
|
||
mtx.lock();
|
||
for (int i = 0; i < SOLENOID_VALVE_COUNT; i++) {
|
||
response_array[5 + i] = ControlInstructions[i];
|
||
}
|
||
mtx.unlock();
|
||
|
||
// 3. 计算校验和（前21字节累加和）
|
||
uint8_t sum = 0;
|
||
for (int i = 0; i < 21; i++) {
|
||
sum += response_array[i];
|
||
}
|
||
response_array[21] = sum; // 校验和
|
||
juart_send(hdl, (char*)response_array, sizeof(response_array));
|
||
hexdump((char*)&response_array,sizeof(response_array));
|
||
std::fill(ControlInstructions.begin(), ControlInstructions.end(), 0x00);
|
||
sleep(2);
|
||
|
||
}
|
||
}
|
||
}
|
||
juart_close(hdl);
|
||
return 0;
|
||
} |