2513 lines
71 KiB
C
2513 lines
71 KiB
C
/*
|
||
*********************************************************************************************************
|
||
* IAR Development Kits
|
||
* on the
|
||
*
|
||
* M451
|
||
*
|
||
* Filename : uart_dtu.c
|
||
* Version : V1.00
|
||
* Programmer(s) : Qian Xianghong
|
||
*********************************************************************************************************
|
||
*/
|
||
|
||
#include "includes.h"
|
||
|
||
#include "drv_dtu.h"
|
||
#include "drv_gps.h"
|
||
|
||
// 运动状态（默认为1，万一加速度计有问题）
|
||
volatile uint8_t Motion_Status = 1;
|
||
|
||
// 初始唤醒次数(快速发送）
|
||
#define INITIAL_TRAN_COUNT 6
|
||
|
||
// 绝对值
|
||
#define abs(x) ((x) < 0 ? -(x) : (x))
|
||
|
||
// GPS上报数据的时间戳，年基数为2010
|
||
#define GPS_BASE_YEAR 2010
|
||
|
||
// Boot-loader地址（在线升级以后重启运行）
|
||
#define LDROM_BASE 0x100000ul // 1M
|
||
|
||
// GPRS串口接收的循环缓冲
|
||
#define DTU_TASKM_DATA_COUNT 200
|
||
loopbuff_t DTU_TaskM;
|
||
uint8_t DTU_TaskM_Data[sizeof(uint8_t) * (DTU_TASKM_DATA_COUNT + 1)] = {0};
|
||
|
||
// 最近一条上传数据的采集时间
|
||
volatile uint32_t DTU_dataTime = 0;
|
||
// 发送成功时间
|
||
volatile uint32_t DTU_succTime = 0;
|
||
|
||
// 这个缓冲区比较大，不放在stack里面
|
||
char DTU_gpsData[2][DTU_GPSDATA_SIZE] = {0}; // 扩展内存
|
||
char DTU_recvBuff[DTU_RECVBUFF_SIZE] = {0}; // 扩展内存
|
||
|
||
// 一次请求升级包数据大小
|
||
#define UPGRADE_DATA_LEN 1024
|
||
|
||
// DTU_Task任务和服务器之间的收发缓冲
|
||
uint8_t Task_sendBuff[TASK_SENDBUFF_SIZE] = {0}; // 扩展内存
|
||
|
||
#if UPGRADE_DATA_LEN >= SFLASH_ERASE_SIZE
|
||
#define TASK_RECVBUFF_SIZE (UPGRADE_DATA_LEN + 32)
|
||
#else
|
||
#define TASK_RECVBUFF_SIZE (SFLASH_ERASE_SIZE)
|
||
#endif
|
||
uint8_t Task_recvBuff[TASK_RECVBUFF_SIZE] = {0}; // 扩展内存
|
||
|
||
// 信号量，用于通知执行任务
|
||
SemaphoreHandle_t DTU_semUpgrade = NULL;
|
||
|
||
// 用于发送到服务器的数据结构
|
||
// 和蓝牙的相应命令一致
|
||
#pragma pack(push, 1)
|
||
|
||
typedef struct
|
||
{
|
||
uint16_t mark;
|
||
unsigned ver : 7;
|
||
unsigned trans : 1;
|
||
unsigned reserved: 8;
|
||
uint16_t len;
|
||
union
|
||
{
|
||
uint16_t cmd;
|
||
struct
|
||
{
|
||
uint8_t err;
|
||
uint8_t cmd_L;
|
||
};
|
||
};
|
||
} bluetooth_recv_t;
|
||
|
||
typedef bluetooth_recv_t bluetooth_send_t;
|
||
|
||
typedef struct
|
||
{
|
||
unsigned staEPress3 : 2;
|
||
unsigned staETempr1 : 2;
|
||
unsigned staETempr2 : 2;
|
||
unsigned staETempr3 : 2;
|
||
|
||
unsigned staDiff : 2;
|
||
unsigned staPress : 2;
|
||
unsigned staEPress1 : 2;
|
||
unsigned staEPress2 : 2;
|
||
|
||
} bluetooth_sensor_t;
|
||
|
||
typedef struct
|
||
{
|
||
unsigned maskStamp : 1;
|
||
unsigned maskEPress1 : 1;
|
||
unsigned maskEPress2 : 1;
|
||
unsigned maskEPress3 : 1;
|
||
unsigned : 1;
|
||
unsigned maskLowPower : 1;
|
||
unsigned maskAbnormal : 1;
|
||
unsigned maskCharging : 1;
|
||
|
||
unsigned maskRssi : 1;
|
||
unsigned maskGPS : 1;
|
||
unsigned maskETempr1 : 1;
|
||
unsigned maskETempr2 : 1;
|
||
unsigned maskETempr3 : 1;
|
||
unsigned maskBattery : 1;
|
||
unsigned maskFlow : 1;
|
||
unsigned maskLeak : 1;
|
||
} bluetooth_mask_t;
|
||
|
||
typedef union
|
||
{
|
||
struct
|
||
{
|
||
unsigned sec : 6;
|
||
unsigned min : 6;
|
||
unsigned hour_L : 4;
|
||
unsigned hour_H : 1;
|
||
unsigned day : 5;
|
||
unsigned mon : 4;
|
||
unsigned year : 6;
|
||
};
|
||
uint32_t tm;
|
||
} bluetooth_timestamp_t;
|
||
|
||
typedef union
|
||
{
|
||
unsigned long long ll;
|
||
struct
|
||
{
|
||
unsigned long l;
|
||
unsigned long h;
|
||
};
|
||
} longlong_mask_t;
|
||
|
||
typedef struct
|
||
{
|
||
union
|
||
{
|
||
struct
|
||
{
|
||
unsigned sateCount : 5; // gps可见卫星数量
|
||
unsigned posState : 1; // gps定位状态 （0-GPS未定位，1-GPS已定位）
|
||
unsigned carState : 1; // 车辆是否启动 （0-车辆未启动，1-车辆已启动）
|
||
unsigned carEvent : 1; // 车辆启动或停止事件（0-启动状态未改变，1-启动状态已改变）
|
||
};
|
||
uint8_t state;
|
||
};
|
||
bluetooth_timestamp_t time; // 时间戳
|
||
int32_t latitude;
|
||
int32_t longitude;
|
||
uint16_t speed;
|
||
} gps_data_t;
|
||
|
||
typedef struct // size = 158
|
||
{
|
||
uint32_t sample_time; // 采集时间：自启动以来经过的秒数
|
||
data_dtu_t dtuData; // size = 36
|
||
data_sample_t sampleData; // size = 118
|
||
} gprs_data_t;
|
||
|
||
// 升级进度信息（存放在FRAM中，可断点续传）
|
||
typedef struct
|
||
{
|
||
uint16_t check; // 标志，固定为0x55AA
|
||
uint32_t ver; // 固件版本
|
||
int32_t fileSize; // 固件总字节数
|
||
uint16_t fileCrc; // 固件总的crc
|
||
int32_t offset; // 本次固件偏移量
|
||
int32_t len; // 本次数据长度
|
||
uint16_t crc; // 本记录的crc
|
||
} upgrade_info_t;
|
||
|
||
// 升级包接收记录
|
||
typedef struct
|
||
{
|
||
uint32_t ver; // 固件版本
|
||
int32_t fileSize; // 固件总字节数
|
||
uint16_t fileCrc; // 固件总的crc
|
||
int32_t offset; // 本次固件偏移量
|
||
int32_t len; // 本次数据长度
|
||
uint8_t data[UPGRADE_DATA_LEN]; // 本次数据
|
||
uint16_t crc; // 本次数据的crc
|
||
} upgrade_frame_t;
|
||
|
||
// 升级文件头
|
||
typedef struct // size=12
|
||
{
|
||
unsigned short check; // 数据有效标志, 0x55AA表示有效
|
||
unsigned upgrade_request : 1; // 升级请求标志，0-无升级，1-有升级
|
||
unsigned upgrade_result : 3; // 升级失败标志，0-成功，1-失败，其余保留
|
||
unsigned encrypt_flag : 2; // 加密标志， 0-无加密，其余保留
|
||
unsigned compress_flag : 2; // 压缩标志， 0-无压缩，1-有压缩，其余保留
|
||
unsigned rerseved1 : 8; // 保留，必须为0xFF
|
||
|
||
unsigned long upgrade_length; // 升级文件长度
|
||
|
||
unsigned rerseved2 : 8; // 保留，必须为0xFF
|
||
unsigned rerseved3 : 8; // 保留，必须为0xFF
|
||
unsigned short crc; // 对前面内容的crc校验
|
||
} TUpgradeHeader;
|
||
|
||
#pragma pack(pop)
|
||
|
||
// 升级包记录
|
||
upgrade_info_t upInfo = {0};
|
||
// 下载储罐档案记录
|
||
upgrade_info_t boxesInfo = {0};
|
||
// 储罐档案缓冲区
|
||
char boxesBuff[16384 + 1] = {0};
|
||
|
||
// 计算两个经纬度之间的距离
|
||
const double EARTH_RADIUS = 6378.137;
|
||
double rad(double d)
|
||
{
|
||
return d * PI / 180.0;
|
||
}
|
||
|
||
double GetDistance(int32_t lat1, int32_t lng1, int32_t lat2, int32_t lng2)
|
||
{
|
||
double radLat1 = rad(lat1 * 0.000001);
|
||
double radLat2 = rad(lat2 * 0.000001);
|
||
double a = radLat1 - radLat2;
|
||
double b = rad(lng1 * 0.000001) - rad(lng2 * 0.000001);
|
||
double s = 2 * asin(sqrt(pow(sin(a / 2), 2) +
|
||
cos(radLat1) * cos(radLat2) * pow(sin(b / 2), 2)));
|
||
s = s * EARTH_RADIUS;
|
||
return s;
|
||
}
|
||
|
||
// 比较新数据的时间，是否晚于老数据的时间
|
||
int32_t GPS_IsLateThan(bluetooth_timestamp_t *pNewTime, bluetooth_timestamp_t *pOldTime)
|
||
{
|
||
uint8_t newHour = (pNewTime->hour_H << 4) | pNewTime->hour_L;
|
||
uint8_t oldHour = (pOldTime->hour_H << 4) | pOldTime->hour_L;
|
||
|
||
if(pNewTime->year > pOldTime->year)
|
||
return TRUE;
|
||
if(pNewTime->year < pOldTime->year)
|
||
return FALSE;
|
||
if(pNewTime->mon > pOldTime->mon)
|
||
return TRUE;
|
||
if(pNewTime->mon < pOldTime->mon)
|
||
return FALSE;
|
||
if(pNewTime->day > pOldTime->day)
|
||
return TRUE;
|
||
if(pNewTime->day < pOldTime->day)
|
||
return FALSE;
|
||
if(newHour > oldHour)
|
||
return TRUE;
|
||
if(newHour < oldHour)
|
||
return FALSE;
|
||
if(pNewTime->min > pOldTime->min)
|
||
return TRUE;
|
||
if(pNewTime->min < pOldTime->min)
|
||
return FALSE;
|
||
|
||
return pNewTime->sec > pOldTime->sec;
|
||
}
|
||
|
||
// 计算两个时间间隔的秒数
|
||
uint32_t GPS_CalcInterval(bluetooth_timestamp_t *pNewTime, bluetooth_timestamp_t *pOldTime)
|
||
{
|
||
// 计算从OldYear以来的秒数
|
||
uint32_t newSeconds = Calc_SecondsFromYear(GPS_BASE_YEAR + pOldTime->year, pNewTime->year + GPS_BASE_YEAR, pNewTime->mon,
|
||
pNewTime->day, (pNewTime->hour_H << 4) | pNewTime->hour_L, pNewTime->min, pNewTime->sec);
|
||
uint32_t oldSeconds = Calc_SecondsFromYear(GPS_BASE_YEAR + pOldTime->year, pOldTime->year + GPS_BASE_YEAR, pOldTime->mon,
|
||
pOldTime->day, (pOldTime->hour_H << 4) | pOldTime->hour_L, pOldTime->min, pOldTime->sec);
|
||
|
||
return newSeconds - oldSeconds;
|
||
}
|
||
|
||
// 将采集数据中的传感器状态转换为蓝牙协议中的状态
|
||
static uint8_t Bluetooth_ConvertStat(sensor_status_t *pStat)
|
||
{
|
||
if(pStat->notConnect)
|
||
return 3;
|
||
if(pStat->overFlow)
|
||
return 1;
|
||
if(pStat->underFlow)
|
||
return 2;
|
||
return 0;
|
||
}
|
||
|
||
// GPS uart
|
||
void GPS_IRQHandler(USART_Handle *huart)
|
||
{
|
||
uint8_t u8DTU = (uint8_t) huart->Instance->DR;
|
||
|
||
// printf("%c", u8DTU);
|
||
// 直接处理
|
||
DTU_Task0(u8DTU);
|
||
}
|
||
|
||
// GSM uart
|
||
void GPRS_IRQHandler(USART_Handle *huart)
|
||
{
|
||
uint8_t u8DTU = (uint8_t) huart->Instance->DR;
|
||
|
||
if(DTU_uartPrint)
|
||
{
|
||
// if(u8DTU == '\n')
|
||
// printf("\\n\n");
|
||
// else if(u8DTU == '\r')
|
||
// printf("\\r");
|
||
// else
|
||
printf("%c", u8DTU);
|
||
}
|
||
// 加入缓冲
|
||
LoopBuff_PutItem(&DTU_TaskM, &u8DTU);
|
||
}
|
||
|
||
void DTU_Open()
|
||
{
|
||
// 分配扩展内存
|
||
// DTU_gpsData[0] = (char *) SRAM_Alloc(DTU_GPSDATA_SIZE);
|
||
// DTU_gpsData[1] = (char *) SRAM_Alloc(DTU_GPSDATA_SIZE);
|
||
// DTU_recvBuff = (char *) SRAM_Alloc(DTU_RECVBUFF_SIZE);
|
||
// Task_sendBuff = (uint8_t *) SRAM_Alloc(TASK_SENDBUFF_SIZE);
|
||
// Task_recvBuff = (uint8_t *) SRAM_Alloc(TASK_RECVBUFF_SIZE);
|
||
LoopBuff_Create(&DTU_TaskM, sizeof(uint8_t), DTU_TASKM_DATA_COUNT, 0, (uint32_t) DTU_TaskM_Data);
|
||
|
||
// 创建信号量
|
||
DTU_semUpgrade = xSemaphoreCreateBinary();
|
||
|
||
huart1.RxISR = GPRS_IRQHandler;
|
||
huart6.RxISR = GPS_IRQHandler;
|
||
|
||
SET_BIT(USART1->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
|
||
LL_USART_Enable(USART1);
|
||
|
||
/* 打开GPS端口: GPS和Debug共用一个串口，GPS用到输入，DEBUG用到输出 */
|
||
SET_BIT(USART6->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
|
||
}
|
||
|
||
// 任务主体：采集GPS数据
|
||
void DTU_Task0(uint8_t c)
|
||
{
|
||
static uint16_t RdIdx = 0;
|
||
static uint8_t bufIdx = 0;
|
||
static data_dtu_t sample = {0};
|
||
static int32_t last_latitude, last_longitude;
|
||
static uint8_t gps_flag = 0, motion_count = 0, motionless_count = 0;
|
||
static uint32_t last_time = 0;
|
||
static uint32_t last_gpsTime = 0;
|
||
uint32_t time;
|
||
|
||
if(c == '$' || RdIdx >= DTU_GPSDATA_SIZE)
|
||
RdIdx = 0;
|
||
|
||
if(RdIdx == 0 && c != '$')
|
||
return;
|
||
|
||
if(c != '\r' && c != '\n')
|
||
DTU_gpsData[bufIdx][RdIdx++] = c;
|
||
else
|
||
{
|
||
// 收到完整的一行
|
||
DTU_gpsData[bufIdx][RdIdx] = 0;
|
||
RdIdx = 0;
|
||
|
||
// 解析一行数据
|
||
if(parse_frame(&bufIdx, DTU_gpsData[bufIdx], &sample))
|
||
{
|
||
if(sample.sateCount > 0)
|
||
printf("sateCount:\t%d\n", sample.sateCount);
|
||
|
||
if(sample.posState)
|
||
{
|
||
time = Calc_SecondsFromYear(INITIAL_YEAR, sample.sysTime.year + 2000, sample.sysTime.month,
|
||
sample.sysTime.day, sample.sysTime.hour, sample.sysTime.minute, sample.sysTime.second);
|
||
|
||
// 修正时间基准（可显示绝对时间）
|
||
if(RTC_offsetSeconds == 0 && time >= DTU_gpsTime)
|
||
{
|
||
RTC_offsetSeconds = time - DTU_gpsTime;
|
||
// 关联铁电和SFlash的一致性
|
||
CheckFramSFlashValid(DTU_gpsTime);
|
||
}
|
||
// 修正时间基准（可显示绝对时间）
|
||
if(time >= DTU_gpsTime) // 每次成功定位都修正时间
|
||
RTC_offsetSeconds = time - DTU_gpsTime;
|
||
|
||
if(sample.sateCount >= 4)
|
||
{
|
||
if(time >= last_time + dcBuff.configData.intervalGPS)
|
||
{
|
||
last_time = time;
|
||
|
||
// 没有硬件加速度计，用软件方式判断
|
||
if(sample.speed <= 3)
|
||
{
|
||
motion_count = 0;
|
||
if(Motion_Status == 1 && ++motionless_count >= 3)
|
||
{
|
||
Motion_Status = 0;
|
||
printf("\nSoft Motion status = 0\n");
|
||
}
|
||
}
|
||
else
|
||
{
|
||
motionless_count = 0;
|
||
if(Motion_Status == 0 && ++motion_count >= 3)
|
||
{
|
||
Motion_Status = 1;
|
||
printf("\nSoft Motion status = 1\n");
|
||
}
|
||
}
|
||
|
||
printf("Latitude:\t%10.6f\n", sample.latitude * 0.000001);
|
||
printf("Longitude:\t%10.6f\n", sample.longitude * 0.000001);
|
||
printf("Speed:\t\t%d km/h\n", sample.speed);
|
||
printf("GPS time:\t%d-%02d-%02d %02d:%02d:%02d\n",
|
||
sample.sysTime.year + 2000, sample.sysTime.month, sample.sysTime.day,
|
||
sample.sysTime.hour, sample.sysTime.minute, sample.sysTime.second);
|
||
|
||
// 计算和上次定位之间的距离，或者判断运动状态
|
||
if(gps_flag == 1 && (
|
||
!Motion_Status
|
||
// || (sample.speed < 5 && GetDistance(last_latitude, last_longitude, sample.latitude, sample.longitude) < 10)
|
||
))
|
||
{
|
||
printf("\nCalibrate to last position\n");
|
||
sample.latitude = last_latitude;
|
||
sample.longitude = last_longitude;
|
||
}
|
||
else
|
||
{
|
||
gps_flag = 1;
|
||
last_latitude = sample.latitude;
|
||
last_longitude = sample.longitude;
|
||
}
|
||
|
||
// 写入全局缓冲
|
||
dcBuff.dtuData.posState = sample.posState;
|
||
dcBuff.dtuData.sateCount = sample.sateCount;
|
||
dcBuff.dtuData.latitude = sample.latitude;
|
||
dcBuff.dtuData.longitude = sample.longitude;
|
||
dcBuff.dtuData.speed = sample.speed;
|
||
dcBuff.dtuData.sysTime = sample.sysTime;
|
||
|
||
// 每30秒保存一次定位信息，重启有效
|
||
if(time >= last_gpsTime + 30)
|
||
{
|
||
last_gpsTime = time;
|
||
|
||
Ext_GPS.sysTime = dcBuff.dtuData.sysTime;
|
||
Ext_GPS.longitude = dcBuff.dtuData.longitude;
|
||
Ext_GPS.latitude = dcBuff.dtuData.latitude;
|
||
Ext_GPS.speed = dcBuff.dtuData.speed;
|
||
Ext_GPS.sateCount = dcBuff.dtuData.sateCount;
|
||
Ext_GPS.posState = dcBuff.dtuData.posState;
|
||
FRAM_SaveInfo(FRAM_GPS_INFO_BASE, (uint8_t *) &Ext_GPS, sizeof(ext_gps_t));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// 清除数据
|
||
memset(&sample, 0, sizeof(sample));
|
||
}
|
||
}
|
||
}
|
||
|
||
uint8_t pack_gprs_tran_data(ext_data_t *pGprs, uint8_t is4G)
|
||
{
|
||
uint16_t i, j;
|
||
bluetooth_sensor_t *pSensor;
|
||
bluetooth_mask_t *pMask;
|
||
uint16_t crc;
|
||
|
||
rf_app_data_t *pData = (rf_app_data_t *) pGprs->payload;
|
||
static data_sample_t sample;
|
||
|
||
// TODO: 将精简数据转换成上传数据
|
||
cacl_gprs_tran_data(pGprs, &sample);
|
||
|
||
// 打包上报数据（按modbus从机响应的格式）
|
||
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
|
||
i = 0;
|
||
|
||
// PSN
|
||
memmove(Task_sendBuff + i, pGprs->oriPSN, 6);
|
||
i += 6;
|
||
// 功能码
|
||
Task_sendBuff[i++] = 0x10;
|
||
// 数据长度：先预设为0，最后再修改，位置为Task_sendBuff[7]
|
||
Task_sendBuff[i++] = 0;
|
||
|
||
// 当前差压值
|
||
*(uint16_t *) (Task_sendBuff + i) = htons(sample.diff);
|
||
i +=2 ;
|
||
// 容积百分比
|
||
*(uint16_t *) (Task_sendBuff + i) = htons(sample.volumePct);
|
||
i += 2;
|
||
// 当前容积
|
||
*(uint32_t *) (Task_sendBuff + i) = htonl(sample.volume);
|
||
i += 4;
|
||
// 重量
|
||
*(uint32_t *) (Task_sendBuff + i) = htonl(sample.weight);
|
||
i += 4;
|
||
if(pData->Sensor.measure_type == 0) // 差压
|
||
{
|
||
// 高度：mmWC
|
||
*(uint16_t *) (Task_sendBuff + i) = htons((uint16_t) (sample.diff * 101.9716213));
|
||
}
|
||
else if(pData->Sensor.measure_type == 2) // 电容
|
||
{
|
||
// 高度：mm
|
||
*(uint16_t *) (Task_sendBuff + i) = htons((uint16_t) (sample.height));
|
||
}
|
||
i += 2;
|
||
// 压力
|
||
*(uint16_t *) (Task_sendBuff + i) = htons(pData->press);
|
||
i += 2;
|
||
// 温度-调试信息
|
||
*(int16_t *) (Task_sendBuff + i) = htons(is4G ? 3 : 1); // 1-标识为LoRa转发,2-标志为北斗上传，3-标志为4G转发
|
||
i += 2;
|
||
// 液源
|
||
if(pData->Sensor.L_source <= SOURCE_POPO)
|
||
Task_sendBuff[i] = pData->Sensor.L_source;
|
||
i++;
|
||
// 储罐类型
|
||
if(pData->Sensor.bottle_type == BOTTLE_TYPE_STAND)
|
||
Task_sendBuff[i] = 0;
|
||
else if(pData->Sensor.bottle_type == BOTTLE_TYPE_LYING)
|
||
Task_sendBuff[i] = 1;
|
||
else if(pData->Sensor.bottle_type == BOTTLE_TYPE_SPHERICAL)
|
||
Task_sendBuff[i] = 2;
|
||
i++;
|
||
// 故障码
|
||
pSensor = (bluetooth_sensor_t *) (Task_sendBuff + i);
|
||
|
||
pSensor->staDiff = pData->Sensor.staDiff;
|
||
pSensor->staPress = pData->Sensor.staPress;
|
||
pSensor->staEPress1 = 3;
|
||
pSensor->staEPress2 = 3;
|
||
pSensor->staEPress3 = 3;
|
||
pSensor->staETempr1 = pData->Sensor.staETempr1;
|
||
pSensor->staETempr2 = 3;
|
||
pSensor->staETempr3 = 3;
|
||
i += 2;
|
||
// 传感器状态
|
||
pMask = (bluetooth_mask_t *) (Task_sendBuff + i);
|
||
memset(pMask, 0xFF, 2);
|
||
pMask->maskFlow = 0;
|
||
pMask->maskLowPower = pData->Sensor.bat_low;
|
||
pMask->maskAbnormal = 0;
|
||
pMask->maskCharging = pData->Sensor.charging;
|
||
i += 2;
|
||
|
||
// 版本号
|
||
Task_sendBuff[i++] = dcBuff.powerInfo.protocolVer.minor;
|
||
// rssi
|
||
Task_sendBuff[i++] = 0;
|
||
if(pMask->maskGPS)
|
||
{
|
||
// 经度
|
||
*(int32_t *) (Task_sendBuff + i) = htonl(pData->longitude);
|
||
i += 4;
|
||
// 纬度
|
||
*(int32_t *) (Task_sendBuff + i) = htonl(pData->latitude);
|
||
i += 4;
|
||
}
|
||
// 扩展温度
|
||
if(pMask->maskETempr1)
|
||
{
|
||
*(uint16_t *) (Task_sendBuff + i) = htons(pData->tempr);
|
||
i += 2;
|
||
}
|
||
if(pMask->maskETempr2)
|
||
{
|
||
i += 2;
|
||
}
|
||
if(pMask->maskETempr3)
|
||
{
|
||
i += 2;
|
||
}
|
||
|
||
// 电池信息
|
||
if(pMask->maskBattery)
|
||
{
|
||
// 电量百分比
|
||
*(uint16_t *) (Task_sendBuff + i) = htons(pData->batPct);
|
||
i += 2;
|
||
// 电池内部温度
|
||
i += 2;
|
||
// 电池当前电压
|
||
*(int16_t *) (Task_sendBuff + i) = htons(pData->voltage);
|
||
i += 2;
|
||
// 电池容量
|
||
i += 2;
|
||
// 电池当前容量
|
||
i += 2;
|
||
// 充电电流，电流的符号表示充放电状态
|
||
*(int16_t *) (Task_sendBuff + i) = htons(pData->batCurrent);
|
||
i += 2;
|
||
// 光照强度
|
||
i += 2;
|
||
}
|
||
|
||
// 流量计
|
||
if(pMask->maskFlow)
|
||
{
|
||
// 天信MODBUS /A1 通信协议 (BCD码）
|
||
// 标况体积总量
|
||
i += 6;
|
||
// 标况流量
|
||
i += 4;
|
||
// 工况流量
|
||
i += 4;
|
||
// 温度
|
||
i += 4;
|
||
// 压力
|
||
i += 4;
|
||
}
|
||
|
||
// 泄露报警
|
||
if(pMask->maskLeak)
|
||
{
|
||
// 类型
|
||
Task_sendBuff[i++] = LEAK_TYPE_SWITCH | LEAK_TYPE_CURRENT | LEAK_TYPE_MODBUS;
|
||
// 状态、报警浓度
|
||
Task_sendBuff[i++] = 0x80;
|
||
}
|
||
|
||
if(pMask->maskStamp)
|
||
{
|
||
if(dcBuff.powerInfo.protocolVer.minor == 107)
|
||
{
|
||
*(uint32_t *) (Task_sendBuff + i) = htonl(pData->relative_time + (RTC_offsetSeconds + rf_get_seconds() - pGprs->recvTime));
|
||
}
|
||
// 时间
|
||
i += 4;
|
||
// 年月日
|
||
i += 4;
|
||
}
|
||
|
||
// 扩展压力
|
||
if(pMask->maskEPress1)
|
||
{
|
||
i += 2;
|
||
}
|
||
if(pMask->maskEPress2)
|
||
{
|
||
i += 2;
|
||
}
|
||
if(pMask->maskEPress3)
|
||
{
|
||
i += 2;
|
||
}
|
||
|
||
// 硬件版本
|
||
// Task_sendBuff[i++] = ((pData->hardVer / 10) << 4) + pData->hardVer % 10;
|
||
Task_sendBuff[i++] = pData->hardVer;
|
||
// 软件版本
|
||
// Task_sendBuff[i++] = ((pData->softVer / 10) << 4) + pData->softVer % 10;;
|
||
Task_sendBuff[i++] = pData->softVer;
|
||
|
||
// 真空传感器
|
||
for(j = 0; j < 2; j++)
|
||
{
|
||
// 状态
|
||
*(uint16_t *) (Task_sendBuff + i) = htons(0);
|
||
i += 2;
|
||
// 使用年限
|
||
i += 2;
|
||
// 真空度
|
||
i += 4;
|
||
// 漏放气速率
|
||
i += 4;
|
||
}
|
||
|
||
// 气瓶容量
|
||
*(uint32_t *) (Task_sendBuff + i) = htonl(Theoretical_Param.v);
|
||
i += 4;
|
||
// 储罐封头直边长
|
||
*(uint16_t *) (Task_sendBuff + i) = htons(0);
|
||
i += 2;
|
||
// 储罐筒长度
|
||
*(uint32_t *) (Task_sendBuff + i) = htonl(pData->L);
|
||
i += 4;
|
||
// 储罐直径
|
||
*(uint32_t *) (Task_sendBuff + i) = htonl(pData->d);
|
||
i += 4;
|
||
// 自动发送频率
|
||
i += 2;
|
||
// 自动发送短信频率
|
||
i += 2;
|
||
|
||
// 修改数据长度
|
||
Task_sendBuff[7] = i - 8;
|
||
|
||
// 校验码
|
||
crc = MODBUS_RTU_CRC16((uint8_t *) Task_sendBuff, i);
|
||
*(uint16_t *)(Task_sendBuff + i) = htons(crc);
|
||
i += 2;
|
||
// 结束符
|
||
Task_sendBuff[i++] = 0x0d;
|
||
Task_sendBuff[i++] = 0x0a;
|
||
|
||
return i;
|
||
}
|
||
|
||
uint8_t pack_modbus_tran_data(ext_data_t *pGprs)
|
||
{
|
||
uint16_t i, j;
|
||
bluetooth_sensor_t *pSensor;
|
||
bluetooth_mask_t *pMask;
|
||
uint16_t crc;
|
||
|
||
rf_app_data_t *pData = (rf_app_data_t *) pGprs->payload;
|
||
static data_sample_t sample;
|
||
|
||
// TODO: 将精简数据转换成上传数据
|
||
cacl_gprs_tran_data(pGprs, &sample);
|
||
|
||
// 打包上报数据（按modbus从机响应的格式）
|
||
memset(Modbus_sendBuff, 0, TASK_SENDBUFF_SIZE);
|
||
i = 0;
|
||
|
||
// PSN
|
||
memmove(Modbus_sendBuff + i, pGprs->oriPSN, 6);
|
||
i += 6;
|
||
// 功能码
|
||
Modbus_sendBuff[i++] = 0x10;
|
||
// 数据长度：先预设为0，最后再修改，位置为Modbus_sendBuff[7]
|
||
Modbus_sendBuff[i++] = 0;
|
||
|
||
// 当前差压值
|
||
*(uint16_t *) (Modbus_sendBuff + i) = htons(sample.diff);
|
||
i +=2 ;
|
||
// 容积百分比
|
||
*(uint16_t *) (Modbus_sendBuff + i) = htons(sample.volumePct / 100);
|
||
i += 2;
|
||
// 当前容积
|
||
*(uint32_t *) (Modbus_sendBuff + i) = htonl(sample.volume);
|
||
i += 4;
|
||
// 重量
|
||
*(uint32_t *) (Modbus_sendBuff + i) = htonl(sample.weight);
|
||
i += 4;
|
||
if(pData->Sensor.measure_type == 0) // 差压
|
||
{
|
||
// 高度：mmWC
|
||
*(uint16_t *) (Modbus_sendBuff + i) = htons((uint16_t) (sample.diff * 101.9716213));
|
||
}
|
||
else if(pData->Sensor.measure_type == 2) // 电容
|
||
{
|
||
// 高度：mm
|
||
*(uint16_t *) (Modbus_sendBuff + i) = htons((uint16_t) (sample.height));
|
||
}
|
||
i += 2;
|
||
// 压力
|
||
*(uint16_t *) (Modbus_sendBuff + i) = htons(pData->press);
|
||
i += 2;
|
||
// 温度-调试信息
|
||
*(int16_t *) (Modbus_sendBuff + i) = 1; // 1-标识为LoRa转发,2-标志为北斗上传，3-标志为4G转发
|
||
i += 2;
|
||
// 液源
|
||
if(pData->Sensor.L_source <= SOURCE_POPO)
|
||
Modbus_sendBuff[i] = pData->Sensor.L_source;
|
||
i++;
|
||
// 储罐类型
|
||
if(pData->Sensor.bottle_type == BOTTLE_TYPE_STAND)
|
||
Modbus_sendBuff[i] = 0;
|
||
else if(pData->Sensor.bottle_type == BOTTLE_TYPE_LYING)
|
||
Modbus_sendBuff[i] = 1;
|
||
else if(pData->Sensor.bottle_type == BOTTLE_TYPE_SPHERICAL)
|
||
Modbus_sendBuff[i] = 2;
|
||
i++;
|
||
// 故障码
|
||
pSensor = (bluetooth_sensor_t *) (Modbus_sendBuff + i);
|
||
|
||
pSensor->staDiff = pData->Sensor.staDiff;
|
||
pSensor->staPress = pData->Sensor.staPress;
|
||
pSensor->staEPress1 = 3;
|
||
pSensor->staEPress2 = 3;
|
||
pSensor->staEPress3 = 3;
|
||
pSensor->staETempr1 = pData->Sensor.staETempr1;
|
||
pSensor->staETempr2 = 3;
|
||
pSensor->staETempr3 = 3;
|
||
i += 2;
|
||
// 传感器状态
|
||
pMask = (bluetooth_mask_t *) (Modbus_sendBuff + i);
|
||
memset(pMask, 0xFF, 2);
|
||
pMask->maskFlow = 0;
|
||
pMask->maskLowPower = pData->Sensor.bat_low;
|
||
pMask->maskAbnormal = 0;
|
||
pMask->maskCharging = pData->Sensor.charging;
|
||
i += 2;
|
||
|
||
// 版本号
|
||
Modbus_sendBuff[i++] = dcBuff.powerInfo.protocolVer.minor;
|
||
// rssi
|
||
Modbus_sendBuff[i++] = 0;
|
||
if(pMask->maskGPS)
|
||
{
|
||
// 经度
|
||
*(int32_t *) (Modbus_sendBuff + i) = htonl(pData->longitude);
|
||
i += 4;
|
||
// 纬度
|
||
*(int32_t *) (Modbus_sendBuff + i) = htonl(pData->latitude);
|
||
i += 4;
|
||
}
|
||
// 扩展温度
|
||
if(pMask->maskETempr1)
|
||
{
|
||
*(uint16_t *) (Modbus_sendBuff + i) = htons(pData->tempr);
|
||
i += 2;
|
||
}
|
||
if(pMask->maskETempr2)
|
||
{
|
||
i += 2;
|
||
}
|
||
if(pMask->maskETempr3)
|
||
{
|
||
i += 2;
|
||
}
|
||
|
||
// 电池信息
|
||
if(pMask->maskBattery)
|
||
{
|
||
// 电量百分比
|
||
*(uint16_t *) (Modbus_sendBuff + i) = htons(pData->batPct);
|
||
i += 2;
|
||
// 电池内部温度
|
||
i += 2;
|
||
// 电池当前电压
|
||
*(int16_t *) (Modbus_sendBuff + i) = htons(pData->voltage);
|
||
i += 2;
|
||
// 电池容量
|
||
i += 2;
|
||
// 电池当前容量
|
||
i += 2;
|
||
// 充电电流，电流的符号表示充放电状态
|
||
*(int16_t *) (Modbus_sendBuff + i) = htons(pData->batCurrent);
|
||
i += 2;
|
||
// 光照强度
|
||
i += 2;
|
||
}
|
||
|
||
// 流量计
|
||
if(pMask->maskFlow)
|
||
{
|
||
// 天信MODBUS /A1 通信协议 (BCD码）
|
||
// 标况体积总量
|
||
i += 6;
|
||
// 标况流量
|
||
i += 4;
|
||
// 工况流量
|
||
i += 4;
|
||
// 温度
|
||
i += 4;
|
||
// 压力
|
||
i += 4;
|
||
}
|
||
|
||
// 泄露报警
|
||
if(pMask->maskLeak)
|
||
{
|
||
// 类型
|
||
Modbus_sendBuff[i++] = LEAK_TYPE_SWITCH | LEAK_TYPE_CURRENT | LEAK_TYPE_MODBUS;
|
||
// 状态、报警浓度
|
||
Modbus_sendBuff[i++] = 0x80;
|
||
}
|
||
|
||
if(pMask->maskStamp)
|
||
{
|
||
if(dcBuff.powerInfo.protocolVer.minor == 107)
|
||
{
|
||
*(uint32_t *) (Modbus_sendBuff + i) = htonl(pData->relative_time + (RTC_offsetSeconds + rf_get_seconds() - pGprs->recvTime));
|
||
}
|
||
// 时间
|
||
i += 4;
|
||
// 年月日
|
||
i += 4;
|
||
}
|
||
|
||
// 扩展压力
|
||
if(pMask->maskEPress1)
|
||
{
|
||
i += 2;
|
||
}
|
||
if(pMask->maskEPress2)
|
||
{
|
||
i += 2;
|
||
}
|
||
if(pMask->maskEPress3)
|
||
{
|
||
i += 2;
|
||
}
|
||
|
||
// 硬件版本
|
||
// Modbus_sendBuff[i++] = ((pData->hardVer / 10) << 4) + pData->hardVer % 10;
|
||
Modbus_sendBuff[i++] = pData->hardVer;
|
||
// 软件版本
|
||
// Modbus_sendBuff[i++] = ((pData->softVer / 10) << 4) + pData->softVer % 10;;
|
||
Modbus_sendBuff[i++] = pData->softVer;
|
||
|
||
// 真空传感器
|
||
for(j = 0; j < 2; j++)
|
||
{
|
||
// 状态
|
||
*(uint16_t *) (Modbus_sendBuff + i) = htons(0);
|
||
i += 2;
|
||
// 使用年限
|
||
i += 2;
|
||
// 真空度
|
||
i += 4;
|
||
// 漏放气速率
|
||
i += 4;
|
||
}
|
||
|
||
// 气瓶容量
|
||
*(uint32_t *) (Modbus_sendBuff + i) = htonl(Theoretical_Param.v);
|
||
i += 4;
|
||
// 储罐封头直边长
|
||
*(uint16_t *) (Modbus_sendBuff + i) = htons(0);
|
||
i += 2;
|
||
// 储罐筒长度
|
||
*(uint32_t *) (Modbus_sendBuff + i) = htonl(pData->L);
|
||
i += 4;
|
||
// 储罐直径
|
||
*(uint32_t *) (Modbus_sendBuff + i) = htonl(pData->d);
|
||
i += 4;
|
||
// 自动发送频率
|
||
i += 2;
|
||
// 自动发送短信频率
|
||
i += 2;
|
||
|
||
// 修改数据长度
|
||
Modbus_sendBuff[7] = i - 8;
|
||
|
||
// 校验码
|
||
crc = MODBUS_RTU_CRC16((uint8_t *) Modbus_sendBuff, i);
|
||
*(uint16_t *)(Modbus_sendBuff + i) = htons(crc);
|
||
i += 2;
|
||
// 结束符
|
||
Modbus_sendBuff[i++] = 0x0d;
|
||
Modbus_sendBuff[i++] = 0x0a;
|
||
|
||
return i;
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////////////////////////////////
|
||
// 填写双向通讯的固定字段
|
||
uint16_t fill_biDir_fixFields(uint16_t cmd, uint16_t len)
|
||
{
|
||
bluetooth_send_t *pSend = (bluetooth_send_t *) Task_sendBuff;
|
||
uint16_t crc;
|
||
|
||
pSend->mark = CONFIG_MARK_LS;
|
||
pSend->ver = htons(dcBuff.powerInfo.protocolVer.major);
|
||
pSend->trans = 0;
|
||
pSend->len = htons(len - sizeof(bluetooth_send_t) + 2);
|
||
pSend->cmd = htons(cmd);
|
||
crc = MODBUS_RTU_CRC16((uint8_t *) Task_sendBuff, len);
|
||
Int2ByteS(Task_sendBuff, len, htons(crc));
|
||
|
||
return len + 2;
|
||
}
|
||
|
||
uint16_t pack_ldms_info_data(uint32_t dataTime, uint32_t totalSeconds)
|
||
{
|
||
uint16_t i = 0;
|
||
S_RTC_TIME_DATA_T sRTC;
|
||
bluetooth_timestamp_t t;
|
||
|
||
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
|
||
|
||
// 头信息（最后再填内容）
|
||
i += sizeof(bluetooth_send_t);
|
||
// PSN
|
||
memmove(Task_sendBuff + i, dcBuff.configBottle.PSN, 6);
|
||
i += 6;
|
||
Task_sendBuff[i++] = dcBuff.powerInfo.hardVer.major;
|
||
Task_sendBuff[i++] = dcBuff.powerInfo.hardVer.minor;
|
||
Task_sendBuff[i++] = dcBuff.powerInfo.softVer.major;
|
||
Task_sendBuff[i++] = dcBuff.powerInfo.softVer.minor;
|
||
// 软件日期：yyyymmdd
|
||
Int2ByteL(Task_sendBuff, i, htonl((2000 + dcBuff.powerInfo.softDate.year) * 10000 + dcBuff.powerInfo.softDate.month * 100 + dcBuff.powerInfo.softDate.day));
|
||
i += 4;
|
||
// Report format
|
||
Task_sendBuff[i++] = dcBuff.powerInfo.protocolVer.major;
|
||
Task_sendBuff[i++] = dcBuff.powerInfo.protocolVer.minor;
|
||
// Config format
|
||
Task_sendBuff[i++] = dcBuff.configBottle.header.ver.major;
|
||
Task_sendBuff[i++] = dcBuff.configBottle.header.ver.minor;
|
||
|
||
// 运行时间：分钟
|
||
Int2ByteL(Task_sendBuff, i, htonl(totalSeconds / 60));
|
||
i += 4;
|
||
Int2ByteS(Task_sendBuff, i, htons(SYS_RSTSTS));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.dtuData.batCurrent));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.dtuData.batVoltage / 10));
|
||
i += 2;
|
||
Task_sendBuff[i++] = dcBuff.dtuData.batPct;
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.dtuData.batCapa));
|
||
i += 4;
|
||
Task_sendBuff[i] = 0;
|
||
i++;
|
||
if(dcBuff.dtuData.posState)
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.dtuData.latitude));
|
||
i += 4;
|
||
if(dcBuff.dtuData.posState)
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.dtuData.longitude));
|
||
i += 4;
|
||
|
||
// 定位时间
|
||
if(dcBuff.dtuData.posState && dcBuff.dtuData.sysTime.year)
|
||
{
|
||
t.year = dcBuff.dtuData.sysTime.year + 2000 - 2010;
|
||
t.mon = dcBuff.dtuData.sysTime.month;
|
||
t.day = dcBuff.dtuData.sysTime.day;
|
||
t.hour_H = dcBuff.dtuData.sysTime.hour >> 4;
|
||
t.hour_L = dcBuff.dtuData.sysTime.hour & 0x0F;
|
||
t.min = dcBuff.dtuData.sysTime.minute;
|
||
t.sec = dcBuff.dtuData.sysTime.second;
|
||
Int2ByteL(Task_sendBuff, i, htonl(t.tm));
|
||
}
|
||
i += 4;
|
||
// 卫星数量
|
||
Task_sendBuff[i++] = dcBuff.dtuData.sateCount;
|
||
// 数据时间
|
||
Wakeup_CalcUTCTime(dataTime + RTC_offsetSeconds, &sRTC);
|
||
t.year = sRTC.u32Year - 2010;
|
||
t.mon = sRTC.u32Month;
|
||
t.day = sRTC.u32Day;
|
||
t.hour_H = sRTC.u32Hour >> 4;
|
||
t.hour_L = sRTC.u32Hour & 0x0F;
|
||
t.min = sRTC.u32Minute;
|
||
t.sec = sRTC.u32Second;
|
||
Int2ByteL(Task_sendBuff, i, htonl(t.tm));
|
||
i += 4;
|
||
// 信号强度
|
||
Task_sendBuff[i++] = dcBuff.dtuData.rssi;
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.powerInfo.gprsSuccCount));
|
||
i += 4;
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.powerInfo.gprsSendCount - dcBuff.powerInfo.gprsSuccCount));
|
||
i += 4;
|
||
if(dcBuff.powerInfo.gprsSendCount > 0)
|
||
Task_sendBuff[i] = dcBuff.powerInfo.gprsSuccCount * 100 / dcBuff.powerInfo.gprsSendCount;
|
||
i++;
|
||
memmove(Task_sendBuff + i, dcBuff.powerInfo.gprsFailCode, strlen(dcBuff.powerInfo.gprsFailCode));
|
||
i += 6;
|
||
memmove(Task_sendBuff + i, dcBuff.powerInfo.simNumber, strlen(dcBuff.powerInfo.simNumber));
|
||
i += 24;
|
||
// Int2ByteL(Task_sendBuff, i, htonl(dcBuff.powerInfo.bdNumber));
|
||
i += 4;
|
||
|
||
// 储罐类型
|
||
Task_sendBuff[i++] = dcBuff.configBottle.type;
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.diameter));
|
||
i += 4;
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.len));
|
||
i += 4;
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.lenExtra));
|
||
i += 4;
|
||
Int2ByteL(Task_sendBuff, i, htonl(Theoretical_Param.v));
|
||
i += 4;
|
||
Task_sendBuff[i++] = dcBuff.configBottle.chargePct;
|
||
Task_sendBuff[i++] = dcBuff.configBottle.source;
|
||
// Int2ByteS(Task_sendBuff, i, htons(Config_GetDensity(dcBuff.configBottle.source) * 1000));
|
||
i += 2;
|
||
Task_sendBuff[i++] = dcBuff.configBottle.dispMode;
|
||
// if(dcBuff.configDisplay.L_Unit == UNIT_KPA)
|
||
// Task_sendBuff[i] = 0;
|
||
// else if(dcBuff.configDisplay.L_Unit == UNIT_KG)
|
||
// Task_sendBuff[i] = 1;
|
||
// else if(dcBuff.configDisplay.L_Unit == UNIT_L)
|
||
// Task_sendBuff[i] = 2;
|
||
// else if(dcBuff.configDisplay.L_Unit == UNIT_MMH2O)
|
||
// Task_sendBuff[i] = 4;
|
||
// else
|
||
// Task_sendBuff[i] = 3;
|
||
i++;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.serverVer));
|
||
i += 2;
|
||
memmove(Task_sendBuff + i, dcBuff.configData.server, strlen(dcBuff.configData.server));
|
||
i += 26;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configData.port));
|
||
i += 2;
|
||
memmove(Task_sendBuff + i, dcBuff.configData.gpsServer, strlen(dcBuff.configData.gpsServer));
|
||
i += 26;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configData.gpsPort));
|
||
i += 2;
|
||
memmove(Task_sendBuff + i, dcBuff.configData.upgServer, strlen(dcBuff.configData.upgServer));
|
||
i += 26;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configData.upgPort));
|
||
i += 2;
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configData.intervalTrans));
|
||
i += 4;
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configData.intervalSample));
|
||
i += 4;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configData.intervalGPSTrans));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configData.intervalGPS));
|
||
i += 2;
|
||
Task_sendBuff[i++] = dcBuff.configData.timeLag;
|
||
strcpy((char *) Task_sendBuff + i, DTU_DecideAPN());
|
||
i += 20;
|
||
// Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configDisplay.bdCommander));
|
||
i += 4;
|
||
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnPress));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnPressH));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.fullPct));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.priPct));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.orderPct));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.emptyPct));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnVolt));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnVoltH));
|
||
i += 2;
|
||
//Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.planMount));
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.offlineSeconds));
|
||
i += 4;
|
||
//Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.predictMount));
|
||
i += 4;
|
||
//Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.floorLevel));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnTempr)); // span
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnTemprH)); // spanPeriod
|
||
i += 2;
|
||
|
||
// 测量方式
|
||
// Task_sendBuff[i] = dcBuff.configDisplay.op_USE_CAPACITY_SENSOR ? 2 : dcBuff.configBottle.measureType;
|
||
i++;
|
||
// Task_sendBuff[i] = 0;
|
||
i++;
|
||
// Task_sendBuff[i] = dcBuff.configDisplay.op_USE_PT100_SENSOR ? 0 : 1;
|
||
i++;
|
||
|
||
// 差压传感器参数
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorDPress.lowRange));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorDPress.highRange));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorDPress.zeroValue));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorDPress.fullValue));
|
||
i += 2;
|
||
// 电容传感器参数
|
||
// Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorCap.baseC));
|
||
i += 2;
|
||
// Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorCap.refC));
|
||
i += 2;
|
||
// Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorCap.c1ADC));
|
||
i += 2;
|
||
// Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorCap.c2ADC));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(CAP_K_C1));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(CAP_K_C2));
|
||
i += 2;
|
||
// 称重传感器参数
|
||
// Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configSensor.sensorWeight.lowRange));
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.sampleData.adDPress));
|
||
i += 4;
|
||
// Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configSensor.sensorWeight.highRange));
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.sampleData.adPress));
|
||
i += 4;
|
||
// Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configSensor.sensorWeight.zeroValue));
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.sampleData.adExtTempr[0]));
|
||
i += 4;
|
||
// Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configSensor.sensorWeight.fullValue));
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.sampleData.adExtTempr[1]));
|
||
i += 4;
|
||
// 压力传感器参数
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorPress.lowRange));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorPress.highRange));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorPress.zeroValue));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorPress.fullValue));
|
||
i += 2;
|
||
// 扩展压力传感器1参数
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorEPress[0].lowRange));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorEPress[0].highRange));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorEPress[0].zeroValue));
|
||
i += 2;
|
||
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorEPress[0].fullValue));
|
||
i += 2;
|
||
// 扩展温度传感器1参数
|
||
// Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorPTempr[0].calibrateT));
|
||
i += 2;
|
||
// Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorPTempr[0].calibrateR));
|
||
i += 2;
|
||
// Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorPTempr[0].zeroValue));
|
||
i += 2;
|
||
// Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorPTempr[0].fullValue));
|
||
i += 2;
|
||
// 扩展温度传感器2参数
|
||
// Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorPTempr[1].calibrateT));
|
||
i += 2;
|
||
// Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorPTempr[1].calibrateR));
|
||
i += 2;
|
||
// Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorPTempr[1].zeroValue));
|
||
i += 2;
|
||
// Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorPTempr[1].fullValue));
|
||
i += 2;
|
||
|
||
// 填写固定字段
|
||
return fill_biDir_fixFields(0xD035, i);
|
||
}
|
||
|
||
#define D036_PARAM_SIZE (240)
|
||
uint8_t parse_param_D036_data(uint8_t *param, uint8_t *reset)
|
||
{
|
||
longlong_mask_t mask;
|
||
uint16_t i = 0, shift = 0;
|
||
|
||
// 参数有效标志位（用一个无符号长整数表示, 共63项可选配置（bit 0~62）, 最高位（bit 63）代表复位命令）
|
||
// 网络字节序： 12 34 56 78 90 ab cd ef
|
||
// h = 0x78563412, l = 0xefcdab90 （网络字节序）
|
||
// h = 0x12345678, l = 0x90abcdef （本机字节序)
|
||
// mask = 0x1234567890abcdef
|
||
mask.h = ntohl(Byte2IntL(param, i));
|
||
i += 4;
|
||
mask.l = ntohl(Byte2IntL(param, i));
|
||
i += 4;
|
||
|
||
printf("\nmask = %016llX\n", mask.ll);
|
||
|
||
// 储罐类型
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.type = param[i];
|
||
i++;
|
||
// 直径
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.diameter = ntohl(Byte2IntL(param, i));
|
||
i += 4;
|
||
// 长度
|
||
if(mask.ll & (1ull << (shift++)))
|
||
{
|
||
dcBuff.configBottle.len = ntohl(Byte2IntL(param, i));
|
||
dcBuff.configBottle.lenExtra = 0;
|
||
}
|
||
i += 4;
|
||
// 充装比
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.chargePct = param[i];
|
||
i++;
|
||
// 介质
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.source = param[i];
|
||
i++;
|
||
// 密度
|
||
if(mask.ll & (1ull << (shift++)))
|
||
;//Config_SetDensity(dcBuff.configBottle.source, ntohs(Byte2IntS(param, i)) / 1000.0);
|
||
i += 2;
|
||
// 显示模式
|
||
if(mask.ll & (1ull << (shift++)))
|
||
{
|
||
dcBuff.configBottle.dispMode = param[i];
|
||
|
||
dcBuff.configBottle.options &= ~0x0003ul;
|
||
if(dcBuff.configBottle.dispMode == DISP_MODE_ALL)
|
||
dcBuff.configBottle.options |= 0x0003ul;
|
||
else if(dcBuff.configBottle.dispMode == DISP_MODE_L)
|
||
dcBuff.configBottle.options |= 0x0001ul;
|
||
else if(dcBuff.configBottle.dispMode == DISP_MODE_KG)
|
||
dcBuff.configBottle.options |= 0x0002ul;
|
||
}
|
||
i++;
|
||
// 显示单位
|
||
if(mask.ll & (1ull << (shift++)))
|
||
{
|
||
if(param[i] == 0)
|
||
dcBuff.configDisplay.L_Unit = UNIT_KPA;
|
||
else if(param[i] == 1)
|
||
dcBuff.configDisplay.L_Unit = UNIT_KG;
|
||
else if(param[i] == 2)
|
||
dcBuff.configDisplay.L_Unit = UNIT_L;
|
||
else if(param[i] == 4)
|
||
dcBuff.configDisplay.L_Unit = UNIT_MMH2O;
|
||
else
|
||
dcBuff.configDisplay.L_Unit = UNIT_PCT;
|
||
}
|
||
i++;
|
||
|
||
// 服务器版本
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.serverVer = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 远传服务器
|
||
if(mask.ll & (1ull << (shift++)))
|
||
strcpy(dcBuff.configData.server, (char *) param + i);
|
||
i += 26;
|
||
// 远传端口
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configData.port = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 远传服务器
|
||
if(mask.ll & (1ull << (shift++)))
|
||
strcpy(dcBuff.configData.gpsServer, (char *) param + i);
|
||
i += 26;
|
||
// 远传端口
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configData.gpsPort = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 远传服务器
|
||
if(mask.ll & (1ull << (shift++)))
|
||
strcpy(dcBuff.configData.upgServer, (char *) param + i);
|
||
i += 26;
|
||
// 远传端口
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configData.upgPort = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 发送频率
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configData.intervalTrans = ntohl(Byte2IntL(param, i));
|
||
i += 4;
|
||
// 采集频率
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configData.intervalSample = ntohl(Byte2IntL(param, i));
|
||
i += 4;
|
||
// 发送频率
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configData.intervalGPSTrans = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 采集频率
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configData.intervalGPS = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 时差
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configData.timeLag = param[i];
|
||
i++;
|
||
// APN
|
||
if(mask.ll & (1ull << (shift++)))
|
||
strcpy(dcBuff.configDisplay.APN, (char *) param + i);
|
||
i += 20;
|
||
// 北斗指挥机卡号
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configDisplay.bdCommander = ntohl(Byte2IntL(param, i));
|
||
i += 4;
|
||
|
||
// 压力报警点低: KPa
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.warnPress = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 压力报警点高: KPa
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.warnPressH = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 满液位报警点: 0.01%
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.fullPct = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 关键液位报警点: 0.01%
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.priPct = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 订货液位报警点: 0.01%
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.orderPct = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 空液位报警点: 0.01%
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.emptyPct = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 电压报警低点: mV
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.warnVolt = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 电压报警高点: mV
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.warnVoltH = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 每日计划用量: L
|
||
if(mask.ll & (1ull << (shift++)))
|
||
{
|
||
//dcBuff.configBottle.planMount = ntohl(Byte2IntL(param, i));
|
||
dcBuff.configBottle.offlineSeconds = ntohl(Byte2IntL(param, i));
|
||
}
|
||
i += 4;
|
||
// 每日预测用量: L
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; // dcBuff.configBottle.predictMount = ntohl(Byte2IntL(param, i));
|
||
i += 4;
|
||
// TTS-空液位报警点: 0.01%
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configBottle.floorLevel = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// TTS-变化量报警点: 0.01%
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.warnTempr = ntohs(Byte2IntS(param, i)); // span
|
||
i += 2;
|
||
// TTS-变化量检测时间: 秒
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configBottle.warnTemprH = ntohs(Byte2IntS(param, i)); // spanPeriod
|
||
i += 2;
|
||
|
||
// 差压传感器量程: 低
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorDPress.lowRange = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 差压传感器量程: 高
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorDPress.highRange = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 差压传感器标定: 低
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorDPress.zeroValue = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 差压传感器标定: 高
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorDPress.fullValue = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 电容传感器量程: 底电容
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configSensor.sensorCap.baseC = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 电容传感器量程: 增长电容
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configSensor.sensorCap.refC = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 电容传感器标定: C1ADC
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configSensor.sensorCap.c1ADC = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 电容传感器标定: C2ADC
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configSensor.sensorCap.c2ADC = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 称重传感器量程: 低
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorWeight.lowRange = ntohl(Byte2IntL(param, i));
|
||
i += 4;
|
||
// 称重传感器量程: 高
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorWeight.highRange = ntohl(Byte2IntL(param, i));
|
||
i += 4;
|
||
// 称重传感器标定: 低
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorWeight.zeroValue = ntohl(Byte2IntL(param, i));
|
||
i += 4;
|
||
// 称重传感器标定: 高
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorWeight.fullValue = ntohl(Byte2IntL(param, i));
|
||
i += 4;
|
||
// 压力传感器1量程: 低
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorPress.lowRange = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 压力传感器1量程: 高
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorPress.highRange = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 压力传感器1标定: 低
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorPress.zeroValue = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 压力传感器1标定: 高
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorPress.fullValue = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 压力传感器2量程: 低
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorEPress[0].lowRange = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 压力传感器2量程: 高
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorEPress[0].highRange = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 压力传感器2标定: 低
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorEPress[0].zeroValue = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 压力传感器2标定: 高
|
||
if(mask.ll & (1ull << (shift++)))
|
||
dcBuff.configSensor.sensorEPress[0].fullValue = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 温度传感器1量程: 低
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configSensor.sensorPTempr[0].calibrateT = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 温度传感器1量程: 高
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configSensor.sensorPTempr[0].calibrateR = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 温度传感器1标定: 低
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configSensor.sensorPTempr[0].zeroValue = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 温度传感器1标定: 高
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configSensor.sensorPTempr[0].fullValue = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 温度传感器2量程: 低
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configSensor.sensorPTempr[1].calibrateT = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 温度传感器2量程: 高
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configSensor.sensorPTempr[1].calibrateR = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 温度传感器2标定: 低
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configSensor.sensorPTempr[1].zeroValue = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 温度传感器2标定: 高
|
||
if(mask.ll & (1ull << (shift++)))
|
||
; //dcBuff.configSensor.sensorPTempr[1].fullValue = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
|
||
*reset = ((mask.ll & (1ull << shift)) != 0);
|
||
|
||
return ((mask.ll & ~(1ull << shift)) != 0);
|
||
}
|
||
|
||
#define D038_CONFIG_SIZE (74)
|
||
uint8_t parse_config_D038_data(uint8_t *param)
|
||
{
|
||
uint16_t i = 0;
|
||
|
||
// 服务器版本
|
||
dcBuff.configBottle.serverVer = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 远传服务器
|
||
strcpy(dcBuff.configData.server, (char *) param + i);
|
||
i += 26;
|
||
// 远传端口
|
||
dcBuff.configData.port = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 远传服务器
|
||
strcpy(dcBuff.configData.gpsServer, (char *) param + i);
|
||
i += 26;
|
||
// 远传端口
|
||
dcBuff.configData.gpsPort = ntohs(Byte2IntS(param, i));
|
||
i += 2;
|
||
// 发送频率
|
||
dcBuff.configData.intervalTrans = ntohl(Byte2IntL(param, i));
|
||
i += 4;
|
||
// 采集频率
|
||
dcBuff.configData.intervalSample = ntohl(Byte2IntL(param, i));
|
||
i += 4;
|
||
|
||
// 硬件版本
|
||
// dcBuff.configDisplay.op_HARDWARE_VER_MAJOR = param[i];
|
||
i++;
|
||
// 只显示毫米水柱
|
||
// dcBuff.configDisplay.op_DISP_MMWC_ONLY = param[i];
|
||
i++;
|
||
// 罐箱版本
|
||
// dcBuff.configDisplay.op_BOX_VER = param[i];
|
||
i++;
|
||
// 基站定位
|
||
// dcBuff.configDisplay.op_CELL_LOCATION = param[i];
|
||
i++;
|
||
// 发送轨迹
|
||
// dcBuff.configDisplay.op_SEND_GPS_DATA = param[i];
|
||
i++;
|
||
// 通信方式
|
||
// dcBuff.configDisplay.op_SERVER_PROTOCOL = param[i];
|
||
i++;
|
||
// URL索引
|
||
// dcBuff.configDisplay.op_SERVER_INDEX = param[i];
|
||
i++;
|
||
// 单向通信
|
||
// dcBuff.configDisplay.op_UNIDIR_COMM = param[i];
|
||
i++;
|
||
|
||
return 1;
|
||
}
|
||
|
||
// 从服务器获取时间
|
||
void DTU_setOffsetSecondsFromServer()
|
||
{
|
||
bluetooth_send_t *pRecv = (bluetooth_send_t *) Task_recvBuff;
|
||
S_RTC_TIME_DATA_T sRTC;
|
||
uint32_t totalSeconds1, totalSeconds2;
|
||
int16_t zz;
|
||
uint16_t i, recvLen;
|
||
|
||
// 从服务器获取当前时间
|
||
printf("\nGet time from server ...\n");
|
||
// 连接升级服务器
|
||
if(DTU_Connect(0, dcBuff.configData.upgServer, dcBuff.configData.upgPort))
|
||
{
|
||
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
|
||
|
||
i = sizeof(bluetooth_send_t);
|
||
// 填写固定字段
|
||
i = fill_biDir_fixFields(0xD03B, i);
|
||
|
||
// 发送i个字节到服务器，至少接收10个字节
|
||
recvLen = sizeof(bluetooth_recv_t) + 2;
|
||
if(DTU_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
|
||
{
|
||
if(recvLen >= sizeof(bluetooth_recv_t) + 2
|
||
&& MODBUS_RTU_CRC16(Task_recvBuff, recvLen) == 0)
|
||
{
|
||
if(recvLen >= sizeof(bluetooth_recv_t) + 11
|
||
&& pRecv->cmd == ntohs(0x003B)
|
||
&& MODBUS_RTU_CRC16(Task_recvBuff, sizeof(bluetooth_recv_t) + 11) == 0)
|
||
{
|
||
// 获取当前时间
|
||
RTC_GetDateAndTime(&sRTC);
|
||
totalSeconds1 = Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
|
||
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);
|
||
|
||
// UTC日期
|
||
i = sizeof(bluetooth_recv_t);
|
||
|
||
// 年
|
||
sRTC.u32Year = ntohs(Byte2IntS(Task_recvBuff, i));
|
||
i += 2;
|
||
// 月
|
||
sRTC.u32Month = Task_recvBuff[i++];
|
||
// 日
|
||
sRTC.u32Day = Task_recvBuff[i++];
|
||
// 时
|
||
sRTC.u32Hour = Task_recvBuff[i++];
|
||
// 分
|
||
sRTC.u32Minute = Task_recvBuff[i++];
|
||
// 秒
|
||
sRTC.u32Second = Task_recvBuff[i++];
|
||
// 时差（按1/4小时, 带符号）
|
||
recvLen = ntohs(Byte2IntS(Task_recvBuff, i));
|
||
memmove(&zz, &recvLen, 2);
|
||
|
||
printf("\n%04d-%02d-%02d %02d:%02d:%02d %d\n", sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
|
||
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second, zz);
|
||
|
||
totalSeconds2 = Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
|
||
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);
|
||
|
||
// 将UTC时间转换为GMT时间（时差为0）
|
||
totalSeconds2 -= zz * 900;
|
||
// 将GMT时间转换为UTC时间（按配置的时差）
|
||
totalSeconds2 += dcBuff.configData.timeLag * 3600;
|
||
|
||
if(RTC_offsetSeconds == 0)
|
||
{
|
||
RTC_offsetSeconds = totalSeconds2 - totalSeconds1;
|
||
// 关联铁电和SFlash的一致性
|
||
CheckFramSFlashValid(totalSeconds1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
}
|
||
}
|
||
////////////////////////////////////////////////////////////////////////////////////////
|
||
// 任务主体：发送运行数据和GPS数据，读取网络信号强度等
|
||
void DTU_Task(void *p_arg)
|
||
{
|
||
bluetooth_send_t *pSend = (bluetooth_send_t *) Task_sendBuff;
|
||
bluetooth_send_t *pRecv = (bluetooth_send_t *) Task_recvBuff;
|
||
uint16_t i, j, k;
|
||
uint32_t totalSeconds;
|
||
S_RTC_TIME_DATA_T sRTC;
|
||
uint8_t try_count;
|
||
uint16_t recvLen;
|
||
uint8_t upgrade;
|
||
uint8_t ackUpgrade;
|
||
uint8_t downloadParam;
|
||
uint8_t ackParam;
|
||
uint8_t downloadOptions;
|
||
uint8_t ackOptions;
|
||
uint8_t downloadBoxes;
|
||
uint8_t ackBoxes;
|
||
uint8_t downloadConfig;
|
||
uint8_t ackConfig;
|
||
uint8_t reset = 0;
|
||
TUpgradeHeader upHeader;
|
||
upgrade_frame_t *pFrame;
|
||
int32_t nextPtr;
|
||
uint8_t write_count;
|
||
|
||
uint32_t rssiTick = 0;
|
||
uint8_t tranLocked = 0;
|
||
|
||
// 清除数据
|
||
memset(&dcBuff.dtuData, 0, sizeof(dcBuff.dtuData));
|
||
|
||
// 从铁电读取最近一次GPS定位信息，并检查是否合法
|
||
if(FRAM_LoadInfo(FRAM_GPS_INFO_BASE, (uint8_t *) &Ext_GPS, sizeof(ext_gps_t)))
|
||
{
|
||
dcBuff.dtuData.sysTime = Ext_GPS.sysTime;
|
||
dcBuff.dtuData.longitude = Ext_GPS.longitude;
|
||
dcBuff.dtuData.latitude = Ext_GPS.latitude;
|
||
dcBuff.dtuData.speed = Ext_GPS.speed;
|
||
dcBuff.dtuData.sateCount = Ext_GPS.sateCount;
|
||
dcBuff.dtuData.posState = Ext_GPS.posState;
|
||
}
|
||
|
||
// 触发固件升级任务：开机执行一次
|
||
xSemaphoreGive(DTU_semUpgrade);
|
||
|
||
while(1)
|
||
{
|
||
// 获取当前时间
|
||
RTC_GetDateAndTime(&sRTC);
|
||
// 计算自上次gps定位以来的时间
|
||
totalSeconds = Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
|
||
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);
|
||
// 刚开始运行的时候，回退到刚启动的时间（忽略系统初始化时间）
|
||
if(totalSeconds < 10)
|
||
totalSeconds = 0;
|
||
|
||
// 每30秒刷新一下4G信号
|
||
if(IsTickOut(rssiTick))
|
||
{
|
||
rssiTick = GetDelayTick(30000);
|
||
|
||
DTU_PowerOn();
|
||
// 采集信号强度和注册信息
|
||
Sim808_ReadGPRS();
|
||
|
||
// GPRS拨号和GPS定位同时进行，以节省时间
|
||
if(dcBuff.dtuData.networked)
|
||
Sim808_GPRSDial();
|
||
}
|
||
|
||
// 连接成功，对发送加锁
|
||
if(!dcBuff.dtuData.connected && Sim808_Connect(0, dcBuff.configData.server, dcBuff.configData.port) && !tranLocked)
|
||
{
|
||
xSemaphoreTake(RF_TranLock, portMAX_DELAY);
|
||
tranLocked = 1;
|
||
}
|
||
|
||
if(!dcBuff.dtuData.connected && tranLocked)
|
||
{
|
||
// 4G连接失败，释放锁让网口有机会发送
|
||
xSemaphoreGive(RF_TranLock);
|
||
tranLocked = 0;
|
||
}
|
||
|
||
// 掉电有效，如果未获取到UTC时间，不转发
|
||
if(RTC_offsetSeconds > 0 && dcBuff.dtuData.connected && LoopBuff_GetCount(&RF_TranM) > 0)
|
||
{
|
||
nextPtr = RF_TranM.info.rdPtr;
|
||
for(k = 0; k < LoopBuff_GetCount(&RF_TranM); k++)
|
||
{
|
||
dcBuff.powerInfo.gprsSendCount++;
|
||
|
||
if(!SFlash_LoadInfo(LoopBuff_GetDataPos(&RF_TranM, nextPtr), (uint8_t *) &Ext_Data_Rec1, sizeof(ext_data_t)))
|
||
{
|
||
nextPtr = LoopBuff_GetNextPtr(&RF_TranM, nextPtr);
|
||
continue; // 不发送，算失败1次
|
||
}
|
||
|
||
nextPtr = LoopBuff_GetNextPtr(&RF_TranM, nextPtr);
|
||
|
||
// 打包上报数据（按modbus从机响应的格式）
|
||
i = pack_gprs_tran_data(&Ext_Data_Rec1, 1);
|
||
|
||
recvLen = 2;
|
||
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
|
||
{
|
||
if(tranLocked)
|
||
{
|
||
// 4G发送失败，释放锁让网口有机会发送
|
||
xSemaphoreGive(RF_TranLock);
|
||
tranLocked = 0;
|
||
}
|
||
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
|
||
break;
|
||
}
|
||
|
||
// 成功发送数据的时间: 取当前时间
|
||
DTU_dataTime = totalSeconds;
|
||
|
||
dcBuff.powerInfo.gprsSuccCount++;
|
||
}
|
||
|
||
// 移除已成功发送的数据
|
||
if(k > 0)
|
||
{
|
||
LoopBuff_RemoveItems(&RF_TranM, k);
|
||
// 保存到铁电
|
||
FRAM_SaveInfo(RF_TranM.info_base, (uint8_t *) &RF_TranM.info, sizeof(RF_TranM.info));
|
||
}
|
||
}
|
||
|
||
// 是否连接维护平台：每隔12小时一次（普莱克斯、林德的每次连接）
|
||
if(xSemaphoreTake(DTU_semUpgrade, 0) == pdTRUE)
|
||
{
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
|
||
// 是否升级或下载参数：维护平台
|
||
upgrade = 0;
|
||
ackUpgrade = 0;
|
||
downloadParam = 0;
|
||
ackParam = 0;
|
||
downloadOptions = 0;
|
||
ackOptions = 0;
|
||
downloadBoxes = 0;
|
||
ackBoxes = 0;
|
||
downloadConfig = 0;
|
||
ackConfig = 0;
|
||
reset = 0;
|
||
k = 1; // 发送1条诊断信息
|
||
|
||
try_count = 2;
|
||
while((try_count--) && (k || upgrade || ackUpgrade || downloadParam || ackParam || downloadOptions || ackOptions || downloadBoxes || ackBoxes || downloadConfig || ackConfig))
|
||
{
|
||
// 连接升级服务器
|
||
if(Sim808_Connect(0, dcBuff.configData.upgServer, dcBuff.configData.upgPort))
|
||
{
|
||
if(k)
|
||
{
|
||
// 发送诊断信息，至少接收12个字节
|
||
i = pack_ldms_info_data(DTU_dataTime, totalSeconds);
|
||
recvLen = sizeof(bluetooth_recv_t) + 2 + 2;
|
||
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
|
||
{
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
// 重连
|
||
continue;
|
||
}
|
||
if(recvLen >= sizeof(bluetooth_recv_t) + 2 + 2 && MODBUS_RTU_CRC16(Task_recvBuff, recvLen) == 0
|
||
&& pRecv->cmd == ntohs(0x0035))
|
||
{
|
||
upgrade = Task_recvBuff[sizeof(bluetooth_recv_t)];
|
||
downloadParam = Task_recvBuff[sizeof(bluetooth_recv_t) + 1];
|
||
if(recvLen >= sizeof(bluetooth_recv_t) + 3 + 2)
|
||
downloadConfig = Task_recvBuff[sizeof(bluetooth_recv_t) + 2];
|
||
if(recvLen >= sizeof(bluetooth_recv_t) + 4 + 2)
|
||
downloadOptions = Task_recvBuff[sizeof(bluetooth_recv_t) + 3];
|
||
if(recvLen >= sizeof(bluetooth_recv_t) + 5 + 2)
|
||
downloadBoxes = Task_recvBuff[sizeof(bluetooth_recv_t) + 4];
|
||
k--; // 发送成功
|
||
}
|
||
}
|
||
|
||
// 下载参数
|
||
if(downloadParam)
|
||
{
|
||
printf("\nDownload parameters ...\n");
|
||
|
||
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
|
||
|
||
i = sizeof(bluetooth_send_t);
|
||
|
||
// PSN
|
||
memmove(Task_sendBuff + i, dcBuff.configBottle.PSN, 6);
|
||
i += 6;
|
||
|
||
// 填写固定字段
|
||
i = fill_biDir_fixFields(0xD036, i);
|
||
|
||
// 发送i个字节到服务器，至少接收10个字节
|
||
recvLen = sizeof(bluetooth_recv_t) + 2;
|
||
if(Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
|
||
{
|
||
if(recvLen >= sizeof(bluetooth_recv_t) + 2
|
||
&& MODBUS_RTU_CRC16(Task_recvBuff, recvLen) == 0)
|
||
{
|
||
downloadParam = 0;
|
||
|
||
if(recvLen >= sizeof(bluetooth_recv_t) + D036_PARAM_SIZE + 2
|
||
&& pRecv->cmd == ntohs(0x0036)
|
||
&& MODBUS_RTU_CRC16(Task_recvBuff, sizeof(bluetooth_recv_t) + D036_PARAM_SIZE + 2) == 0)
|
||
{
|
||
// 保存参数
|
||
if(parse_param_D036_data(Task_recvBuff + sizeof(bluetooth_recv_t), &reset))
|
||
{
|
||
// 保存参数
|
||
Config_SaveConfig();
|
||
// Can_Write(CONFIG_BOARD_SAMPLE,CAN_DC_BOTTLE_CONFIG, &display_modifi);
|
||
// Can_Write(CONFIG_BOARD_SAMPLE,CAN_DC_SENSOR_CONFIG, &display_modifi);
|
||
// Can_Write(CONFIG_BOARD_SAMPLE,CAN_DC_DATA_CONFIG, &display_modifi);
|
||
// Can_Write(CONFIG_BOARD_SAMPLE,CAN_DC_DISPLAY_CONFIG, &display_modifi);
|
||
}
|
||
ackParam = 1;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
// 重连
|
||
continue;
|
||
}
|
||
}
|
||
|
||
// 确认参数
|
||
if(ackParam)
|
||
{
|
||
printf("\nConfirm download parameters ...\n");
|
||
|
||
// 发送确认
|
||
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
|
||
|
||
i = sizeof(bluetooth_send_t);
|
||
|
||
// PSN
|
||
memmove(Task_sendBuff + i, dcBuff.configBottle.PSN, 6);
|
||
i += 6;
|
||
// 参数时间戳
|
||
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.ts));
|
||
i += 4;
|
||
|
||
// 填写固定字段
|
||
i = fill_biDir_fixFields(0xD022, i);
|
||
|
||
// 发送i个字节到服务器，至少接收10个字节
|
||
// 如果失败，下次再发送
|
||
recvLen = sizeof(bluetooth_recv_t) + 2;
|
||
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
|
||
{
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
// 重连
|
||
continue;
|
||
}
|
||
ackParam = 0;
|
||
}
|
||
|
||
// 下载配置选项
|
||
if(downloadOptions)
|
||
{
|
||
}
|
||
|
||
// 确认配置选项
|
||
if(ackOptions)
|
||
{
|
||
}
|
||
|
||
// 下载罐箱档案
|
||
if(downloadBoxes)
|
||
{
|
||
printf("\nDownload boxes ...\n");
|
||
|
||
if(boxesInfo.fileSize == 0)
|
||
{
|
||
// 从头开始下载
|
||
memset(&boxesInfo, 0, sizeof(boxesInfo));
|
||
}
|
||
|
||
// 下载数据
|
||
while(boxesInfo.fileSize == 0 || boxesInfo.offset < boxesInfo.fileSize)
|
||
{
|
||
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
|
||
|
||
i = sizeof(bluetooth_send_t);
|
||
|
||
// PSN
|
||
memmove(Task_sendBuff + i, dcBuff.configBottle.PSN, 6);
|
||
i += 6;
|
||
// 当前版本号
|
||
i += 4;
|
||
// 文件偏移量
|
||
Int2ByteL(Task_sendBuff, i, htonl(boxesInfo.offset));
|
||
i += 4;
|
||
// 请求数据长度
|
||
Int2ByteL(Task_sendBuff, i, htonl(UPGRADE_DATA_LEN));
|
||
i += 4;
|
||
|
||
// 填写固定字段
|
||
i = fill_biDir_fixFields(0xD0E2, i);
|
||
|
||
// 发送i个字节到服务器，至少接收10个字节
|
||
// 如果失败，下次再下载
|
||
recvLen = sizeof(bluetooth_recv_t) + 2;
|
||
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
|
||
break;
|
||
|
||
if(recvLen >= sizeof(bluetooth_recv_t) + 2 && MODBUS_RTU_CRC16(Task_recvBuff, recvLen) == 0)
|
||
{
|
||
if(pRecv->cmd == ntohs(0x00E2))
|
||
{
|
||
pFrame = (upgrade_frame_t *) (Task_recvBuff + sizeof(bluetooth_recv_t));
|
||
if(MODBUS_RTU_CRC16(pFrame->data, ntohl(pFrame->len) + 2) == 0)
|
||
{
|
||
// 内容下载成功，允许继续下载
|
||
try_count = 2;
|
||
|
||
// 如果储罐档案有变化
|
||
if(boxesInfo.fileSize > 0 && (boxesInfo.fileSize != ntohl(pFrame->fileSize) || boxesInfo.fileCrc != pFrame->fileCrc
|
||
|| boxesInfo.offset > ntohl(pFrame->fileSize)))
|
||
{
|
||
// 从头开始升级
|
||
memset(&boxesInfo, 0, sizeof(boxesInfo));
|
||
continue;
|
||
}
|
||
// 保存下载信息
|
||
// 如果只是网络通信失败，会断点续传
|
||
boxesInfo.fileSize = ntohl(pFrame->fileSize);
|
||
boxesInfo.offset = ntohl(pFrame->offset);
|
||
boxesInfo.len = ntohl(pFrame->len);
|
||
boxesInfo.fileCrc = pFrame->fileCrc;
|
||
printf("\nfileSize = %d, offset = %d, len = %d\n",
|
||
boxesInfo.fileSize, boxesInfo.offset, boxesInfo.len);
|
||
|
||
// 要留1个字节用于添加结束符
|
||
if(boxesInfo.offset + boxesInfo.len < sizeof(boxesBuff))
|
||
{
|
||
memmove(boxesBuff + boxesInfo.offset, pFrame->data, boxesInfo.len);
|
||
boxesInfo.offset += boxesInfo.len;
|
||
}
|
||
else
|
||
{
|
||
// 取消本次下载
|
||
boxesInfo.fileSize = 0;
|
||
downloadBoxes = 0;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else // 命令返回错误
|
||
{
|
||
// 取消本次下载
|
||
boxesInfo.fileSize = 0;
|
||
downloadBoxes = 0;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if(boxesInfo.fileSize > 0 && boxesInfo.offset == boxesInfo.fileSize)
|
||
{
|
||
if(do_crc_16(0, (uint8_t *) boxesBuff, boxesInfo.fileSize) == boxesInfo.fileCrc)
|
||
{
|
||
// 校验通过
|
||
printf("\nBoxes confirm passed\n");
|
||
downloadBoxes = 0;
|
||
|
||
// 发送确认
|
||
ackBoxes = 1;
|
||
}
|
||
else
|
||
{
|
||
// 校验未通过
|
||
printf("\n****** Boxes confirm failed\n");
|
||
// 从头开始
|
||
boxesInfo.fileSize = 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
// 继续
|
||
continue;
|
||
}
|
||
}
|
||
|
||
// 确认罐箱档案
|
||
if(ackBoxes)
|
||
{
|
||
printf("\nConfirm boxes ...\n");
|
||
|
||
// 发送确认
|
||
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
|
||
|
||
i = sizeof(bluetooth_send_t);
|
||
|
||
// PSN
|
||
memmove(Task_sendBuff + i, dcBuff.configBottle.PSN, 6);
|
||
i += 6;
|
||
// 当前版本号
|
||
Int2ByteL(Task_sendBuff, i, htonl(boxesInfo.ver));
|
||
i += 4;
|
||
// 档案的CRC16
|
||
Int2ByteS(Task_sendBuff, i, boxesInfo.fileCrc);
|
||
i += 2;
|
||
|
||
// 填写固定字段
|
||
i = fill_biDir_fixFields(0xD0E3, i);
|
||
|
||
// 发送i个字节到服务器，至少接收10个字节
|
||
// 如果失败，下次再发送
|
||
recvLen = sizeof(bluetooth_recv_t) + 2;
|
||
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
|
||
{
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
// 重连
|
||
continue;
|
||
}
|
||
if(recvLen == sizeof(bluetooth_recv_t) + 2 && pRecv->cmd == ntohs(0x00E3))
|
||
{
|
||
ackBoxes = 0;
|
||
|
||
// 更新储罐档案
|
||
boxesBuff[boxesInfo.fileSize] = 0;
|
||
Ext_Update_Boxes(boxesBuff);
|
||
|
||
// 下次再升级从头开始
|
||
boxesInfo.fileSize = 0;
|
||
}
|
||
}
|
||
|
||
// 下载配置
|
||
if(downloadConfig)
|
||
{
|
||
printf("\nDownload configuration ...\n");
|
||
|
||
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
|
||
|
||
i = sizeof(bluetooth_send_t);
|
||
|
||
// PSN
|
||
memmove(Task_sendBuff + i, dcBuff.configBottle.PSN, 6);
|
||
i += 6;
|
||
|
||
// 填写固定字段
|
||
i = fill_biDir_fixFields(0xD038, i);
|
||
|
||
// 发送i个字节到服务器，至少接收10个字节
|
||
recvLen = sizeof(bluetooth_recv_t) + 2;
|
||
if(Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
|
||
{
|
||
if(recvLen >= sizeof(bluetooth_recv_t) + 2
|
||
&& MODBUS_RTU_CRC16(Task_recvBuff, recvLen) == 0)
|
||
{
|
||
downloadConfig = 0;
|
||
|
||
if(recvLen >= sizeof(bluetooth_recv_t) + D038_CONFIG_SIZE + 2
|
||
&& pRecv->cmd == ntohs(0x0038)
|
||
&& MODBUS_RTU_CRC16(Task_recvBuff, sizeof(bluetooth_recv_t) + D038_CONFIG_SIZE + 2) == 0)
|
||
{
|
||
// 保存参数
|
||
if(parse_config_D038_data(Task_recvBuff + sizeof(bluetooth_recv_t)))
|
||
{
|
||
// 保存参数
|
||
Config_SaveConfig();
|
||
// Can_Write(CONFIG_BOARD_SAMPLE,CAN_DC_BOTTLE_CONFIG, &display_modifi);
|
||
// Can_Write(CONFIG_BOARD_SAMPLE,CAN_DC_SENSOR_CONFIG, &display_modifi);
|
||
// Can_Write(CONFIG_BOARD_SAMPLE,CAN_DC_DATA_CONFIG, &display_modifi);
|
||
// Can_Write(CONFIG_BOARD_SAMPLE,CAN_DC_DISPLAY_CONFIG, &display_modifi);
|
||
}
|
||
ackConfig = 1;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
// 重连
|
||
continue;
|
||
}
|
||
}
|
||
|
||
// 确认配置
|
||
if(ackConfig)
|
||
{
|
||
printf("\nConfirm download configuration ...\n");
|
||
|
||
// 发送确认
|
||
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
|
||
|
||
i = sizeof(bluetooth_send_t);
|
||
|
||
// PSN
|
||
memmove(Task_sendBuff + i, dcBuff.configBottle.PSN, 6);
|
||
i += 6;
|
||
|
||
// 填写固定字段
|
||
i = fill_biDir_fixFields(0xD039, i);
|
||
|
||
// 发送i个字节到服务器，至少接收10个字节
|
||
// 如果失败，下次再发送
|
||
recvLen = sizeof(bluetooth_recv_t) + 2;
|
||
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
|
||
{
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
// 重连
|
||
continue;
|
||
}
|
||
ackConfig = 0;
|
||
// 配置改变，需要复位
|
||
reset = 1;
|
||
}
|
||
|
||
// 升级
|
||
if(upgrade)
|
||
{
|
||
printf("\nUpgrade software ...\n");
|
||
|
||
// 从FRAM读取初始进度
|
||
FRAM_LoadInfo(FRAM_UPGRADE_INFO_BASE, (uint8_t *) &upInfo, sizeof(upInfo));
|
||
|
||
if(upInfo.fileSize == 0)
|
||
{
|
||
// 从头开始升级
|
||
memset(&upInfo, 0, sizeof(upInfo));
|
||
// 保存到铁电
|
||
for(write_count = 0; write_count < 2; write_count++)
|
||
{
|
||
FRAM_SaveInfo(FRAM_UPGRADE_INFO_BASE, (uint8_t *) &upInfo, sizeof(upInfo));
|
||
if(FRAM_BufferVerify(FRAM_UPGRADE_INFO_BASE, (uint8_t *) &upInfo, sizeof(upInfo)))
|
||
break;
|
||
printf("**** Verify FRAM failed at: 0x%08X, %d bytes\n", FRAM_UPGRADE_INFO_BASE, sizeof(upInfo));
|
||
delay_ms(200);
|
||
}
|
||
}
|
||
|
||
// 下载数据
|
||
while(upInfo.fileSize == 0 || upInfo.offset < upInfo.fileSize)
|
||
{
|
||
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
|
||
|
||
i = sizeof(bluetooth_send_t);
|
||
|
||
// PSN
|
||
memmove(Task_sendBuff + i, dcBuff.configBottle.PSN, 6);
|
||
i += 6;
|
||
// 当前固件号
|
||
Int2ByteL(Task_sendBuff, i, htonl(upInfo.ver));
|
||
i += 4;
|
||
// 文件偏移量
|
||
Int2ByteL(Task_sendBuff, i, htonl(upInfo.offset));
|
||
i += 4;
|
||
// 请求数据长度
|
||
Int2ByteL(Task_sendBuff, i, htonl(UPGRADE_DATA_LEN));
|
||
i += 4;
|
||
|
||
// 填写固定字段
|
||
i = fill_biDir_fixFields(0xD0E0, i);
|
||
|
||
// 发送i个字节到服务器，至少接收10个字节
|
||
// 如果失败，下次再升级
|
||
recvLen = sizeof(bluetooth_recv_t) + 2;
|
||
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
|
||
break;
|
||
|
||
if(recvLen >= sizeof(bluetooth_recv_t) + 2 && MODBUS_RTU_CRC16(Task_recvBuff, recvLen) == 0)
|
||
{
|
||
if(pRecv->cmd == ntohs(0x00E0))
|
||
{
|
||
pFrame = (upgrade_frame_t *) (Task_recvBuff + sizeof(bluetooth_recv_t));
|
||
if(MODBUS_RTU_CRC16(pFrame->data, ntohl(pFrame->len) + 2) == 0)
|
||
{
|
||
// 升级内容下载成功，允许继续升级
|
||
try_count = 2;
|
||
|
||
// 如果升级包有变化
|
||
if(upInfo.fileSize > 0 && (upInfo.fileSize != ntohl(pFrame->fileSize) || upInfo.fileCrc != pFrame->fileCrc
|
||
|| upInfo.offset > ntohl(pFrame->fileSize) || upInfo.ver != ntohl(pFrame->ver)))
|
||
{
|
||
// 从头开始升级
|
||
memset(&upInfo, 0, sizeof(upInfo));
|
||
// 保存到铁电
|
||
for(write_count = 0; write_count < 2; write_count++)
|
||
{
|
||
FRAM_SaveInfo(FRAM_UPGRADE_INFO_BASE, (uint8_t *) &upInfo, sizeof(upInfo));
|
||
if(FRAM_BufferVerify(FRAM_UPGRADE_INFO_BASE, (uint8_t *) &upInfo, sizeof(upInfo)))
|
||
break;
|
||
printf("**** Verify FRAM failed at: 0x%08X, %d bytes\n", FRAM_UPGRADE_INFO_BASE, sizeof(upInfo));
|
||
delay_ms(200);
|
||
}
|
||
continue;
|
||
}
|
||
// 保存下载信息
|
||
// 如果只是网络通信失败，会断点续传
|
||
upInfo.ver = ntohl(pFrame->ver);
|
||
upInfo.fileSize = ntohl(pFrame->fileSize);
|
||
upInfo.offset = ntohl(pFrame->offset);
|
||
upInfo.len = ntohl(pFrame->len);
|
||
upInfo.fileCrc = pFrame->fileCrc;
|
||
printf("\nfileSize = %d, offset = %d, len = %d\n",
|
||
upInfo.fileSize, upInfo.offset, upInfo.len);
|
||
|
||
// 如果是第一个包，先将升级请求改为0，以免意外重启导致boot-loader解压
|
||
// 待全部下载完以后，再改为1
|
||
if(upInfo.offset == 0)
|
||
((TUpgradeHeader *) pFrame->data)->upgrade_request = 0;
|
||
#if UPGRADE_DATA_LEN >= SFLASH_ERASE_SIZE
|
||
// 直接写入flash
|
||
for(write_count = 0; write_count < 2; write_count++)
|
||
{
|
||
SFlash_BufferWrite(SFLASH_UPGRADE_BASE + upInfo.offset, pFrame->data, upInfo.len);
|
||
if(SFlash_BufferVerify(SFLASH_UPGRADE_BASE + upInfo.offset, pFrame->data, upInfo.len))
|
||
break;
|
||
printf("**** Verify SFlash failed at: 0x%08X, %d bytes\n", SFLASH_UPGRADE_BASE + upInfo.offset, upInfo.len);
|
||
delay_ms(200);
|
||
}
|
||
upInfo.offset += upInfo.len;
|
||
#else
|
||
// 为了减少flash的多次擦写，又节约收发缓冲
|
||
// 先把数据拷到flash页缓冲
|
||
for(write_count = 0; write_count < 2; write_count++)
|
||
{
|
||
FRAM_BufferWrite(FRAM_UPGRADE_DATA_BASE + upInfo.offset % SFLASH_ERASE_SIZE, pFrame->data, upInfo.len);
|
||
if(FRAM_BufferVerify(FRAM_UPGRADE_DATA_BASE + upInfo.offset % SFLASH_ERASE_SIZE, pFrame->data, upInfo.len))
|
||
break;
|
||
printf("**** Verify FRAM failed at: 0x%08X, %d bytes\n", FRAM_UPGRADE_DATA_BASE + upInfo.offset % SFLASH_ERASE_SIZE, upInfo.len);
|
||
delay_ms(200);
|
||
}
|
||
upInfo.offset += upInfo.len;
|
||
|
||
// 够一页了，或者下载完了就从铁电写入flash
|
||
if(upInfo.offset % SFLASH_ERASE_SIZE == 0)
|
||
{
|
||
FRAM_BufferRead(FRAM_UPGRADE_DATA_BASE, Task_recvBuff, SFLASH_ERASE_SIZE);
|
||
for(write_count = 0; write_count < 2; write_count++)
|
||
{
|
||
SFlash_BufferWrite(SFLASH_UPGRADE_BASE + (upInfo.offset - SFLASH_ERASE_SIZE), Task_recvBuff, SFLASH_ERASE_SIZE);
|
||
if(SFlash_BufferVerify(SFLASH_UPGRADE_BASE + (upInfo.offset - SFLASH_ERASE_SIZE), Task_recvBuff, SFLASH_ERASE_SIZE))
|
||
break;
|
||
printf("**** Verify SFlash failed at: 0x%08X, %d bytes\n", SFLASH_UPGRADE_BASE + (upInfo.offset - SFLASH_ERASE_SIZE), SFLASH_ERASE_SIZE);
|
||
delay_ms(200);
|
||
}
|
||
|
||
}
|
||
else if(upInfo.offset == upInfo.fileSize)
|
||
{
|
||
FRAM_BufferRead(FRAM_UPGRADE_DATA_BASE, Task_recvBuff, upInfo.offset % SFLASH_ERASE_SIZE);
|
||
for(write_count = 0; write_count < 2; write_count++)
|
||
{
|
||
SFlash_BufferWrite(SFLASH_UPGRADE_BASE + (upInfo.offset - upInfo.offset % SFLASH_ERASE_SIZE), Task_recvBuff, upInfo.offset % SFLASH_ERASE_SIZE);
|
||
if(SFlash_BufferVerify(SFLASH_UPGRADE_BASE + (upInfo.offset - upInfo.offset % SFLASH_ERASE_SIZE), Task_recvBuff, upInfo.offset % SFLASH_ERASE_SIZE))
|
||
break;
|
||
printf("**** Verify SFlash failed at: 0x%08X, %d bytes\n", SFLASH_UPGRADE_BASE + (upInfo.offset - upInfo.offset % SFLASH_ERASE_SIZE), upInfo.offset % SFLASH_ERASE_SIZE);
|
||
delay_ms(200);
|
||
}
|
||
}
|
||
#endif
|
||
for(write_count = 0; write_count < 2; write_count++)
|
||
{
|
||
// 保存到铁电
|
||
FRAM_SaveInfo(FRAM_UPGRADE_INFO_BASE, (uint8_t *) &upInfo, sizeof(upInfo));
|
||
if(FRAM_BufferVerify(FRAM_UPGRADE_INFO_BASE, (uint8_t *) &upInfo, sizeof(upInfo)))
|
||
break;
|
||
printf("**** Verify FRAM failed at: 0x%08X, %d bytes\n", FRAM_UPGRADE_INFO_BASE, sizeof(upInfo));
|
||
delay_ms(200);
|
||
}
|
||
}
|
||
}
|
||
else // 命令返回错误
|
||
{
|
||
// 取消本次升级
|
||
upInfo.fileSize = 0;
|
||
// 保存到铁电
|
||
for(write_count = 0; write_count < 2; write_count++)
|
||
{
|
||
FRAM_SaveInfo(FRAM_UPGRADE_INFO_BASE, (uint8_t *) &upInfo, sizeof(upInfo));
|
||
if(FRAM_BufferVerify(FRAM_UPGRADE_INFO_BASE, (uint8_t *) &upInfo, sizeof(upInfo)))
|
||
break;
|
||
printf("**** Verify FRAM failed at: 0x%08X, %d bytes\n", FRAM_UPGRADE_INFO_BASE, sizeof(upInfo));
|
||
delay_ms(200);
|
||
}
|
||
|
||
upgrade = 0;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if(upInfo.fileSize > 0 && upInfo.offset == upInfo.fileSize)
|
||
{
|
||
SFlash_BufferRead(SFLASH_UPGRADE_BASE, (uint8_t *) &upHeader, sizeof(upHeader));
|
||
// 将升级请求改为1
|
||
upHeader.upgrade_request = 1;
|
||
if(upHeader.check == 0x55AA
|
||
&& do_crc_16(0, (uint8_t *) &upHeader, sizeof(upHeader)) == 0
|
||
&& do_sflash_crc(SFLASH_UPGRADE_BASE + sizeof(upHeader), upHeader.upgrade_length) == 0)
|
||
{
|
||
// 校验通过
|
||
printf("\nUpgrade package confirm passed\n");
|
||
// 发送确认
|
||
ackUpgrade = 1;
|
||
}
|
||
else
|
||
{
|
||
// 校验未通过
|
||
printf("\n****** Upgrade package confirm failed\n");
|
||
// 从头开始
|
||
upInfo.fileSize = 0;
|
||
// 保存到铁电
|
||
for(write_count = 0; write_count < 2; write_count++)
|
||
{
|
||
FRAM_SaveInfo(FRAM_UPGRADE_INFO_BASE, (uint8_t *) &upInfo, sizeof(upInfo));
|
||
if(FRAM_BufferVerify(FRAM_UPGRADE_INFO_BASE, (uint8_t *) &upInfo, sizeof(upInfo)))
|
||
break;
|
||
printf("**** Verify FRAM failed at: 0x%08X, %d bytes\n", FRAM_UPGRADE_INFO_BASE, sizeof(upInfo));
|
||
delay_ms(200);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
// 继续
|
||
continue;
|
||
}
|
||
}
|
||
|
||
// 确认升级成功
|
||
if(ackUpgrade)
|
||
{
|
||
printf("\nConfirm upgrade software ...\n");
|
||
|
||
|
||
// 发送确认
|
||
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
|
||
|
||
i = sizeof(bluetooth_send_t);
|
||
|
||
// PSN
|
||
memmove(Task_sendBuff + i, dcBuff.configBottle.PSN, 6);
|
||
i += 6;
|
||
// 当前固件号
|
||
Int2ByteL(Task_sendBuff, i, htonl(upInfo.ver));
|
||
i += 4;
|
||
// 固件的CRC16
|
||
Int2ByteS(Task_sendBuff, i, upInfo.fileCrc);
|
||
i += 2;
|
||
|
||
// 填写固定字段
|
||
i = fill_biDir_fixFields(0xD0E1, i);
|
||
|
||
// 发送i个字节到服务器，至少接收10个字节
|
||
// 如果失败，下次再发送
|
||
recvLen = sizeof(bluetooth_recv_t) + 2;
|
||
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
|
||
{
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
// 重连
|
||
continue;
|
||
}
|
||
if(recvLen == sizeof(bluetooth_recv_t) + 2 && pRecv->cmd == ntohs(0x00E1))
|
||
{
|
||
// 将升级请求改为1
|
||
SFlash_BufferRead(SFLASH_UPGRADE_BASE, (uint8_t *) &upHeader, sizeof(upHeader));
|
||
upHeader.upgrade_request = 1;
|
||
for(write_count = 0; write_count < 2; write_count++)
|
||
{
|
||
SFlash_BufferWrite(SFLASH_UPGRADE_BASE, (uint8_t *) &upHeader, sizeof(upHeader));
|
||
if(SFlash_BufferVerify(SFLASH_UPGRADE_BASE, (uint8_t *) &upHeader, sizeof(upHeader)))
|
||
break;
|
||
printf("**** Verify SFlash failed at: 0x%08X, %d bytes\n", SFLASH_UPGRADE_BASE, sizeof(upHeader));
|
||
delay_ms(200);
|
||
}
|
||
|
||
// 下次再升级从头开始
|
||
upInfo.fileSize = 0;
|
||
// 保存到铁电
|
||
for(write_count = 0; write_count < 2; write_count++)
|
||
{
|
||
FRAM_SaveInfo(FRAM_UPGRADE_INFO_BASE, (uint8_t *) &upInfo, sizeof(upInfo));
|
||
if(FRAM_BufferVerify(FRAM_UPGRADE_INFO_BASE, (uint8_t *) &upInfo, sizeof(upInfo)))
|
||
break;
|
||
printf("**** Verify FRAM failed at: 0x%08X, %d bytes\n", FRAM_UPGRADE_INFO_BASE, sizeof(upInfo));
|
||
delay_ms(200);
|
||
}
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
|
||
// 关闭DTU电源
|
||
VCC_GSM_OFF();
|
||
delay_ms(200);
|
||
|
||
// 将LDROM映射到地址0x0
|
||
// FMC_Open();
|
||
// FMC_SetVectorPageAddr(LDROM_BASE);
|
||
// FMC_Close();
|
||
// 复位以后执行Bootloader，将升级包解压
|
||
//WDT_Close(); // 先关看门狗，免得bootloader复位
|
||
NVIC_SystemReset();
|
||
}
|
||
}
|
||
|
||
// 关闭和服务器的连接
|
||
DTU_Close(0);
|
||
|
||
// 确认参数以后才执行复位命令（避免反复复位）
|
||
if(reset && !ackParam)
|
||
{
|
||
VCC_GSM_OFF();
|
||
delay_ms(200);
|
||
NVIC_SystemReset();
|
||
}
|
||
}
|
||
}
|
||
|
||
// 刚处理完，清除等待的信号。等下一个周期再执行（如果有报警必须立即上传）
|
||
xSemaphoreTake(DTU_semUpgrade, 0);
|
||
}
|
||
}
|
||
}
|