2650 lines
75 KiB
C++
2650 lines
75 KiB
C++
#include"Define.h"
|
||
#include <GSMMannager.h>
|
||
#include <HTTPClient.h>
|
||
#include <ArduinoHttpClient.h>
|
||
#include<driver/periph_ctrl.h>
|
||
#include <SoftwareSerial.h>
|
||
#include <Ticker.h>
|
||
#include <updatebyme.h>
|
||
//#include "MyWebServer.h"
|
||
#include "SDmanger.h"
|
||
//#include "HttpsOTAUpdate.h"
|
||
#include "slave.h"
|
||
#include "log.h"
|
||
|
||
#include <wifidebug.h>
|
||
#include <ArduinoJson.h>
|
||
#include <Communication_Protocol.h>
|
||
|
||
#include "IRIS_Method.h"
|
||
#include "DS18B20.h"
|
||
#include "Servo.h"
|
||
#include "jiaresi.h"
|
||
#include <Ds1302.h>
|
||
#include "servo.h"
|
||
#include "SensorIS11.h"
|
||
#include "tuigan.h"
|
||
#include "beep.h"
|
||
#include "My74HC595.h"
|
||
#include "SolarCalculator.h"
|
||
#define LOGGING
|
||
#define wb485PORT_RX 3
|
||
#define wb485PORT_TX 2
|
||
|
||
#define MY74HC595_dataPin 35
|
||
#define MY74HC595_clockPin 33
|
||
#define MY74HC595_latchPin 34
|
||
|
||
#define IS1Serial_port 1
|
||
#define IS1Serial_RX 18
|
||
#define IS1Serial_TX 17
|
||
// u_char ret[17];
|
||
|
||
// Ticker ticker;
|
||
|
||
/*
|
||
任务名：Task0
|
||
任务功能：光谱数据采集
|
||
*/
|
||
TaskHandle_t Task0_Handler;
|
||
void Task0(void *pvParameters);
|
||
/*
|
||
任务名：Task1
|
||
任务功能：外设控制,加热 、推杆、舵机、温度采集、时间获取
|
||
*/
|
||
TaskHandle_t Task1_Handler;
|
||
void Task1(void *pvParameters);
|
||
|
||
/*
|
||
任务名：Task2
|
||
任务功能：数据上传
|
||
*/
|
||
TaskHandle_t Task2_Handler;
|
||
void Task2(void *pvParameters);
|
||
|
||
//work_mode 0:手动 1：时间模式 time_mode 2：高级模式 advanced_mode 3:low_power_mode
|
||
//caiji_mode 0；停止 1：单次 2：连续 3：定标 4：高级模式 5：回传数据 6：低功耗模式
|
||
//atuo_return 0:不自动返回 1：自动返回
|
||
//return_mode 设置返回模式 暂时没用
|
||
//return_data_type 详情见你懂的O.o
|
||
//time_interval 时间间隔不能等于0；
|
||
//caiji_state 0 :未采集（no） 1：采集完成（finish） 2：采集中（working）
|
||
//dingbiao_time 0自动曝光 非0使用这个时长曝光
|
||
volatile u_int32_t work_mode = 0,caiji_mode = 0,return_mode = 1,atuo_return = 0,return_data_type = 0x00,time_interval = 60 * 2,caiji_state = 0 ,db_shutter,db_avn;
|
||
volatile float start_time = 9.0,stop_time = 15.30,maximum_temperature = 40,Minimum_temperature = 0,bc_b1,bc_b2,bc_b3,bc_b4;
|
||
|
||
|
||
|
||
/// @brief 高级模式参数
|
||
// advanced_direction 0:up 1:down 2:dark
|
||
// advanced_shutter_time 曝光时间
|
||
// advanced_collect_times 采集次数
|
||
// advanced_remove_dark 0:不去暗 1:去暗
|
||
volatile u_int32_t advanced_direction=0,advanced_shutter_time=0,advanced_collect_times=0,advanced_remove_dark=0;
|
||
|
||
u_int32_t timeOut = 10000;
|
||
// SoftwareSerial *wb485port;
|
||
|
||
SemaphoreHandle_t xMutexInventory = NULL; //创建信号量Handler
|
||
|
||
//json
|
||
DynamicJsonDocument doc(1024);//接收串口json
|
||
DynamicJsonDocument sys_sd_doc(1024);//读取系统json
|
||
DynamicJsonDocument ds18b20_doc(1024);//读取ds18b20 json
|
||
|
||
|
||
void json_command();
|
||
void sys_info_init();
|
||
|
||
//////ds1302时间/////////
|
||
Ds1302 rtc(0, 8, 7);
|
||
Ds1302::DateTime now;
|
||
bool sys_set_time(uint32_t year,uint32_t month,uint32_t day);
|
||
// const static char* WeekDays[] =
|
||
// {
|
||
// "Monday",
|
||
// "Tuesday",
|
||
// "Wednesday",
|
||
// "Thursday",
|
||
// "Friday",
|
||
// "Saturday",
|
||
// "Sunday"
|
||
// };
|
||
|
||
struct IS11_datastruct *IS11_datastructure;
|
||
|
||
//////is11/////////
|
||
SensorIS11 *is11Sensor;
|
||
STRSensorInfo STRSensorInfos_structure;
|
||
|
||
// SoftwareSerial *IS1Serial;
|
||
HardwareSerial *IS1Serial;
|
||
|
||
//原来
|
||
HardwareSerial wb485Serial(0);
|
||
|
||
size_t serialwrite(u_char* data,size_t lenth)
|
||
{
|
||
// return IS1Serial->write(data,lenth);
|
||
while (IS1Serial->available() > 0)
|
||
{
|
||
IS1Serial->read();
|
||
|
||
}
|
||
|
||
int rec=IS1Serial->write(data,lenth);
|
||
|
||
return rec;
|
||
}
|
||
|
||
size_t serialread(u_char *data, size_t lenth)
|
||
{
|
||
lenth=IS1Serial->available();
|
||
|
||
if (lenth<=0 )
|
||
{
|
||
/* code */
|
||
return 0;
|
||
}
|
||
int lenthofread = IS1Serial->readBytes(data,lenth);
|
||
|
||
return lenthofread;
|
||
}
|
||
////////////////////////////////AIR780EG///////////////////////////////////////////
|
||
GSMMannger *gsmmanger;
|
||
struct gps_struct{
|
||
uint16_t year;
|
||
uint8_t month;
|
||
uint8_t day;
|
||
uint8_t hour;
|
||
uint8_t minute;
|
||
uint8_t second;
|
||
float latitude;
|
||
float longitude;
|
||
};
|
||
String get_GPS(gps_struct *gps);
|
||
String getnetData();
|
||
HttpClient *http;
|
||
////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
// void save_sd_ds18b20_address(uint8_t num,uint8_t *addr);
|
||
// void sd_read_set_ds18b20_address();
|
||
|
||
bool read_dingbiao(String dingbiao_path,uint8_t *dianbiao_data_buff);
|
||
void send_dingbiao(String dingbiao_path);
|
||
void dingbiao_init(String dingbiao_path);
|
||
|
||
void rm_dir_or_file(const char * dirname);
|
||
void low_power_mode(uint8_t state);
|
||
void setup()
|
||
{
|
||
//关闭光谱仪
|
||
pinMode(36,INPUT);
|
||
vTaskDelay(1000);
|
||
|
||
log_init();
|
||
// Serial.begin(115200);
|
||
|
||
// wb485Serial.begin(115200);
|
||
wb485Serial.begin(115200, SERIAL_8N1, wb485PORT_RX, wb485PORT_TX, false);
|
||
|
||
|
||
vTaskDelay(1000);
|
||
|
||
vTaskDelay(5000);
|
||
IS1Serial =new HardwareSerial(IS1Serial_port);
|
||
IS1Serial->begin(115200, SERIAL_8N1, IS1Serial_RX, IS1Serial_TX);
|
||
IS1Serial->setTimeout(1);
|
||
|
||
|
||
|
||
//初始化SD卡
|
||
sdcard::init_sdcard();
|
||
sdcard::testwriet();
|
||
sdcard::Mkdir("/guangpu_data");
|
||
sdcard::Mkdir("/up");
|
||
sdcard::Mkdir("/down");
|
||
sdcard::Mkdir("/other");
|
||
sdcard::Mkdir("/gps");
|
||
sdcard::Mkdir("/log");
|
||
sdcard::Mkdir("/dingbiao");
|
||
|
||
///
|
||
|
||
// while(1)
|
||
// {
|
||
// write_log(log_path,"hello world",10);
|
||
// if(SD_MMC.exists("/guangpu_data/0"))
|
||
// {
|
||
// rm_dir_or_file("/guangpu_data/0");
|
||
// }
|
||
// }
|
||
|
||
dingbiao_init("/dingbiao/dingbiao_up_gain.bin");
|
||
dingbiao_init("/dingbiao/dingbiao_up_offset.bin");
|
||
dingbiao_init("/dingbiao/dingbiao_down_gain.bin");
|
||
dingbiao_init("/dingbiao/dingbiao_down_offset.bin");
|
||
//检查SD卡是否有log.log文件 没有则创建
|
||
// unsigned char log_level = 10;
|
||
if(!SD_MMC.exists(log_path))
|
||
{
|
||
File file;
|
||
file = SD_MMC.open(log_path,"ab+");
|
||
file.flush();
|
||
file.close();
|
||
}
|
||
if(!SD_MMC.exists(gp_log))
|
||
{
|
||
//检查SD卡是否有log.log文件 没有则创建
|
||
File file;
|
||
file = SD_MMC.open(gp_log,"ab+");
|
||
file.flush();
|
||
file.close();
|
||
}
|
||
// 初始化DS18b20
|
||
uint8_t temp_number = DS18b20_init();
|
||
// float temp[temp_number];
|
||
// getall_temp(temp);
|
||
// while (1)
|
||
// {
|
||
// getall_temp(temp);
|
||
// for (size_t i = 0; i < temp_number; i++)
|
||
// {
|
||
// write_log(log_path,"temp " + String(i) + ": " + String(temp[i]),10);
|
||
// }
|
||
// vTaskDelay(1000 * 2);
|
||
// }
|
||
|
||
// sd_read_set_ds18b20_address();
|
||
|
||
|
||
//初始化舵机
|
||
servo_init(21,0);
|
||
|
||
//初始化蜂鸣器
|
||
beep_init(6,2000,12);
|
||
// while (1)
|
||
// {
|
||
// servo_set_angle(120);
|
||
// vTaskDelay(1000 * 1.5);
|
||
// servo_set_angle(0);
|
||
|
||
// beep_run(2000,1000);
|
||
// vTaskDelay(1000 * 3);
|
||
// beep_stop();
|
||
// }
|
||
|
||
|
||
// while(1)
|
||
// {
|
||
// beep_run(2000,1000);
|
||
// vTaskDelay(1000 * 3);
|
||
// beep_stop();
|
||
// vTaskDelay(1000 * 3);
|
||
// }
|
||
|
||
|
||
|
||
//初始化时间
|
||
rtc.init();
|
||
// now.year = 24;
|
||
// now.month = 5;
|
||
// now.day = 21;
|
||
// now.hour = 13;
|
||
// now.minute = 45;
|
||
// now.second = 0;
|
||
// now.dow = Ds1302::DOW_WED;
|
||
// rtc.setDateTime(&now);
|
||
|
||
|
||
rtc.getDateTime(&now);
|
||
|
||
|
||
|
||
//初始化74hc595
|
||
my74hc595_init();
|
||
///////////////////////////加热测试////////////////////////////////////
|
||
// while(1)
|
||
// {
|
||
// write_log(log_path,"start jiaresi",10);
|
||
// jiaresi(0,start_jiare);
|
||
// jiaresi(1,start_jiare);
|
||
// jiaresi(2,start_jiare);
|
||
// jiaresi(3,start_jiare);
|
||
// jiaresi(4,start_jiare);
|
||
// jiaresi(5,start_jiare);
|
||
|
||
// tuigan(tui);
|
||
// vTaskDelay(1000 * 15);
|
||
|
||
// write_log(log_path,"stop jiaresi",10);
|
||
// jiaresi(0,start_jiare);
|
||
// jiaresi(1,stop_jiare);
|
||
// jiaresi(2,stop_jiare);
|
||
// jiaresi(3,stop_jiare);
|
||
// jiaresi(4,stop_jiare);
|
||
// jiaresi(5,stop_jiare);
|
||
|
||
// tuigan(suo);
|
||
// vTaskDelay(1000 * 15);
|
||
|
||
// }
|
||
|
||
|
||
///////////////////////////加热测试////////////////////////////////////
|
||
|
||
///////////////////////////推杆测试/////////////////////////////////////
|
||
// uint32_t x = 0;
|
||
// float n = 5;
|
||
// uint32_t data_length;
|
||
// uint8_t read_buf[100];
|
||
// while (1)
|
||
// {
|
||
// while(wb485Serial.available())
|
||
// {
|
||
// data_length += wb485Serial.readBytes(&read_buf[data_length],100);
|
||
// for (uint32_t i = 0; i < 5000; i++)
|
||
// {
|
||
// if(wb485Serial.available() > 0)
|
||
// {
|
||
// break;
|
||
// }
|
||
// }
|
||
// }
|
||
// //如果接收到数据
|
||
// if (data_length > 0)
|
||
// {
|
||
// if(read_buf[0] == 'n')
|
||
// {
|
||
// //将转换为数字
|
||
// n = atof((const char *) (read_buf+1));
|
||
// if(n<5) n = 5;
|
||
// }
|
||
// if(read_buf[0] == 'H')
|
||
// {
|
||
// wb485Serial.println("n = " + String(n));
|
||
// }
|
||
// memset(read_buf, 0, sizeof(read_buf));
|
||
// data_length = 0;
|
||
// }
|
||
|
||
|
||
// if(x == 1)
|
||
// {
|
||
// wb485Serial.println("start tuigan tui");
|
||
// tuigan(tui);
|
||
// }
|
||
// else if(x == 1000 *n)
|
||
// {
|
||
// wb485Serial.println("start tuigan suo");
|
||
// tuigan(suo);
|
||
// }
|
||
// else if(x == 1000 * 2 * n)
|
||
// {
|
||
// x = 0;
|
||
// }
|
||
|
||
// x++;
|
||
// vTaskDelay(1);
|
||
// }
|
||
///////////////////////////推杆测试/////////////////////////////////////
|
||
|
||
|
||
|
||
// //初始化AIR780EG
|
||
gsmmanger = new GSMMannger(2, 19, 20);
|
||
http = new HttpClient(*gsmmanger->client, "82.156.1.111");
|
||
String Date = getnetData();
|
||
write_log(log_path,"date is :"+Date,10);
|
||
|
||
// while(1)
|
||
// {
|
||
// String Date = getnetData();
|
||
// write_log(log_path,"date is :"+Date,10);
|
||
// vTaskDelay(1000);
|
||
// }
|
||
// //初始化AIR780EG
|
||
// gsmmanger = new GSMMannger();
|
||
// //获取GPS
|
||
gps_struct gps_structure;
|
||
|
||
String gpsbac = get_GPS(&gps_structure);
|
||
|
||
//计算日出日落
|
||
double transit, sunrise, sunset;
|
||
double utc_offset = 8;
|
||
|
||
|
||
// int i=0;
|
||
// while(1)
|
||
// {
|
||
// gpsbac = get_GPS(&gps_structure);
|
||
// write_log(log_path,String(i)+"Getting GPS " + gpsbac,10);
|
||
// vTaskDelay(1000);
|
||
// i++;
|
||
// if (gpsbac != "-1")
|
||
// {
|
||
// calcSunriseSunset(now.year+2000, now.month, now.day,gps_structure.latitude, gps_structure.longitude, transit, sunrise, sunset);
|
||
// write_log(log_path,"sunrise: " + String(sunrise),10);
|
||
// write_log(log_path,"sunset: " + String(sunset),10);
|
||
// write_log(log_path,"transit: " + String(transit),10);
|
||
// write_log(log_path,"latitude: " + String(gps_structure.latitude),10);
|
||
// write_log(log_path,"longitude: " + String(gps_structure.longitude),10);
|
||
// write_log(log_path,"gps_date: " + gpsbac,10);
|
||
// }
|
||
// }
|
||
|
||
|
||
if (gpsbac != "-1")
|
||
{
|
||
calcSunriseSunset(now.year+2000, now.month, now.day,gps_structure.latitude, gps_structure.longitude, transit, sunrise, sunset);
|
||
}
|
||
else
|
||
{
|
||
write_log(log_path,"no gps",10);
|
||
}
|
||
|
||
//开启光谱仪
|
||
pinMode(36,OUTPUT);
|
||
digitalWrite(36,LOW);
|
||
vTaskDelay(1000 * 2);
|
||
InitFunction(serialwrite,serialread);
|
||
is11Sensor = new SensorIS11();
|
||
STRSensorInfos_structure = is11Sensor->initSensor();
|
||
|
||
|
||
// while(1)
|
||
// {
|
||
// is11Sensor->SetShutter(2);
|
||
// vTaskDelay(1000);
|
||
// is11Sensor->SetShutter(1);
|
||
// vTaskDelay(1000);
|
||
// }
|
||
// 删除原来SD卡的系统信息
|
||
|
||
|
||
sys_info_init();
|
||
|
||
|
||
|
||
|
||
servo_set_angle(120);
|
||
vTaskDelay(1000 * 1.5);
|
||
servo_set_angle(0);
|
||
vTaskDelay(1000 * 1.5);
|
||
|
||
beep_run(2000,1000);
|
||
vTaskDelay(1000 * 1.5);
|
||
beep_stop();
|
||
|
||
// sys_sd_doc["is_spacial"] = "yes";
|
||
|
||
// deserializeJson(sys_sd_doc,system_info);
|
||
// while (1)
|
||
// {
|
||
// }
|
||
|
||
xMutexInventory = xSemaphoreCreateMutex(); //创建MUTEX
|
||
if (xMutexInventory == NULL) {
|
||
|
||
} else{
|
||
//创建并启动Core1的任务 xTaskCreatePinnedToCore
|
||
xTaskCreatePinnedToCore(
|
||
Task0, /* 任务函数 */
|
||
"Task0", /* 任务名称 */
|
||
1024 * 50, /* 栈大小 */
|
||
NULL, /* 任务参数 */
|
||
2, /* 任务优先级 */
|
||
&Task0_Handler, /* 任务句柄 */
|
||
0); /* Core 0 */
|
||
|
||
xTaskCreatePinnedToCore(
|
||
Task1, /* 任务函数 */
|
||
"Task1", /* 任务名称 */
|
||
1024 * 5, /* 栈大小 */
|
||
NULL, /* 任务参数 */
|
||
1, /* 任务优先级 */
|
||
&Task1_Handler, /* 任务句柄 */
|
||
0);
|
||
|
||
//创建并启动Core0的任务
|
||
xTaskCreatePinnedToCore(
|
||
Task2, /* 任务函数 */
|
||
"Task2", /* 任务名称 */
|
||
1024 * 30, /* 栈大小 */
|
||
NULL, /* 任务参数 */
|
||
20, /* 任务优先级 */
|
||
&Task2_Handler, /* 任务句柄 */
|
||
1);
|
||
}
|
||
// write_log(log_path,"setup ok",log_level);
|
||
// beep_run(2000,512);
|
||
// vTaskDelay(1000 * 3);
|
||
// beep_stop();
|
||
}
|
||
|
||
void loop()
|
||
{
|
||
|
||
|
||
}
|
||
void Task0(void *pvParameters)
|
||
{
|
||
vTaskDelay(1);
|
||
write_log(log_path,"task 0",10);
|
||
uint32_t uint_work_task0 = 100;
|
||
while (1)
|
||
{
|
||
if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
|
||
{
|
||
if(uint_work_task0 == 100 && caiji_mode != 2)
|
||
{
|
||
caiji_mode = 0;
|
||
uint_work_task0 = 0;
|
||
}
|
||
if (caiji_state == 2)
|
||
{
|
||
caiji_state = 1;
|
||
}
|
||
uint_work_task0 = caiji_mode;
|
||
}
|
||
xSemaphoreGive(xMutexInventory);
|
||
//caiji_mode 0停止 1单次 2连续 3定标 4定标 5回传数据
|
||
switch (uint_work_task0)
|
||
{
|
||
case 0:
|
||
|
||
break;
|
||
case 1:
|
||
if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
|
||
{
|
||
caiji_state = 2;
|
||
}
|
||
xSemaphoreGive(xMutexInventory);
|
||
is11Sensor->TakeOneJob(false);
|
||
if (atuo_return == 1)
|
||
{
|
||
is11Sensor->senddata(&wb485Serial,return_data_type);
|
||
}
|
||
uint_work_task0 = 100;
|
||
break;
|
||
case 2:
|
||
if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
|
||
{
|
||
caiji_state = 2;
|
||
}
|
||
xSemaphoreGive(xMutexInventory);
|
||
is11Sensor->TakeOneJob(false);
|
||
if (atuo_return == 1)
|
||
{
|
||
is11Sensor->senddata(&wb485Serial,return_data_type);
|
||
}
|
||
vTaskDelay(1000 * time_interval);
|
||
break;
|
||
|
||
case 3:
|
||
is11Sensor->senddata(&wb485Serial,return_data_type);
|
||
|
||
uint_work_task0 = 100;
|
||
break;
|
||
|
||
case 4:
|
||
if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
|
||
{
|
||
caiji_state = 2;
|
||
}
|
||
xSemaphoreGive(xMutexInventory);
|
||
is11Sensor->advanced_mode(advanced_direction,advanced_shutter_time,advanced_collect_times,advanced_remove_dark);
|
||
uint_work_task0 = 100;
|
||
break;
|
||
|
||
case 5:
|
||
if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
|
||
{
|
||
caiji_state = 2;
|
||
}
|
||
xSemaphoreGive(xMutexInventory);
|
||
is11Sensor->opt(advanced_direction);
|
||
uint_work_task0 = 100;
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
vTaskDelay(10);
|
||
}
|
||
}
|
||
|
||
|
||
//Task1的实现
|
||
void Task1(void *pvParameters)
|
||
{
|
||
vTaskDelay(10);
|
||
write_log(log_path,"task 1",10);
|
||
|
||
while(1)
|
||
{
|
||
// vTaskDelay(1000);
|
||
// //获取时间
|
||
// rtc.getDateTime(&now);
|
||
|
||
// //获取温度
|
||
// // float temp[8];
|
||
// // getall_temp(temp);
|
||
// // //平均温度
|
||
// // float temp_ave = 0;
|
||
// // for (size_t i = 0; i < 8; i++)
|
||
// // {
|
||
// // temp_ave += temp[i];
|
||
// // }
|
||
// // temp_ave = temp_ave / 8;
|
||
// // write_log(log_path,"temp_ave: " + String(temp_ave),log_level);
|
||
|
||
// //获取GPS
|
||
// gps_struct gps_structure;
|
||
|
||
// String gpsbac = get_GPS(&gps_structure);
|
||
// //计算日出日落
|
||
// double transit, sunrise, sunset;
|
||
// double utc_offset = 8;
|
||
// if (gpsbac != "-1")
|
||
// {
|
||
// calcSunriseSunset(now.year+2000, now.month, now.day,gps_structure.latitude, gps_structure.longitude, transit, sunrise, sunset);
|
||
// }
|
||
// else
|
||
// {
|
||
// write_log(log_path,"no gps",10);
|
||
// }
|
||
|
||
// //日出日落控制 太阳升起前推杆缩，太阳落下后推杆伸
|
||
// write_log(log_path,"now.hour: " + String(now.hour),log_level);
|
||
// write_log(log_path,"sunrise: " + String((int)sunrise),log_level);
|
||
// write_log(log_path,"sunset: " + String((int)sunset),log_level);
|
||
// if (now.hour+1 == (int)sunrise)
|
||
// {
|
||
// tuigan(suo);
|
||
// }
|
||
// else if (now.hour+1 >= (int)sunset)
|
||
// {
|
||
// tuigan(tui);
|
||
// }
|
||
|
||
// if(sys_sd_doc["work_mode"] == "time_mode")
|
||
// {
|
||
// float now_time = now.hour + now.minute/100;
|
||
// if(now_time > start_time && now_time < stop_time)
|
||
// {
|
||
|
||
// }
|
||
// else
|
||
// {
|
||
// if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
|
||
// {
|
||
// caiji_mode = 0;
|
||
// }
|
||
// xSemaphoreGive(xMutexInventory);
|
||
// }
|
||
// }
|
||
|
||
// write_log(log_path,"temp_ave: " + String(temp_ave),log_level);
|
||
// if(temp_ave < Minimum_temperature)
|
||
// {
|
||
// write_log(log_path,"start jiaresi",10);
|
||
// jiaresi(5,start_jiare);
|
||
// vTaskDelay(1000 * 10);
|
||
// }
|
||
// else if (temp_ave > Minimum_temperature + 5)
|
||
// {
|
||
// write_log(log_path,"stop jiaresi",10);
|
||
// jiaresi(5,stop_jiare);
|
||
// }
|
||
// for(int ab ; ab < 10; ab++)
|
||
// {
|
||
|
||
rtc.getDateTime(&now);
|
||
// String path = "/guangpu_data/"+ String(now.year) + "/" + String(now.month) + "/" + String(now.day);
|
||
// if(!SD_MMC.exists(log_path))
|
||
|
||
//////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
double cardSize = SD_MMC.cardSize() / (1024 * 1024);
|
||
|
||
double used_size = SD_MMC.usedBytes() / (1024 * 1024);
|
||
|
||
float used_percent = used_size / cardSize;
|
||
write_log(log_path,"used_percent: " + String(used_percent),10);
|
||
//数据清除规则:1、满十年清除第一年数据 2、当数据>90%时删除最前一个月数据
|
||
if(used_percent >= 0.8)
|
||
{
|
||
if (used_percent >= 0.9)
|
||
{
|
||
//删除文件
|
||
String path_b = "/gaugpu_data";
|
||
for(int i=24;i<255 ;i++)
|
||
{
|
||
for (uint8_t j = 1; j < 13; i++)
|
||
{
|
||
String path_a = path_b + "/" +String(i)+ "/" +String(j);
|
||
if(SD_MMC.exists(path_a))
|
||
{
|
||
rm_dir_or_file(path_a.c_str());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//报警
|
||
write_log(log_path,"sdcard will full," + String(used_percent * 100) + "%" +"used.",10);
|
||
}
|
||
|
||
if(SD_MMC.exists("/guangpu_data/"+ String(now.year - 10) ))
|
||
{
|
||
String path = "/guangpu_data/"+ String(now.year - 10);
|
||
rm_dir_or_file(path.c_str());
|
||
}
|
||
|
||
|
||
// write_log(log_path,"delete /guangpu_data/0 1111111111",10);
|
||
|
||
// if(SD_MMC.exists("/guangpu_data/0"))
|
||
// {
|
||
// write_log(log_path,"delete /guangpu_data/0 2222222222222222",10);
|
||
// // sdcard::deleteFolderOrFile("/gaugpu_data/0");
|
||
// rm_dir_or_file("/guangpu_data/0");
|
||
// }
|
||
///////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
//////////////////////////////////////////////时间////////////////////////////////////////////////////////////
|
||
//获取RTC时间
|
||
rtc.getDateTime(&now);
|
||
|
||
// 获取网络时间
|
||
gps_struct net_structure;
|
||
String net_date = getnetData();
|
||
write_log(log_path,"net_date is :"+net_date,10);
|
||
// 2024-07-12 07:12:45
|
||
|
||
//截取时间
|
||
if(net_date != "-1")
|
||
{
|
||
net_structure.year = net_date.substring(0,4).toInt() - 2000;
|
||
net_structure.month = net_date.substring(5,7).toInt();
|
||
net_structure.day = net_date.substring(8,10).toInt();
|
||
net_structure.hour = net_date.substring(11,13).toInt();
|
||
net_structure.minute = net_date.substring(14,16).toInt();
|
||
net_structure.second = net_date.substring(17,-1).toInt();
|
||
|
||
if(now.year != net_structure.year || now.month != net_structure.month || now.day != net_structure.day || now.hour - net_structure.hour || (fabs(now.minute - net_structure.minute)>5 ))
|
||
{
|
||
now.year = net_structure.year;
|
||
now.month = net_structure.month;
|
||
now.day = net_structure.day;
|
||
now.hour = net_structure.hour;
|
||
now.minute = net_structure.minute;
|
||
now.second = net_structure.second;
|
||
rtc.setDateTime(&now);
|
||
}
|
||
}
|
||
////获取GPS
|
||
gps_struct gps_structure;
|
||
String gpsbac = get_GPS(&gps_structure);
|
||
|
||
if(net_date != "-1" && gpsbac != "-1")
|
||
{
|
||
gps_structure.year = gps_structure.year - 2000;
|
||
if(now.year != gps_structure.year || now.month != gps_structure.month || now.day != gps_structure.day || now.hour != gps_structure.hour || (fabs(now.minute - net_structure.minute)>5 ))
|
||
{
|
||
now.year = gps_structure.year;
|
||
now.month = gps_structure.month;
|
||
now.day = gps_structure.day;
|
||
now.hour = gps_structure.hour;
|
||
now.minute = gps_structure.minute;
|
||
now.second = gps_structure.second;
|
||
rtc.setDateTime(&now);
|
||
}else write_log(log_path,"no gps",10);
|
||
}
|
||
//////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
|
||
//获取时间
|
||
rtc.getDateTime(&now);
|
||
if(sys_sd_doc["work_mode"] == "time_mode")
|
||
{
|
||
float now_time = now.hour + now.minute/100;
|
||
if(now_time > start_time && now_time < stop_time)
|
||
{
|
||
|
||
}
|
||
else
|
||
{
|
||
if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
|
||
{
|
||
caiji_mode = 0;
|
||
}
|
||
xSemaphoreGive(xMutexInventory);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
// sdcard::Mkdir(path);
|
||
|
||
float temp4 = getone_temp(4);
|
||
float temp6 = getone_temp(6);
|
||
write_log(log_path,"temp4 : " + String(temp4),10);
|
||
write_log(log_path,"temp6 : " + String(temp6),10);
|
||
|
||
if((temp4+temp6)/2 < 0)
|
||
{
|
||
write_log(log_path,"start jiaresi",10);
|
||
jiaresi(5,start_jiare);
|
||
vTaskDelay(1000 * 10);
|
||
}
|
||
else if ((temp4+temp6)/2 > 5)
|
||
{
|
||
write_log(log_path,"stop jiaresi",10);
|
||
jiaresi(5,stop_jiare);
|
||
}
|
||
vTaskDelay(1000 * 10);
|
||
}
|
||
}
|
||
|
||
// Task2的实现
|
||
void Task2(void *pvParameters)
|
||
{
|
||
vTaskDelay(20);
|
||
write_log(log_path,"task 2",10);
|
||
unsigned char read_buf[1024*10];
|
||
unsigned char command_data[1024 * 10];
|
||
unsigned char data_type;
|
||
String send_data ;
|
||
int send_lenth;
|
||
u_char send_buff[300];
|
||
|
||
while(1)
|
||
{
|
||
unsigned short data_length = 0;
|
||
//监测接收串口数据
|
||
while(wb485Serial.available())
|
||
{
|
||
data_length += wb485Serial.readBytes(&read_buf[data_length],1024*10);
|
||
for (uint32_t i = 0; i < 5000; i++)
|
||
{
|
||
if(wb485Serial.available() > 0)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
//如果接收到数据
|
||
if (data_length > 0)
|
||
{
|
||
// 测试数据
|
||
write_log(log_path,"data_length: " + String(data_length),log_level);
|
||
|
||
data_length = IRIS_Cut_Befor_Header(read_buf,data_length);
|
||
if (data_length < 0)
|
||
{
|
||
send_data = "send data error";
|
||
write_log(log_path,send_data,log_level);
|
||
send_lenth = IRIS_Protocol_Pack(0x01,(uint16_t)send_data.length(), (uint8_t *)send_data.c_str(),send_buff);
|
||
wb485Serial.write(send_buff,send_lenth);
|
||
// return;
|
||
}
|
||
int ret = IRIS_STM32_Protocol_Unpack(read_buf,data_length,&data_type,command_data);
|
||
write_log(log_path,"ret:" +String(ret),log_level);
|
||
if (ret > 0)
|
||
{
|
||
write_log(log_path,"data_type:" +String(data_type),log_level);
|
||
if(data_type == 0x00)//json
|
||
{
|
||
deserializeJson(doc,command_data);
|
||
write_log(log_path,"start json_command",log_level);
|
||
json_command();
|
||
doc.clear();
|
||
}
|
||
else if (data_type == 0x01)//String
|
||
{
|
||
// write_log(command_data,0);
|
||
}
|
||
else if (data_type == 0x03) //hex
|
||
{
|
||
write_log(log_path,"",log_level);
|
||
String dingbiao_path;
|
||
if (command_data[0] == 4 || command_data[0] == 5)
|
||
{
|
||
// is11Sensor->save_dingbiao(command_data);
|
||
//保存到sd卡
|
||
if(command_data[0] == 4)
|
||
{
|
||
if(command_data[1] == 0) dingbiao_path = "/dingbiao/dingbiao_up_gain.bin";
|
||
else if(command_data[1] == 1) dingbiao_path = "/dingbiao/dingbiao_up_offset.bin";
|
||
}
|
||
else if(command_data[0] == 5)
|
||
{
|
||
if(command_data[1] == 0) dingbiao_path = "/dingbiao/dingbiao_down_gain.bin";
|
||
else if(command_data[1] == 1) dingbiao_path = "/dingbiao/dingbiao_down_offset.bin";
|
||
}
|
||
is11Sensor->save_dingbiao(command_data);
|
||
File file = SD_MMC.open(dingbiao_path, "wb");
|
||
file.write((uint8_t *)&command_data, ret);
|
||
file.flush();
|
||
file.close();
|
||
}
|
||
}
|
||
else if(data_type == 0x04)
|
||
{
|
||
uint8_t num = command_data[0];
|
||
set_ds18b20_address(num,command_data+1);
|
||
}
|
||
|
||
send_data = "wb485 success";
|
||
write_log(log_path,send_data,log_level);
|
||
// send_lenth = IRIS_Protocol_Pack(0x01,(uint16_t)send_data.length(), (uint8_t *)send_data.c_str(),send_buff);
|
||
// wb485Serial.write(send_buff,send_lenth);
|
||
}
|
||
else
|
||
{
|
||
send_data = "send data error";
|
||
write_log(log_path,send_data,log_level);
|
||
send_lenth = IRIS_Protocol_Pack(0x01,(uint16_t)send_data.length(), (uint8_t *)send_data.c_str(),send_buff);
|
||
wb485Serial.write(send_buff,send_lenth);
|
||
}
|
||
|
||
memset(read_buf, 0, sizeof(read_buf));
|
||
memset(command_data, 0, sizeof(command_data));
|
||
}
|
||
// vTaskDelay(1);
|
||
}
|
||
}
|
||
/*
|
||
//处理json命令
|
||
command : 1、get_sensor_info
|
||
2、set_sensor_info
|
||
3、set_work_mode
|
||
4、get_work_mode
|
||
5、set_time_interval
|
||
6、start_work
|
||
7、stop_work
|
||
8、set_return_mode
|
||
9、set_atuo_return
|
||
10、set_return_data_type
|
||
11、get_9
|
||
12、
|
||
13、get_data
|
||
14、set_bochangxishu
|
||
15、get_bochangxishu
|
||
16、get_chongcaiyangbochang
|
||
|
||
18、get_darkcurrent
|
||
19、set_servo_offset
|
||
20、set_start_time
|
||
21、set_stop_time
|
||
22、set_maximum_temperature
|
||
23、set_Minimum_temperature
|
||
24、
|
||
*/
|
||
|
||
/*{"command":"","name":"gaoguangpu","version":"v2.0","SN":"123456","date":"","caiji_mode":"","time_interval":"","return_data_type":"","bochangxishu":""}*/
|
||
void json_command()
|
||
{
|
||
int ret;
|
||
bool save = false;
|
||
String send_str;
|
||
u_char send_buff[1000];
|
||
|
||
if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
|
||
{
|
||
//command 1
|
||
if (doc["command"] == "get_sensor_info")
|
||
{
|
||
rtc.getDateTime(&now);
|
||
sys_sd_doc["date"] = String(now.year+2000) + "-" + String(now.month) + "-" + String(now.day) + " " + String(now.hour) + ":" + String(now.minute) + ":" + String(now.second);
|
||
send_str = "";
|
||
serializeJson(sys_sd_doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
serializeJson(sys_sd_doc, send_str);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
//command 2
|
||
else if (doc["command"] == "set_sensor_info")
|
||
{
|
||
write_log(log_path,"set_sensor_info",log_level);
|
||
if(doc["name"] == NULL)
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "Name cannot be null";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
save = true ;
|
||
sys_sd_doc["name"] = doc["name"].as<String>();
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
|
||
if(doc["version"] == NULL)
|
||
{
|
||
|
||
}
|
||
else
|
||
{
|
||
save = true ;
|
||
sys_sd_doc["version"] = doc["version"].as<String>();
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
//command 3
|
||
else if (doc["command"] == "set_work_mode")
|
||
{
|
||
|
||
if(doc["work_mode"] == "manual_mode")
|
||
{
|
||
if(sys_sd_doc["work_mode"]=="low_power_mode") low_power_mode(1);
|
||
save = true ;
|
||
sys_sd_doc["work_mode"] = "manual_mode";
|
||
sys_sd_doc["caiji_mode"] = "single";
|
||
sys_sd_doc["atuo_return"] ="no";
|
||
sys_sd_doc["return_data_type"] = 0x00;
|
||
work_mode = 0;
|
||
caiji_mode = 0;
|
||
atuo_return = 0;
|
||
return_data_type = 0x00;
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else if (doc["work_mode"] == "time_mode")
|
||
{
|
||
if(sys_sd_doc["work_mode"]=="low_power_mode") low_power_mode(1);
|
||
save = true;
|
||
sys_sd_doc["work_mode"] = "time_mode";
|
||
sys_sd_doc["caiji_mode"] = "continue";
|
||
sys_sd_doc["atuo_return"] = "yes";
|
||
sys_sd_doc["return_data_type"] = 0x00;
|
||
work_mode = 1;
|
||
caiji_mode = 0;
|
||
atuo_return = 1;
|
||
return_data_type = 0x00;
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else if(doc["work_mode"] == "advanced_mode")
|
||
{
|
||
if(sys_sd_doc["work_mode"]=="low_power_mode") low_power_mode(1);
|
||
|
||
save = true;
|
||
sys_sd_doc["work_mode"] = "advanced_mode";
|
||
sys_sd_doc["caiji_mode"] = "advanced";
|
||
sys_sd_doc["atuo_return"] = "no";
|
||
sys_sd_doc["return_data_type"] = 0x00;
|
||
|
||
work_mode = 2;
|
||
caiji_mode = 0;
|
||
atuo_return = 0;
|
||
return_data_type = 0x00;
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else if(doc["work_mode"] == "low_power_mode")
|
||
{
|
||
save = true;
|
||
sys_sd_doc["work_mode"] = "low_power_mode";
|
||
sys_sd_doc["caiji_mode"] = "low_power";
|
||
sys_sd_doc["atuo_return"] = "no";
|
||
sys_sd_doc["return_data_type"] = 0x00;
|
||
|
||
work_mode = 3;
|
||
|
||
low_power_mode(0);
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "work mode error";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
//command 4.1
|
||
else if (doc["command"] == "set_caiji_mode")
|
||
{
|
||
if(doc["caiji_mode"] == "start")
|
||
{
|
||
if(sys_sd_doc["caiji_mode"]=="continue") caiji_mode = 2;
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else if(doc["caiji_mode"] == "stop")
|
||
{
|
||
if(sys_sd_doc["caiji_mode"]=="continue") caiji_mode = 0;
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else if(doc["caiji_mode"] == "single")
|
||
{
|
||
save = true;
|
||
sys_sd_doc["caiji_mode"] = doc["caiji_mode"].as<String>();
|
||
caiji_mode = 1;
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else if(doc["caiji_mode"] == "continue")
|
||
{
|
||
save = true;
|
||
sys_sd_doc["caiji_mode"] = doc["caiji_mode"].as<String>();
|
||
caiji_mode = 2;
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "work mode error";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
//command 4.2
|
||
else if (doc["command"] == "take_one_job")
|
||
{
|
||
|
||
|
||
if(caiji_mode == 0)
|
||
{
|
||
caiji_mode = 1;
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "Working";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
//command 4.3
|
||
else if (doc["command"] == "set_time_interval")
|
||
{
|
||
if (doc["time_interval"]>0)
|
||
{
|
||
save = true;
|
||
sys_sd_doc["time_interval"] = doc["time_interval"];
|
||
time_interval = doc["time_interval"];
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "time_interval error";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
//command 5
|
||
else if (doc["command"] == "get_work_mode")
|
||
{
|
||
doc.clear();
|
||
send_str = "";
|
||
doc["work_mode"] = sys_sd_doc["work_mode"].as<String>();
|
||
doc["caiji_mode"] = sys_sd_doc["caiji_mode"].as<String>();
|
||
doc["atuo_return"] = sys_sd_doc["atuo_return"].as<String>();
|
||
doc["return_data_type"] =sys_sd_doc["return_data_type"];
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
//command 6
|
||
else if(doc["command"] == "set_atuo_return")
|
||
{
|
||
if(doc["atuo_return"] == "yes")
|
||
{
|
||
save = true;
|
||
sys_sd_doc["atuo_return"] = doc["atuo_return"].as<String>();
|
||
atuo_return = 1;
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else if (doc["atuo_return"] == "no")
|
||
{
|
||
save = true;
|
||
sys_sd_doc["atuo_return"] = doc["atuo_return"].as<String>();
|
||
atuo_return = 0;
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "atuo_return error";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
//command 7
|
||
else if (doc["command"] == "set_return_data_type")
|
||
{
|
||
u_int8_t a = 0;
|
||
u_int32_t b = doc["return_data_type"];
|
||
switch (b)
|
||
{
|
||
case 0x00:
|
||
a=1;
|
||
break;
|
||
case 0x01:
|
||
a=1;
|
||
break;
|
||
case 0x02:
|
||
a=1;
|
||
break;
|
||
case 0x03:
|
||
a=1;
|
||
break;
|
||
case 0x04:
|
||
a=1;
|
||
break;
|
||
case 0x05:
|
||
a=1;
|
||
break;
|
||
case 0x10:
|
||
a=1;
|
||
break;
|
||
case 0x11:
|
||
a=1;
|
||
break;
|
||
case 0x12:
|
||
a=1;
|
||
break;
|
||
case 0x13:
|
||
a=1;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
if(a)
|
||
{
|
||
save = true;
|
||
sys_sd_doc["return_data_type"] = doc["return_data_type"];
|
||
return_data_type = doc["return_data_type"];
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "return_data_type error";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
//command 8
|
||
//保留，没用
|
||
else if (doc["command"] == "set_return_mode")
|
||
{
|
||
save = true;
|
||
sys_sd_doc["return_mode"] = doc["return_mode"].as<String>();
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
/*设置回传模式 */
|
||
}
|
||
//command 9
|
||
else if (doc["command"] == "get_data")
|
||
{
|
||
u_int8_t a = 0;
|
||
u_int32_t b = doc["return_data_type"];
|
||
switch (b)
|
||
{
|
||
case 0x00:
|
||
a=1;
|
||
break;
|
||
case 0x01:
|
||
a=1;
|
||
break;
|
||
case 0x02:
|
||
a=1;
|
||
break;
|
||
case 0x03:
|
||
a=1;
|
||
break;
|
||
case 0x04:
|
||
a=1;
|
||
break;
|
||
case 0x05:
|
||
a=1;
|
||
break;
|
||
case 0x06:
|
||
a=1;
|
||
break;
|
||
case 0x10:
|
||
a=1;
|
||
break;
|
||
case 0x11:
|
||
a=1;
|
||
break;
|
||
case 0x12:
|
||
a=1;
|
||
break;
|
||
case 0x13:
|
||
a=1;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
if(a && caiji_mode !=3)
|
||
{
|
||
return_data_type = doc["return_data_type"];
|
||
caiji_mode = 3;
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["caiji_state"] = "working";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
/* code */
|
||
}
|
||
//command 10
|
||
else if (doc["command"] == "set_bochangxishu")
|
||
{
|
||
float b1=0,b2=0,b3=0,b4=0;
|
||
b1 = doc["bochangxishu"]["b0"].as<float>();
|
||
b2 = doc["bochangxishu"]["b1"].as<float>();
|
||
b3 = doc["bochangxishu"]["b2"].as<float>();
|
||
b4 = doc["bochangxishu"]["b3"].as<float>();
|
||
|
||
if(b1!=0 && b2 !=0 && b3 != 0 && b4 != 0)
|
||
{
|
||
save = true;
|
||
bc_b1 = doc["bochangxishu"]["b0"].as<float>();
|
||
bc_b2 = doc["bochangxishu"]["b1"].as<float>();
|
||
bc_b3 = doc["bochangxishu"]["b2"].as<float>();
|
||
bc_b4 = doc["bochangxishu"]["b3"].as<float>();
|
||
|
||
sys_sd_doc["bochangxishu"]["b0"] = doc["bochangxishu"]["b0"].as<float>();
|
||
sys_sd_doc["bochangxishu"]["b1"] = doc["bochangxishu"]["b1"].as<float>();
|
||
sys_sd_doc["bochangxishu"]["b2"] = doc["bochangxishu"]["b2"].as<float>();
|
||
sys_sd_doc["bochangxishu"]["b3"] = doc["bochangxishu"]["b3"].as<float>();
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "bochangxishu error or null";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
|
||
//command 11
|
||
else if (doc["command"] == "get_bochangxishu")
|
||
{
|
||
doc.clear();
|
||
doc["bochangxishu"]["a0"] = sys_sd_doc["bochangxishu"]["a0"].as<float>();
|
||
doc["bochangxishu"]["a1"] = sys_sd_doc["bochangxishu"]["a1"].as<float>();
|
||
doc["bochangxishu"]["a2"] = sys_sd_doc["bochangxishu"]["a2"].as<float>();
|
||
doc["bochangxishu"]["a3"] = sys_sd_doc["bochangxishu"]["a3"].as<float>();
|
||
|
||
doc["bochangxishu"]["b0"] = sys_sd_doc["bochangxishu"]["b0"].as<float>();
|
||
doc["bochangxishu"]["b1"] = sys_sd_doc["bochangxishu"]["b1"].as<float>();
|
||
doc["bochangxishu"]["b2"] = sys_sd_doc["bochangxishu"]["b2"].as<float>();
|
||
doc["bochangxishu"]["b3"] = sys_sd_doc["bochangxishu"]["b3"].as<float>();
|
||
|
||
send_str = "";
|
||
doc["state"] = "ok";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
|
||
//command 12
|
||
else if (doc["command"] == "get_chongcaiyangbochang")
|
||
{
|
||
// String chongcaiyangbochang;
|
||
/* code */
|
||
}
|
||
|
||
//command 14
|
||
else if(doc["command"] == "set_servo_offset")
|
||
{
|
||
float angle = doc["servo_offset_angle"];
|
||
if(angle > 0 || angle < 180)
|
||
{
|
||
save = true;
|
||
sys_sd_doc["servo_offset_angle"] = doc["servo_offset_angle"].as<float>();
|
||
servo_offset(angle);
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "servo_offset_angle error or out of range";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
|
||
//command 15
|
||
else if(doc["command"] == "set_start_time")
|
||
{
|
||
float t = doc["start_time"].as<float>();
|
||
if(t>0 && t < 24)
|
||
{
|
||
save = true;
|
||
sys_sd_doc["start_time"] = doc["start_time"].as<float>();
|
||
start_time = doc["start_time"].as<float>();
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "start_time error or out of range";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
//command 16
|
||
else if(doc["command"] == "set_stop_time")
|
||
{
|
||
float tt = doc["stop_time"].as<float>();
|
||
if(tt>0 && tt < 24 && tt > start_time)
|
||
{
|
||
save = true;
|
||
sys_sd_doc["stop_time"] = doc["stop_time"].as<float>();
|
||
stop_time = doc["stop_time"];
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "stop_time error or out of range";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
//command 17
|
||
else if(doc["command"] == "set_maximum_temperature")
|
||
{
|
||
float te = doc["maximum_temperature"].as<float>();
|
||
if(te < 100)
|
||
{
|
||
save = true;
|
||
maximum_temperature = doc["maximum_temperature"].as<float>();
|
||
sys_sd_doc["maximum_temperature"] = doc["maximum_temperature"].as<float>();
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "maximum_temperature error or out of range";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
|
||
//command 18
|
||
else if(doc["command"] == "set_Minimum_temperature")
|
||
{
|
||
float tte = doc["Minimum_temperature"].as<float>();
|
||
if(tte < maximum_temperature)
|
||
{
|
||
save = true;
|
||
maximum_temperature = doc["Minimum_temperature"].as<float>();
|
||
sys_sd_doc["Minimum_temperature"] = doc["Minimum_temperature"].as<float>();
|
||
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "Minimum_temperature error or out of range";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
//command 19
|
||
else if(doc["command"] == "get_date")
|
||
{
|
||
send_str = "";
|
||
doc.clear();
|
||
rtc.getDateTime(&now);
|
||
doc["state"] = "ok";
|
||
doc["date"]["year"]= now.year;
|
||
doc["date"]["month"]= now.month;
|
||
doc["date"]["day"]= now.day;
|
||
doc["date"]["hour"]= now.hour;
|
||
doc["date"]["minute"]= now.minute;
|
||
doc["date"]["second"]= now.second;
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
//command 20
|
||
else if(doc["command"] == "get_caiji_state")
|
||
{
|
||
uint32_t percent;
|
||
send_str = "";
|
||
doc.clear();
|
||
if(caiji_state == 1)
|
||
{
|
||
doc["caiji_state"] = "finish";
|
||
percent = is11Sensor->work_progress;
|
||
doc["percent"] = percent;
|
||
doc["info"] = "end";
|
||
}
|
||
else if(caiji_state == 2 )
|
||
{
|
||
doc["caiji_state"] = "working";
|
||
percent = is11Sensor->work_progress;
|
||
doc["percent"] = percent;
|
||
if(percent < 100)
|
||
{
|
||
doc["info"] = "working";
|
||
}
|
||
else
|
||
{
|
||
doc["info"] = "end";
|
||
}
|
||
}
|
||
else doc["caiji_state"] = "no";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
//command 21
|
||
else if(doc["command"] == "start_opt")
|
||
{
|
||
if(sys_sd_doc["work_mode"] == "advanced_mode")
|
||
{
|
||
caiji_mode = 5;
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "The working mode is not advanced_mode";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
//command 22
|
||
else if(doc["command"] == "get_opt")
|
||
{
|
||
if(sys_sd_doc["work_mode"] == "advanced_mode")
|
||
{
|
||
send_str = "";
|
||
uint32_t aa = is11Sensor->dingbiao_shutter;
|
||
doc["opt"] = aa;
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "The working mode is not advanced_mode";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
else if(doc["command"] == "start_collect")
|
||
{
|
||
bool collect = true;
|
||
if(sys_sd_doc["work_mode"] == "advanced_mode")
|
||
{
|
||
// caiji_mode = 3;
|
||
if (doc["direction"] == "up")
|
||
{
|
||
advanced_direction = 0;
|
||
}
|
||
else if (doc["direction"] == "down")
|
||
{
|
||
advanced_direction = 1;
|
||
}
|
||
else if (doc["direction"] == "dark")
|
||
{
|
||
advanced_direction = 2;
|
||
}
|
||
else
|
||
{
|
||
collect = false;
|
||
// send_str = "";
|
||
// doc["state"] = "failed";
|
||
// doc["info"] = "direction error";
|
||
// serializeJson(doc, send_str);
|
||
// ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
// wb485Serial.write(send_buff, ret);
|
||
}
|
||
|
||
if(doc["shutter_time"]>=1)
|
||
{
|
||
advanced_shutter_time = doc["shutter_time"];
|
||
}
|
||
else
|
||
{
|
||
collect = false;
|
||
// send_str = "";
|
||
// doc["state"] = "failed";
|
||
// doc["info"] = "shutter_time error";
|
||
// serializeJson(doc, send_str);
|
||
// ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
// wb485Serial.write(send_buff, ret);
|
||
}
|
||
|
||
if(doc["collect_times"]>0)
|
||
{
|
||
advanced_collect_times = doc["collect_times"];
|
||
}
|
||
else
|
||
{
|
||
collect = false;
|
||
// send_str = "";
|
||
// doc["state"] = "failed";
|
||
// doc["info"] = "collect_times error";
|
||
// serializeJson(doc, send_str);
|
||
// ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
// wb485Serial.write(send_buff, ret);
|
||
}
|
||
if(doc["remove_dark"] == "yes")
|
||
{
|
||
advanced_remove_dark = 1;
|
||
}
|
||
else if(doc["remove_dark"] == "no")
|
||
{
|
||
advanced_remove_dark = 0;
|
||
}
|
||
else
|
||
{
|
||
collect = false;
|
||
// send_str = "";
|
||
// doc["state"] = "failed";
|
||
// doc["info"] = "remove_dark error";
|
||
// serializeJson(doc, send_str);
|
||
// ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
// wb485Serial.write(send_buff, ret);
|
||
}
|
||
|
||
if (collect)
|
||
{
|
||
caiji_mode = 4;
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "parameter error";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "The working mode is not advanced_mode";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
//command 25
|
||
else if(doc["command"] == "set_sys_time")
|
||
{
|
||
uint32_t year,month,day,hour,minute,second;
|
||
|
||
year = doc["year"];
|
||
month = doc["month"];
|
||
day = doc["day"];
|
||
hour = doc["hour"];
|
||
minute = doc["minute"];
|
||
second = doc["second"];
|
||
write_log(log_path,"year" + String(year) + "month" + String(month) + "day" + String(day) + "hour" + String(hour) + "minute" + String(minute) + "second" + String(second),10);
|
||
if(year>99 || month>12 || day>31 || hour > 23 || minute >59 || second > 59)
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "date error1";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
if(sys_set_time(year,month,day))
|
||
{
|
||
now.year = year;
|
||
now.month = month;
|
||
now.day = day;
|
||
now.hour = hour;
|
||
now.minute =minute;
|
||
now.second =second;
|
||
// now.dow = 5;
|
||
rtc.setDateTime(&now);
|
||
send_str = "";
|
||
doc["state"] = "success";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "date error2";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
}
|
||
}
|
||
//command 26
|
||
// else if(doc["command"] == "set_ds18b20_address")
|
||
// {
|
||
// uint8_t num = doc["num"];
|
||
// uint8_t addr[8];
|
||
// if (num>=0 && num<8)
|
||
// {
|
||
// addr[0] = doc["addr"]["0"];
|
||
// addr[1] = doc["addr"]["1"];
|
||
// addr[2] = doc["addr"]["2"];
|
||
// addr[3] = doc["addr"]["3"];
|
||
// addr[4] = doc["addr"]["4"];
|
||
// addr[5] = doc["addr"]["5"];
|
||
// addr[6] = doc["addr"]["6"];
|
||
// addr[7] = doc["addr"]["7"];
|
||
|
||
// set_ds18b20_address(num, addr);
|
||
// save_sd_ds18b20_address(num,addr);
|
||
// send_str = "";
|
||
// doc["state"] = "success";
|
||
// serializeJson(doc, send_str);
|
||
// ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
// wb485Serial.write(send_buff, ret);
|
||
// }
|
||
// else
|
||
// {
|
||
// send_str = "";
|
||
// doc["state"] = "failed";
|
||
// doc["info"] = "num error";
|
||
// serializeJson(doc, send_str);
|
||
// ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
// wb485Serial.write(send_buff, ret);
|
||
// }
|
||
// }
|
||
else if(doc["command"] == "get_dingbiao")
|
||
{
|
||
send_dingbiao("/dingbiao/dingbiao_up_gain.bin");
|
||
send_dingbiao("/dingbiao/dingbiao_up_offset.bin");
|
||
send_dingbiao("/dingbiao/dingbiao_down_gain.bin");
|
||
send_dingbiao("/dingbiao/dingbiao_down_offset.bin");
|
||
}
|
||
//command error
|
||
else
|
||
{
|
||
send_str = "";
|
||
doc["state"] = "failed";
|
||
doc["info"] = "no command";
|
||
serializeJson(doc, send_str);
|
||
ret = IRIS_Protocol_Pack(0x00,(uint16_t)send_str.length(), (uint8_t *)send_str.c_str(),send_buff);
|
||
wb485Serial.write(send_buff, ret);
|
||
}
|
||
//将修改后的系统信息写入内存卡
|
||
if(save == true)
|
||
{
|
||
send_str = "";
|
||
serializeJson(sys_sd_doc, send_str);
|
||
|
||
File file;
|
||
file = SD_MMC.open("/system_info.json","w+");
|
||
file.println(send_str);
|
||
file.flush();
|
||
file.close();
|
||
}
|
||
}
|
||
xSemaphoreGive(xMutexInventory);
|
||
}
|
||
|
||
|
||
String get_GPS(gps_struct *gps)
|
||
{
|
||
write_log(log_path,"start get GPS ",10);
|
||
String gpsbac,Date,temp,Latitude,Longitude;
|
||
gsmmanger->modem->sendAT(GF("+CGNSPWR?"));
|
||
gsmmanger->modem->waitResponse("OK");
|
||
|
||
gsmmanger->modem->sendAT(GF("+CGNSPWR=1"));
|
||
gsmmanger->modem->waitResponse("OK");
|
||
|
||
gsmmanger->modem->sendAT(GF("+CGNSAID=31,1,1,1"));
|
||
gsmmanger->modem->waitResponse("OK");
|
||
|
||
gsmmanger->modem->sendAT(GF("+CGNSINF"));
|
||
|
||
//获取gps信息
|
||
gsmmanger->modem->waitResponse(5000,gpsbac);
|
||
write_log(log_path,"gpsbac is " + gpsbac,10);
|
||
|
||
//检测是否有效
|
||
temp = gpsbac.substring(16,17);
|
||
// write_log(log_path,"hahaha :" + temp,10);
|
||
|
||
if(temp != "1")
|
||
{
|
||
// write_log(log_path,"gps error,hahahaha",10);
|
||
return "-1";
|
||
}
|
||
//截取时间
|
||
Date = gpsbac.substring(18,32);
|
||
temp = Date.substring(0,4) + "-" + Date.substring(4,6) + "-" +Date.substring(6,8) + " " + Date.substring(8,10) + ":" +Date.substring(10,12) + ":" +Date.substring(12,-1);
|
||
|
||
gps->year = Date.substring(0,4).toInt();
|
||
gps->month = Date.substring(4,6).toInt();
|
||
gps->day = Date.substring(6,8).toInt();
|
||
gps->hour = Date.substring(8,10).toInt();
|
||
gps->minute = Date.substring(10,12).toInt();
|
||
gps->second = Date.substring(12,-1).toInt();
|
||
|
||
Date = temp;
|
||
// +CGNSINF: 1,1,20240430052525,40.040938,116.328013,51.900,0.26,0.00,3,,2.14,2.42,4.00,,10,8,,,34,,
|
||
|
||
// OK
|
||
////////获取经纬度//////////
|
||
temp = gpsbac.substring(33);
|
||
// write_log(log_path,"Longitude is :" + temp,10);
|
||
int pos = temp.indexOf(",");
|
||
Latitude = temp.substring(0,pos);
|
||
gps->latitude = Latitude.toFloat();
|
||
// write_log(log_path,"Latitude ::::" + Latitude,10);
|
||
|
||
temp = temp.substring(pos+1);
|
||
// write_log(log_path,"Longitude is :" + temp,10);
|
||
pos = temp.indexOf(",");
|
||
Longitude = temp.substring(0,pos);
|
||
gps->longitude = Longitude.toFloat();
|
||
// write_log(log_path,"Longitude ::::" + Longitude,10);
|
||
|
||
if(Date.indexOf(",") != -1)
|
||
{
|
||
return "-1";
|
||
}
|
||
|
||
return Date;
|
||
}
|
||
|
||
|
||
|
||
void sys_info_init()
|
||
{
|
||
gps_struct gps_structure;
|
||
String system_info;
|
||
String rtcdate_now ="20" + String(now.year) + "-" + String(now.month) + "-" + String(now.day) + " " + String(now.hour) + ":" + String(now.minute) + ":" + String(now.second);
|
||
write_log(log_path,rtcdate_now,10);
|
||
if(SD_MMC.exists("/system_info.json"))
|
||
{
|
||
write_log(log_path,"has system_info.json file",log_level);
|
||
File file;
|
||
file = SD_MMC.open("/system_info.json","rb+");
|
||
system_info = file.readString();
|
||
file.flush();
|
||
file.close();
|
||
|
||
deserializeJson(doc, system_info);
|
||
//初始化系统信息
|
||
sys_sd_doc["name"] = doc["name"].as<String>();
|
||
sys_sd_doc["serialnumber"] = STRSensorInfos_structure.serialnumber;
|
||
// sys_sd_doc["serialnumber"] = "is110008";
|
||
sys_sd_doc["version"] = doc["version"].as<String>();
|
||
sys_sd_doc["date"] = rtcdate_now;
|
||
|
||
sys_sd_doc["work_mode"] = doc["work_mode"].as<String>(); //一会
|
||
if(doc["work_mode"] == "manual_mode")
|
||
{
|
||
work_mode = 0;
|
||
}
|
||
else if (doc["work_mode"] == "time_mode")
|
||
{
|
||
work_mode = 1;
|
||
}
|
||
else
|
||
{
|
||
work_mode = 0;
|
||
}
|
||
|
||
// if(caiji_mode == 7)
|
||
// {
|
||
// sys_sd_doc["work_mode"] = "specify";
|
||
// }
|
||
|
||
|
||
sys_sd_doc["caiji_mode"] = doc["caiji_mode"].as<String>();//一会
|
||
if(doc["caiji_mode"] == "start")
|
||
{
|
||
if(sys_sd_doc["caiji_mode"]=="continue") caiji_mode = 2;
|
||
}
|
||
else if(doc["caiji_mode"] == "stop")
|
||
{
|
||
if(sys_sd_doc["caiji_mode"]=="continue") caiji_mode = 0;
|
||
}
|
||
else if(doc["caiji_mode"] == "single")
|
||
{
|
||
sys_sd_doc["caiji_mode"] = doc["caiji_mode"].as<String>();
|
||
caiji_mode = 1;
|
||
}
|
||
else if(doc["caiji_mode"] == "continue")
|
||
{
|
||
sys_sd_doc["caiji_mode"] = doc["caiji_mode"].as<String>();
|
||
caiji_mode = 2;
|
||
}
|
||
else
|
||
{
|
||
|
||
}
|
||
|
||
sys_sd_doc["time_interval"] = doc["time_interval"];
|
||
time_interval = doc["time_interval"].as<uint32_t>();
|
||
sys_sd_doc["start_time"] = doc["start_time"].as<float>();
|
||
start_time = doc["start_time"].as<uint32_t>();
|
||
sys_sd_doc["stop_time"] = doc["stop_time"].as<float>();
|
||
stop_time = doc["stop_time"].as<float>();
|
||
sys_sd_doc["maximum_temperature"] = doc["maximum_temperature"].as<float>();
|
||
maximum_temperature = doc["maximum_temperature"].as<float>();
|
||
sys_sd_doc["Minimum_temperature"] = doc["Minimum_temperature"].as<float>();
|
||
Minimum_temperature = doc["Minimum_temperature"].as<float>();
|
||
sys_sd_doc["servo_offset_angle"] = doc["servo_offset_angle"].as<float>();
|
||
float a = doc["servo_offset_angle"].as<float>();
|
||
servo_offset(a);
|
||
sys_sd_doc["bochangxishu"]["a0"] = STRSensorInfos_structure.a1;
|
||
sys_sd_doc["bochangxishu"]["a1"] = STRSensorInfos_structure.a2;
|
||
sys_sd_doc["bochangxishu"]["a2"] = STRSensorInfos_structure.a3;
|
||
sys_sd_doc["bochangxishu"]["a3"] = STRSensorInfos_structure.a4;
|
||
|
||
sys_sd_doc["bochangxishu"]["b0"] = doc["bochangxishu"]["b0"].as<float>();
|
||
sys_sd_doc["bochangxishu"]["b1"] = doc["bochangxishu"]["b1"].as<float>();
|
||
sys_sd_doc["bochangxishu"]["b2"] = doc["bochangxishu"]["b2"].as<float>();
|
||
sys_sd_doc["bochangxishu"]["b3"] = doc["bochangxishu"]["b3"].as<float>();
|
||
sys_sd_doc["return_data_type"] = doc["return_data_type"].as<float>();
|
||
sys_sd_doc["return_mode"] = doc["return_mode"]; //暂定
|
||
sys_sd_doc["atuo_return"] = doc["atuo_return"].as<String>();//一会
|
||
if(doc["atuo_return"] == "yes")
|
||
{
|
||
atuo_return = 1;
|
||
}
|
||
else
|
||
{
|
||
atuo_return = 0;
|
||
}
|
||
sys_sd_doc["gps_info"]["latitude"] = gps_structure.latitude;
|
||
sys_sd_doc["gps_info"]["longitude"] = gps_structure.longitude;
|
||
|
||
system_info = "";
|
||
serializeJson(sys_sd_doc, system_info);
|
||
write_log(log_path, system_info,log_level);
|
||
|
||
doc.clear();
|
||
}
|
||
else{
|
||
write_log(log_path,"do not has system_info.json file" ,log_level);
|
||
|
||
sys_sd_doc["name"] = "HS";
|
||
// sys_sd_doc["serialnumber"] = "is110008";
|
||
sys_sd_doc["serialnumber"] = STRSensorInfos_structure.serialnumber;
|
||
sys_sd_doc["version"] = "v2.0";
|
||
sys_sd_doc["date"] = rtcdate_now;
|
||
sys_sd_doc["work_mode"] = "manual_mode";
|
||
sys_sd_doc["caiji_mode"] = "stop";
|
||
sys_sd_doc["time_interval"] = time_interval;
|
||
sys_sd_doc["start_time"] = start_time;
|
||
sys_sd_doc["stop_time"] = stop_time;
|
||
sys_sd_doc["maximum_temperature"] = maximum_temperature;
|
||
sys_sd_doc["Minimum_temperature"] = Minimum_temperature;
|
||
sys_sd_doc["servo_offset_angle"] = 0;
|
||
|
||
sys_sd_doc["bochangxishu"]["a0"] = STRSensorInfos_structure.a1;
|
||
sys_sd_doc["bochangxishu"]["a1"] = STRSensorInfos_structure.a2;
|
||
sys_sd_doc["bochangxishu"]["a2"] = STRSensorInfos_structure.a3;
|
||
sys_sd_doc["bochangxishu"]["a3"] = STRSensorInfos_structure.a4;
|
||
|
||
sys_sd_doc["bochangxishu"]["b0"] = bc_b1;
|
||
sys_sd_doc["bochangxishu"]["b1"] = bc_b2;
|
||
sys_sd_doc["bochangxishu"]["b2"] = bc_b3;
|
||
sys_sd_doc["bochangxishu"]["b3"] = bc_b4;
|
||
sys_sd_doc["return_data_type"] = return_data_type;
|
||
sys_sd_doc["return_mode"] = ""; //暂定
|
||
sys_sd_doc["atuo_return"] = "no";
|
||
sys_sd_doc["gps_info"]["latitude"] = gps_structure.latitude;
|
||
sys_sd_doc["gps_info"]["longitude"] = gps_structure.longitude;
|
||
|
||
serializeJson(sys_sd_doc, system_info);
|
||
write_log(log_path, system_info,log_level);
|
||
|
||
File file;
|
||
file = SD_MMC.open("/system_info.json","w+");
|
||
file.println(system_info);
|
||
file.flush();
|
||
file.close();
|
||
}
|
||
}
|
||
|
||
|
||
|
||
bool sys_set_time(uint32_t year,uint32_t month,uint32_t day)
|
||
{
|
||
uint32_t m[4] ={4,6,9,11};
|
||
year = year + 2000;
|
||
for(int i = 0; i < 4; i++)
|
||
{
|
||
if(month == m[i])
|
||
{
|
||
if(day >= 31) return false;
|
||
}
|
||
}
|
||
if(month == 2)
|
||
{
|
||
if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
|
||
{
|
||
|
||
// write_log(log_path,"is ruannian" + String(day),10);
|
||
if(day > 29) return false;
|
||
}
|
||
else
|
||
{
|
||
// write_log(log_path,"not is " + String(day),10);
|
||
if(day > 28) return false;
|
||
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// void save_ds18b20_address(uint8_t *data)
|
||
// {
|
||
// uint8_t add[8][8]={0};
|
||
// uint8_t num = data[0];
|
||
// for(uint8_t i = 0; i < 8; i++)
|
||
// {
|
||
// add[num][i] = data[i+1];
|
||
// }
|
||
|
||
// File file = SD_MMC.open("/ds18b20_address.bin", "wb");
|
||
// file.write((uint8_t *)add, 64);
|
||
// file.flush();
|
||
// file.close();
|
||
// }
|
||
|
||
// void read_ds18b20_address()
|
||
// {
|
||
// uint8_t add[8][8]={0};
|
||
// File file = SD_MMC.open("/ds18b20_address.bin", "rb");
|
||
// file.read((uint8_t *)add, 64);
|
||
// file.flush();
|
||
// file.close();
|
||
|
||
// for(uint8_t i = 0; i < 8; i++)
|
||
// {
|
||
// set_ds18b20_address(i,add[i]);
|
||
// }
|
||
// }
|
||
|
||
|
||
|
||
// void sd_read_set_ds18b20_address()
|
||
// {
|
||
// uint8_t add[8];
|
||
// String str1[8] = {"sensor0","sensor1","sensor2","sensor3","sensor4","sensor5","sensor6","sensor7"};
|
||
// String str2[8] = {"byte0","byte1","byte2","byte3","byte4","byte5","byte6","byte7"};
|
||
|
||
// if(SD_MMC.exists("/temp_sensor.json"))
|
||
// {
|
||
// File file;
|
||
// file = SD_MMC.open("/temp_sensor.json","rb+");
|
||
// String temp_sensor = file.readString();
|
||
// file.flush();
|
||
// file.close();
|
||
// deserializeJson(doc, temp_sensor);
|
||
// for(uint8_t a = 0; a < 8; a++)
|
||
// {
|
||
// for(uint8_t b = 0; b < 8; b++)
|
||
// {
|
||
// add[b] = doc[str1[a]][str2[b]];
|
||
// ds18b20_doc[a][b] = doc[str1[a]][str2[b]];
|
||
// }
|
||
// set_ds18b20_address(a,add);
|
||
// }
|
||
// temp_sensor = "";
|
||
// serializeJson(doc, temp_sensor);
|
||
// write_log(log_path, temp_sensor,log_level);
|
||
// }
|
||
// else
|
||
// {
|
||
// write_log(log_path,"do not has file",10);
|
||
// for(uint8_t a = 0; a < 8; a++)
|
||
// {
|
||
// for(uint8_t b = 0; b < 8; b++)
|
||
// {
|
||
// ds18b20_doc[a][b] = "";
|
||
// }
|
||
// }
|
||
// File file;
|
||
// file = SD_MMC.open("/temp_sensor.json","w+");
|
||
// file.flush();
|
||
// file.close();
|
||
// }
|
||
// doc.clear();
|
||
// }
|
||
|
||
// void save_sd_ds18b20_address(uint8_t num,uint8_t *addr)
|
||
// {
|
||
// String str1[8] = {"sensor0","sensor1","sensor2","sensor3","sensor4","sensor5","sensor6","sensor7"};
|
||
// String str2[8] = {"byte0","byte1","byte2","byte3","byte4","byte5","byte6","byte7"};
|
||
// String temp_sensor;
|
||
|
||
// for(uint8_t i = 0; i < 8; i++)
|
||
// {
|
||
// ds18b20_doc[str1[num]][str2[i]] = addr[i];
|
||
// }
|
||
|
||
// temp_sensor = "";
|
||
// serializeJson(ds18b20_doc, temp_sensor);
|
||
// write_log(log_path, temp_sensor,log_level);
|
||
// File file;
|
||
// file = SD_MMC.open("/temp_sensor.json","w+");
|
||
// file.println(temp_sensor);
|
||
// file.flush();
|
||
// file.close();
|
||
// }
|
||
|
||
//dingbiao_path
|
||
//1、dingbiao/dingbiao_up_gain.txt
|
||
//2、dingbiao/dingbiao_up_offset.txt
|
||
//3、dingbiao/dingbiao_down_gain.txt
|
||
//4、dingbiao/dingbiao_down_offset.txt
|
||
|
||
|
||
bool read_dingbiao(String dingbiao_path,uint8_t *dianbiao_data_buff)
|
||
{
|
||
if(SD_MMC.exists(dingbiao_path))
|
||
{
|
||
File file;
|
||
file = SD_MMC.open(dingbiao_path,"rb");
|
||
file.read(dianbiao_data_buff,sizeof(IS11_datastruct));
|
||
file.flush();
|
||
file.close();
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void send_dingbiao(String dingbiao_path)
|
||
{
|
||
uint32_t dingbiao_len = 0;
|
||
uint8_t *send_dingbiao_buff = new uint8_t[sizeof(IS11_datastruct)+7];
|
||
uint8_t *read_dingbiao_buff = new uint8_t[sizeof(IS11_datastruct)];
|
||
|
||
if(read_dingbiao(dingbiao_path,read_dingbiao_buff))
|
||
{
|
||
dingbiao_len = IRIS_Protocol_Pack(0x02,(uint16_t)sizeof(IS11_datastruct), read_dingbiao_buff,send_dingbiao_buff);
|
||
wb485Serial.write(send_dingbiao_buff,dingbiao_len);
|
||
}
|
||
|
||
delete read_dingbiao_buff;
|
||
delete send_dingbiao_buff;
|
||
}
|
||
|
||
void dingbiao_init(String dingbiao_path)
|
||
{
|
||
uint8_t *read_dingbiao_buff = new uint8_t[sizeof(IS11_datastruct)];
|
||
|
||
if(read_dingbiao(dingbiao_path,read_dingbiao_buff))
|
||
{
|
||
is11Sensor->save_dingbiao(read_dingbiao_buff);
|
||
}
|
||
delete read_dingbiao_buff;
|
||
}
|
||
|
||
|
||
|
||
|
||
// /////////////////////////////////上传数据/////////////////////////////////////
|
||
// bool UpdateData(String path, char *str, size_t lenth, String Contenttype = "")
|
||
// {
|
||
// http->beginRequest();
|
||
// http->post(path);
|
||
// if (Contenttype != "")
|
||
// {
|
||
// http->sendHeader(HTTP_HEADER_CONTENT_TYPE, Contenttype);
|
||
|
||
// /* code */
|
||
// }
|
||
|
||
// http->sendHeader(HTTP_HEADER_CONTENT_LENGTH, lenth);
|
||
// http->endRequest();
|
||
// int err = http->write((const byte *)str, lenth);
|
||
// delay(1000);
|
||
// Serial.print("send date size");
|
||
// Serial.println(err);
|
||
|
||
// /*
|
||
// for (size_t i = 0; i < lenth; i++)
|
||
// {
|
||
// Serial.print("0x");
|
||
// Serial.print(str[i],HEX);
|
||
// Serial.print(" ");
|
||
// if (i%20==0)
|
||
// {
|
||
// Serial.println(" ");
|
||
// }
|
||
// }
|
||
// */
|
||
// // http->write((const byte*)IS1Sensor.UpData, IS1Sensor.SensorInfo.BandNum*2);
|
||
// // http->stop();
|
||
// Serial.println("hear1");
|
||
// if (err == 0)
|
||
// {
|
||
// http->stop();
|
||
// return false;
|
||
// }
|
||
// int status = http->responseStatusCode();
|
||
// Serial.println("hear3");
|
||
// if (!status)
|
||
// {
|
||
// http->stop();
|
||
// return false;
|
||
// }
|
||
|
||
// int length = http->contentLength();
|
||
// Serial.println("hear4");
|
||
// if (length == 0)
|
||
// {
|
||
// http->stop();
|
||
// return false;
|
||
// }
|
||
|
||
// String body = http->responseBody();
|
||
// Serial.println("body:"+body);
|
||
// if (body != "ok")
|
||
// {
|
||
// http->stop();
|
||
// return false;
|
||
// }
|
||
|
||
// http->stop();
|
||
// return true;
|
||
// }
|
||
|
||
|
||
// void ReuploadData(String path, String webpath, String content = "")
|
||
// {
|
||
// vTaskDelay(1);
|
||
// Vector<String> files;
|
||
// String vec[20]; //每次处理20个
|
||
// files.setStorage(vec);
|
||
// while (!sdcard::ListDir(path.c_str(), files))
|
||
// {
|
||
// if (files.size() != 0)
|
||
// {
|
||
// Serial.println("find " + String(files.size()) + "file");
|
||
// for (size_t i = 0; i < files.size(); i++)
|
||
// {
|
||
// File nowfile = SD_MMC.open(files.at(i).c_str(), "rb");
|
||
// size_t size = nowfile.size();
|
||
// char *arr = new char[size];
|
||
// nowfile.readBytes(arr, size);
|
||
// bool flagsucc = UpdateData(webpath, arr, size, content);
|
||
// if (!flagsucc)
|
||
// {
|
||
// return;
|
||
// /* code */
|
||
// }
|
||
// delete[] arr;
|
||
// sdcard::deleteFolderOrFile(files.at(i).c_str());
|
||
// vTaskDelay(1);
|
||
// /* code */
|
||
// }
|
||
// }
|
||
// vTaskDelay(1);
|
||
// }
|
||
// if (files.size() != 0)
|
||
// {
|
||
// Serial.println("find " + String(files.size()) + "file not enough 20");
|
||
// for (size_t i = 0; i < files.size(); i++)
|
||
// {
|
||
// vTaskDelay(1);
|
||
// File nowfile = SD_MMC.open(files.at(i).c_str(), "rb");
|
||
// size_t size = nowfile.size();
|
||
// char *arr = new char[size];
|
||
// nowfile.readBytes(arr, size);
|
||
// Serial.println("run here now");
|
||
// bool flagsucc = UpdateData(webpath, arr, size, content);
|
||
// if (!flagsucc)
|
||
// {
|
||
// return;
|
||
// /* code */
|
||
// }
|
||
|
||
// delete[] arr;
|
||
// sdcard::deleteFolderOrFile(files.at(i).c_str());
|
||
// /* code */
|
||
// }
|
||
// }
|
||
// vTaskDelay(1);
|
||
// }
|
||
// ///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
|
||
|
||
|
||
|
||
String getnetData()
|
||
{
|
||
write_log(log_path,"start get net data",10);
|
||
int err = http->get("/weather/php/Date.php");
|
||
if (err != 0)
|
||
{
|
||
return "-1";
|
||
}
|
||
write_log(log_path,"responseStatusCode",10);
|
||
int status = http->responseStatusCode();
|
||
if (!status)
|
||
{
|
||
return "-1";
|
||
}
|
||
|
||
int times_try = 0;
|
||
write_log(log_path,"headerAvailable",10);
|
||
while (http->headerAvailable())
|
||
{
|
||
if(times_try > 100)
|
||
{
|
||
http->stop();
|
||
return "-1";
|
||
}
|
||
write_log(log_path,"readHeaderName",10);
|
||
String headerName = http->readHeaderName();
|
||
write_log(log_path,"readHeaderValue",10);
|
||
String headerValue = http->readHeaderValue();
|
||
|
||
vTaskDelay(100);
|
||
times_try++;
|
||
}
|
||
write_log(log_path,"isResponseChunked",10);
|
||
if (http->isResponseChunked())
|
||
{
|
||
}
|
||
write_log(log_path,"contentLength",10);
|
||
String body = http->responseBody();
|
||
http->stop();
|
||
return body;
|
||
}
|
||
|
||
|
||
void rm_dir_or_file( const char * dirname)
|
||
{
|
||
File root = SD_MMC.open(dirname);
|
||
String dir = String(dirname);
|
||
if(root.isDirectory())
|
||
{
|
||
File file = root.openNextFile();
|
||
if(file)
|
||
{
|
||
if (file.isDirectory())
|
||
{
|
||
dir = String(dirname) + "/" + String(file.name());
|
||
write_log(log_path,dir,10);
|
||
rm_dir_or_file(dir.c_str());
|
||
}
|
||
else
|
||
{
|
||
do
|
||
{
|
||
dir = String(dirname) + "/" + String(file.name());
|
||
if(SD_MMC.remove(dir))
|
||
{
|
||
write_log(log_path,"remove file success",10);
|
||
}
|
||
else
|
||
{
|
||
write_log(log_path,"remove file failed",10);
|
||
break;
|
||
}
|
||
file = root.openNextFile();
|
||
if(!file) break;
|
||
} while (!file.isDirectory());
|
||
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
SD_MMC.rmdir(dir);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
SD_MMC.remove(dir);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
// void rm_dir_or_file( const char * dirname)
|
||
// {
|
||
// File root = SD_MMC.open(dirname);
|
||
// String dir = String(dirname);
|
||
|
||
// if(root.isDirectory())
|
||
// {
|
||
// File file = root.openNextFile();
|
||
// if(file)
|
||
// {
|
||
// while (file.isDirectory())
|
||
// {
|
||
// dir = String(dirname) + "/" + String(file.name());
|
||
// write_log(log_path,dir,10);
|
||
// rm_dir_or_file(dir.c_str());
|
||
// file = root.openNextFile();
|
||
// }
|
||
// if(!file.isDirectory())
|
||
// {
|
||
// do
|
||
// {
|
||
// dir = String(dirname) + "/" + String(file.name());
|
||
// if(SD_MMC.remove(dir))
|
||
// {
|
||
// write_log(log_path,"remove file success",10);
|
||
// }
|
||
// else
|
||
// {
|
||
// write_log(log_path,"remove file failed",10);
|
||
// break;
|
||
// }
|
||
// file = root.openNextFile();
|
||
// if(!file) break;
|
||
// } while (!file.isDirectory());
|
||
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// SD_MMC.rmdir(dir);
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// SD_MMC.remove(dir);
|
||
// }
|
||
// }
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//0:关闭 1:开启
|
||
void low_power_mode(uint8_t state)
|
||
{
|
||
if(state == 0)
|
||
{
|
||
//关闭光谱仪
|
||
pinMode(36,INPUT);
|
||
//关闭AIR780E
|
||
pinMode(37,OUTPUT);
|
||
digitalWrite(37,LOW);
|
||
}
|
||
else
|
||
{
|
||
//开启光谱仪
|
||
pinMode(36,OUTPUT);
|
||
digitalWrite(36,LOW);
|
||
//开启AIR780E
|
||
pinMode(37,OUTPUT);
|
||
digitalWrite(37,HIGH);
|
||
}
|
||
} |