haifeng.wang
/
MS-DTU
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
MS-DTU/Anjiehui7_TTS_ST_V2.4_LOCAL/User/uart_dtu.c

5306 lines
160 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
*********************************************************************************************************
* 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"
#include "ccs_prediction.h"
// 初始唤醒次数(快速发送）
#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 uint8_t DTU_dataConn = 0;
// 强制连接维护平台
volatile uint8_t DTU_ldmsConn = 0;
// 维护平台连接计时
volatile uint32_t DTU_ldmsTime = 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任务和服务器之间的收发缓冲
#define TASK_SENDBUFF_SIZE 400
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}; // 扩展内存
// 信号量，用于通知执行任务
volatile uint8_t DTU_semGPS = 0;
volatile uint8_t DTU_semGPRS = 0;
volatile uint8_t DTU_semSync = 0;
// 用于发送到服务器的数据结构
// 和蓝牙的相应命令一致
#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;
// 双向通讯的数据结构
typedef struct // size = 120
{
uint16_t serverVer; // 服务器参数版本号
uint8_t type; // 储罐类型
uint32_t diameter; // 内径
uint32_t len; // 圆柱体长度
uint32_t lenExtra; // 直边封头长度
uint32_t reserved_1[3];
uint8_t source; // 液源
uint32_t density; // 各液源的比重（kg/m3)
uint16_t fullPct; // 满液位百分比
uint16_t priPct; // 关键液位百分比
uint16_t orderPct; // 订货液位百分比
uint16_t emptyPct; // 空液位百分比
uint32_t planMount; // 每日计划用量
uint32_t predictMount; // 每日预测用量
uint16_t warnVolt; // 电压报警低点: 10mV
uint16_t warnVoltH; // 电压报警高点: 10mV
uint16_t warnPress; // 压力报警低点: KPa
uint16_t warnPressH; // 压力报警高点: KPa
uint32_t intervalTrans; // 数据上报周期
uint32_t intervalSample; // 数据采集周期
uint32_t intervalGPSTrans; // 位置上报周期
uint32_t intervalGPS; // 位置采集周期
union
{
struct
{
char gpsServer[20]; // 远传服务器 (只上传，不修改)
int16_t gpsPort; // 远传端口 (只上传，不修改)
char pwd1[6]; // 储罐参数修改密码
};
struct
{
char gprsServer[26]; // praxair：修改数据服务器地址
int16_t gprsPort; // praxair: 修改数据服务器端口
};
};
uint32_t options; // 参数开关
union
{
uint8_t reserved_2[12];
struct
{
uint16_t floorLevel; // praxair: 液量报警下限
uint16_t span; // praxair: 液量变化报警门限
uint16_t spanPeriod; // praxair: 液量变化报警时间
unsigned floorLevelAssigned : 1; // praxair: 参数中floorLevel是否有效
unsigned spanAssigned : 1; // praxair: 参数中span是否有效
unsigned spanPeriodAssigned : 1; // praxair: 参数中spanPeriod是否有效
unsigned intervalTransAssigned : 1; // praxair: 参数中intervalTrans是否有效
unsigned gprsServerAssigned : 1; // praxair: 参数中数据服务器地址是否有效
unsigned gprsPortAssigned : 1; // praxair: 参数中数据服务器端口是否有效
unsigned : 2;
};
};
uint32_t ts; // 参数时间戳
} param_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;
// 阿里云密钥记录
typedef struct // size=76
{
unsigned short check; // 数据有效标志, 0x55AA表示有效
uint8_t PSN[6]; // 获取密钥所用的PSN（如果PSN改变需重新获取）
char product[12]; // 产品代码
char device[21]; // 默认为cPSN
char secret[33]; // 设备密钥
unsigned short crc; // 对前面内容的crc校验
} TAliyunSecret;
#define ALIYUN_SECRET_SIZE (66)
#pragma pack(pop)
// 阿里云密钥
TAliyunSecret aliyunSecret = {0};
// 升级包记录
upgrade_info_t upInfo = {0};
// GPS循环缓冲记录
loopbuff_t gpsBuff = {0};
// 存放GPRS记录的循环缓冲
loopbuff_t gprsBuff = {0};
loopbuff_t bd_gprsBuff = {0};
// GPRS记录读写缓冲
gprs_data_t gprsRWBuf;
void pack_param_DO23_data(param_data_t *param)
{
memset(param, 0, sizeof(param_data_t));
param->serverVer = htons(dcBuff.configBottle.serverVer);
param->type = dcBuff.configBottle.type;
param->diameter = htonl(dcBuff.configBottle.diameter);
param->len = htonl(dcBuff.configBottle.len);
param->lenExtra = htonl(dcBuff.configBottle.lenExtra);
param->source = dcBuff.configBottle.source;
param->density = htonl(Config_GetDensity(dcBuff.configBottle.source) * 1000);
param->fullPct = htons(dcBuff.configBottle.fullPct);
param->priPct = htons(dcBuff.configBottle.priPct);
param->orderPct = htons(dcBuff.configBottle.orderPct);
param->emptyPct = htons(dcBuff.configBottle.emptyPct);
param->planMount = htonl(dcBuff.configBottle.planMount);
param->predictMount = htonl(dcBuff.configBottle.predictMount);
param->warnVolt = htons(dcBuff.configBottle.warnVolt);
param->warnVoltH = htons(dcBuff.configBottle.warnVoltH);
param->warnPress = htons(dcBuff.configBottle.warnPress);
param->warnPressH = htons(dcBuff.configBottle.warnPressH);
param->intervalTrans = htonl(dcBuff.configData.intervalTrans);
param->intervalSample = htonl(dcBuff.configData.intervalSample);
param->intervalGPSTrans = htonl(dcBuff.configData.intervalGPSTrans);
param->intervalGPS = htonl(dcBuff.configData.intervalGPS);
if(dcBuff.configBottle.serverVer != 3)
{
strcpy(param->gpsServer, dcBuff.configData.gpsServer);
param->gpsPort = htons(dcBuff.configData.gpsPort);
strcpy(param->pwd1, dcBuff.configDisplay.pwd1);
}
if(dcBuff.configBottle.dispMode == DISP_MODE_ALL)
param->options |= 0x0003ul;
else if(dcBuff.configBottle.dispMode == DISP_MODE_L)
param->options |= 0x0001ul;
else if(dcBuff.configBottle.dispMode == DISP_MODE_KG)
param->options |= 0x0002ul;
param->options = htonl(param->options);
param->ts = htonl(dcBuff.configBottle.ts);
// praxair
memset(param->reserved_2, 0, sizeof(param->reserved_2));
if(dcBuff.configBottle.serverVer == 3)
{
param->floorLevel = htons(dcBuff.configBottle.floorLevel);
param->floorLevelAssigned = 1;
param->span = htons(dcBuff.configBottle.span);
param->spanAssigned = 1;
param->spanPeriod = htons(dcBuff.configBottle.spanPeriod);
param->spanPeriodAssigned = 1;
param->intervalTransAssigned = 1;
strcpy(param->gprsServer, dcBuff.configData.server);
param->gprsServerAssigned = 1;
param->gprsPort = htons(dcBuff.configData.port);
param->gprsPortAssigned = 1;
}
}
void parse_param_D021_data(param_data_t *param)
{
int serverVer = ntohs(param->serverVer);
dcBuff.configBottle.serverVer = serverVer;
if(serverVer == 3) // praxair
{
if(param->floorLevelAssigned)
dcBuff.configBottle.floorLevel = ntohs(param->floorLevel);
if(param->spanAssigned)
dcBuff.configBottle.span = ntohs(param->span);
if(param->spanPeriodAssigned)
dcBuff.configBottle.spanPeriod = ntohs(param->spanPeriod);
if(param->intervalTransAssigned)
dcBuff.configData.intervalTrans = ntohl(param->intervalTrans);
if(param->gprsServerAssigned)
{
strcpy(dcBuff.configData.server, param->gprsServer);
strcpy(dcBuff.configData.upgServer, param->gprsServer);
strcpy(dcBuff.configData.gpsServer, param->gprsServer);
}
if(param->gprsPortAssigned)
{
dcBuff.configData.port = ntohs(param->gprsPort);
dcBuff.configData.upgPort = dcBuff.configData.port + 1;
dcBuff.configData.gpsPort = dcBuff.configData.port + 2;
}
}
else
{
dcBuff.configBottle.type = param->type;
dcBuff.configBottle.diameter = ntohl(param->diameter);
dcBuff.configBottle.len = ntohl(param->len);
dcBuff.configBottle.lenExtra = ntohl(param->lenExtra);
dcBuff.configBottle.source = param->source;
Config_SetDensity(dcBuff.configBottle.source, ntohl(param->density) / 1000.0);
dcBuff.configBottle.fullPct = ntohs(param->fullPct);
dcBuff.configBottle.priPct = ntohs(param->priPct);
dcBuff.configBottle.orderPct = ntohs(param->orderPct);
dcBuff.configBottle.emptyPct = ntohs(param->emptyPct);
dcBuff.configBottle.planMount = ntohl(param->planMount);
dcBuff.configBottle.predictMount = ntohl(param->predictMount);
dcBuff.configBottle.warnVolt = ntohs(param->warnVolt);
dcBuff.configBottle.warnVoltH = ntohs(param->warnVoltH);
dcBuff.configBottle.warnPress = ntohs(param->warnPress);
dcBuff.configBottle.warnPressH = ntohs(param->warnPressH);
dcBuff.configData.intervalTrans = ntohl(param->intervalTrans);
dcBuff.configData.intervalSample = ntohl(param->intervalSample);
// 以下参数只做上传，不做修改
// dcBuff.configData.intervalGPSTrans = ntohl(param->intervalGPSTrans);
// dcBuff.configData.intervalGPS = ntohl(param->intervalGPS);
// strcpy(dcBuff.configData.gpsServer, param->gpsServer);
// dcBuff.configData.gpsPort = ntohs(param->gpsPort);
// strcpy(dcBuff.configDisplay.pwd1, param->pwd1);
dcBuff.configBottle.options = ntohl(param->options);
if((dcBuff.configBottle.options & 0x0003ul) == 0x0003ul)
dcBuff.configBottle.dispMode = DISP_MODE_ALL;
else if((dcBuff.configBottle.options & 0x0001ul) == 0x0001ul)
dcBuff.configBottle.dispMode = DISP_MODE_L;
else if((dcBuff.configBottle.options & 0x0002ul) == 0x0002ul)
dcBuff.configBottle.dispMode = DISP_MODE_KG;
else
dcBuff.configBottle.dispMode = DISP_MODE_DPRESS;
dcBuff.configBottle.ts = ntohl(param->ts);
}
}
// 是否GPS定位
volatile uint8_t GPS_Locate = 1;
volatile uint8_t GPS_Located = 0;
volatile uint32_t GPS_waitTick = 0;
volatile uint8_t GPS_Waiting = 0;
// GPS定位超时
const uint8_t DTU_tmrLocate = 90;
// GPS发送数据
volatile uint32_t GPS_tranTick = 0;
// 保存上次数据的时间
bluetooth_timestamp_t GPS_LastTime = {0};
// 是否发送GPRS数据
uint8_t GPRS_Send_Task = 0;
uint32_t GPRS_Send_Time = 0;
// 是否保存GPRS数据
uint8_t GPRS_Save_Task = 0;
uint32_t GPRS_Save_Time = 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;
}
// 将一个数据加入队列
void GPS_PutToQueue(gps_data_t *gps)
{
uint16_t nextPtr;
// 如果要添加数据的时间大于上一条数据的时间
if(GPS_LastTime.year == 0 || GPS_IsLateThan(&gps->time, &GPS_LastTime))
{
// 移动写指针
nextPtr = LoopBuff_GetNextPtr(&gpsBuff, gpsBuff.info.wtPtr);
// 如果队列已满
if(nextPtr == gpsBuff.info.rdPtr)
{
// 移动读指针（丢弃第一条数据）
gpsBuff.info.rdPtr = LoopBuff_GetNextPtr(&gpsBuff, gpsBuff.info.rdPtr);
}
// 将新数据加到最后
FRAM_BufferWrite(LoopBuff_GetDataPos(&gpsBuff, gpsBuff.info.wtPtr), (uint8_t *) gps, sizeof(gps_data_t));
gpsBuff.info.wtPtr = nextPtr;
// 保存到铁电
FRAM_SaveInfo(gpsBuff.info_base, (uint8_t *) &gpsBuff.info, sizeof(gpsBuff.info));
GPS_LastTime = gps->time;
}
}
// 将一个数据加入队列
void GPRS_PutToQueue(loopbuff_t *lpBuff, data_dtu_t *dtuData, data_sample_t *sampleData)
{
uint16_t nextPtr;
S_RTC_TIME_DATA_T sRTC;
gprs_data_t *gprs;
// 移动写指针
nextPtr = LoopBuff_GetNextPtr(lpBuff, lpBuff->info.wtPtr);
// 如果队列已满
if(nextPtr == lpBuff->info.rdPtr)
{
// 移动读指针（丢弃第一条数据）
lpBuff->info.rdPtr = LoopBuff_GetNextPtr(lpBuff, lpBuff->info.rdPtr);
}
// 将新数据加到最后
gprs = &gprsRWBuf;
// 获取当前时间
RTC_GetDateAndTime(&sRTC);
// 计算自上次gps定位以来的时间
gprs->sample_time = Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);
gprs->dtuData = *dtuData;
gprs->sampleData = *sampleData;
FRAM_BufferWrite(LoopBuff_GetDataPos(lpBuff, lpBuff->info.wtPtr), (uint8_t *) gprs, sizeof(gprs_data_t));
lpBuff->info.wtPtr = nextPtr;
}
// 将前面几条数据移出队列
void GPS_MoveFromQueue(uint8_t count)
{
LoopBuff_RemoveItems(&gpsBuff, count);
// 保存到铁电
FRAM_SaveInfo(gpsBuff.info_base, (uint8_t *) &gpsBuff.info, sizeof(gpsBuff.info));
}
// 查找队列前面的数据, 找出时间间隔相同的一组，最多max_count条
// 本函数在调用的地方加锁，因为这个函数返回以后接着要取数据
uint8_t GPS_LookData(uint8_t max_count, uint16_t *interval, uint8_t *done)
{
uint8_t count = 0;
uint8_t i;
uint16_t gps_count = 0, nextPtr;
gps_data_t gps0, gps1;
*interval = 0;
*done = 1;
if(max_count < 1)
return 0;
// 获取未发送记录条数
gps_count = LoopBuff_GetCount(&gpsBuff);
if(gps_count < 2)
return gps_count;
count = 2;
FRAM_BufferRead(LoopBuff_GetDataPos(&gpsBuff, gpsBuff.info.rdPtr), (uint8_t *) &gps0, sizeof(gps_data_t));
nextPtr = LoopBuff_GetNextPtr(&gpsBuff, gpsBuff.info.rdPtr);
FRAM_BufferRead(LoopBuff_GetDataPos(&gpsBuff, nextPtr), (uint8_t *) &gps1, sizeof(gps_data_t));
*interval = GPS_CalcInterval(&gps1.time, &gps0.time);
for(i = 2; count < max_count && i < gps_count; i++)
{
// 如果后面的时间间隔不一样
gps0 = gps1;
nextPtr = LoopBuff_GetNextPtr(&gpsBuff, nextPtr);
FRAM_BufferRead(LoopBuff_GetDataPos(&gpsBuff, nextPtr), (uint8_t *) &gps1, sizeof(gps_data_t));
if(GPS_CalcInterval(&gps1.time, &gps0.time) != *interval)
break;
count++;
}
if(i < gps_count)
*done = 0;
return count;
}
// 将采集数据中的传感器状态转换为蓝牙协议中的状态
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->RDR;
// printf("%c", u8DTU);
// 直接处理
DTU_Task0(u8DTU);
}
// GSM uart
void GPRS_IRQHandler(USART_Handle *huart)
{
uint8_t u8DTU = (uint8_t) huart->Instance->RDR;
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_Init()
{
/* 配置GSM端口 */
LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOA);
/**USART1 GPIO Configuration
PA9 ------> USART1_TX
PA10 ------> USART1_RX
*/
GPIO_InitStruct.Pin = LL_GPIO_PIN_9|LL_GPIO_PIN_10;
GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_MEDIUM;
GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
GPIO_InitStruct.Alternate = LL_GPIO_AF_7;
LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* 配置GPS端口: GPS和Debug共用一个串口，GPS用到输入，DEBUG用到输出 */
}
void DTU_Open()
{
LL_USART_InitTypeDef USART_InitStruct = {0};
// 分配扩展内存
// 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(&gpsBuff, sizeof(gps_data_t), FRAM_GPS_DATA_COUNT, FRAM_GPS_INFO_BASE, FRAM_GPS_DATA_BASE);
LoopBuff_Create(&gprsBuff, sizeof(gprs_data_t), FRAM_GPRS_DATA_COUNT, FRAM_GPRS_INFO_BASE, FRAM_GPRS_DATA_BASE);
LoopBuff_Create(&bd_gprsBuff, sizeof(gprs_data_t), FRAM_BD_GPRS_DATA_COUNT, FRAM_GPRS_BD_INFO_BASE, FRAM_GPRS_BD_DATA_BASE);
LoopBuff_Create(&DTU_TaskM, sizeof(uint8_t), DTU_TASKM_DATA_COUNT, 0, (uint32_t) DTU_TaskM_Data);
huart1.RxISR = GPRS_IRQHandler;
huart2.RxISR = GPS_IRQHandler;
/* Peripheral clock enable */
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_USART1);
/* USART1 interrupt Init */
NVIC_SetPriority(USART1_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(),5, 0));
NVIC_EnableIRQ(USART1_IRQn);
USART_InitStruct.BaudRate = 115200;
USART_InitStruct.DataWidth = LL_USART_DATAWIDTH_8B;
USART_InitStruct.StopBits = LL_USART_STOPBITS_1;
USART_InitStruct.Parity = LL_USART_PARITY_NONE;
USART_InitStruct.TransferDirection = LL_USART_DIRECTION_TX_RX;
USART_InitStruct.HardwareFlowControl = LL_USART_HWCONTROL_NONE;
USART_InitStruct.OverSampling = LL_USART_OVERSAMPLING_16;
LL_USART_Init(USART1, &USART_InitStruct);
LL_USART_ConfigAsyncMode(USART1);
SET_BIT(USART1->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
LL_USART_Enable(USART1);
/* 打开GPS端口: GPS和Debug共用一个串口，GPS用到输入，DEBUG用到输出 */
}
// 任务主体：采集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;
gps_data_t gpsData;
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)
if(time >= DTU_gpsTime) // 每次成功定位都修正时间
RTC_offsetSeconds = time - DTU_gpsTime;
if(sample.sateCount >= 4)
{
if(time >= last_time + dcBuff.configData.intervalGPS)
{
last_time = time;
// 如果没有硬件加速度计，则用软件方式判断
if(dcBuff.configDisplay.op_SEND_GPS_DATA && Accelero_ID != ACCELERO_ID)
{
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(dcBuff.configDisplay.op_SEND_GPS_DATA && 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;
// 最近定位成功
dcBuff.dtuData.recentPosState = 1;
if(dcBuff.configDisplay.op_SEND_GPS_DATA)
{
// 加入GPS数据队列，待发送
if(sample.sateCount > 31)
gpsData.sateCount = 31;
else
gpsData.sateCount = sample.sateCount;
gpsData.posState = sample.posState;
gpsData.carState = VCC_POWER_STATUS() ? 1: 0;
gpsData.carEvent = bat_CurrentEvent;
bat_CurrentEvent = 0;
gpsData.time.year = sample.sysTime.year + 2000 - GPS_BASE_YEAR;
gpsData.time.mon = sample.sysTime.month;
gpsData.time.day = sample.sysTime.day;
gpsData.time.hour_H = sample.sysTime.hour >> 4;
gpsData.time.hour_L = sample.sysTime.hour & 0x0F;
gpsData.time.min = sample.sysTime.minute;
gpsData.time.sec = sample.sysTime.second;
gpsData.latitude = sample.latitude;
gpsData.longitude = sample.longitude;
gpsData.speed = sample.speed;
GPS_PutToQueue(&gpsData);
}
else
{
GPS_Located = 1;
// 停止超时定时器
GPS_Waiting = 0;
}
}
}
}
// 清除数据
memset(&sample, 0, sizeof(sample));
}
}
}
// 发送奥扬数据
uint16_t pack_aoyang_send_data(gprs_data_t *pGprs, uint32_t totalSeconds)
{
S_RTC_TIME_DATA_T sRTC;
char field[20];
// 打包上报数据（按modbus从机响应的格式）
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
// PSN
strcat((char *) Task_sendBuff, "{\"i\":");
sprintf(field, "20%02d%02d%02d%02d%03d",
dcBuff.configBottle.PSN[0], dcBuff.configBottle.PSN[1], dcBuff.configBottle.PSN[2],
dcBuff.configBottle.PSN[3], (dcBuff.configBottle.PSN[4] << 8) | dcBuff.configBottle.PSN[5]);
strcat((char *) Task_sendBuff, field);
// 取数时间
strcat((char *) Task_sendBuff, ",\"t\":");
Wakeup_CalcUTCTime(pGprs->sample_time + RTC_offsetSeconds, &sRTC);
sprintf(field, "%04d%02d%02d%02d%02d%02d", sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);
strcat((char *) Task_sendBuff, field);
// 液位高度
strcat((char *) Task_sendBuff, ",\"h\":");
if(pGprs->sampleData.staDPress.status == SENSOR_STATUS_OVERFLOW)
{
// 短路
sprintf(field, "%d", -1);
}
else if(pGprs->sampleData.staDPress.status == SENSOR_STATUS_NOCONNECT
|| pGprs->sampleData.staDPress.status == SENSOR_STATUS_UNDERFLOW)
{
// 断路
sprintf(field, "%d", -2);
}
else
sprintf(field, "%d", (uint16_t) pGprs->sampleData.height);
strcat((char *) Task_sendBuff, field);
// 液体体积
strcat((char *) Task_sendBuff, ",\"v\":");
if(pGprs->sampleData.staDPress.status == SENSOR_STATUS_NOCONNECT
|| pGprs->sampleData.staDPress.status == SENSOR_STATUS_OVERFLOW
|| pGprs->sampleData.staDPress.status == SENSOR_STATUS_UNDERFLOW)
{
// 故障
sprintf(field, "%d", -1);
}
else
sprintf(field, "%d", pGprs->sampleData.volume);
strcat((char *) Task_sendBuff, field);
// 气瓶压力
strcat((char *) Task_sendBuff, ",\"p\":");
if(pGprs->sampleData.staPress.status == SENSOR_STATUS_OVERFLOW)
{
// 短路
sprintf(field, "%d", -1);
}
else if(pGprs->sampleData.staPress.status == SENSOR_STATUS_NOCONNECT
|| pGprs->sampleData.staPress.status == SENSOR_STATUS_UNDERFLOW)
{
// 断路
sprintf(field, "%d", -2);
}
else
{
// 压力：KPa->MPa
sprintf(field, "%f", pGprs->sampleData.pressure * 0.001);
}
strcat((char *) Task_sendBuff, field);
// 经度
strcat((char *) Task_sendBuff, ",\"x\":");
if(!pGprs->dtuData.recentPosState || pGprs->dtuData.longitude == 0)
sprintf(field, "%d", 200);
else
sprintf(field, "%.6f", pGprs->dtuData.longitude * 0.000001);
strcat((char *) Task_sendBuff, field);
// 纬度
strcat((char *) Task_sendBuff, ",\"y\":");
if(!pGprs->dtuData.recentPosState || pGprs->dtuData.latitude == 0)
sprintf(field, "%d", 200);
else
sprintf(field, "%.6f", pGprs->dtuData.latitude * 0.000001);
strcat((char *) Task_sendBuff, field);
//结束符，多发送一个换行符('\n')
strcat((char *) Task_sendBuff, "}\n");
return strlen((char *) Task_sendBuff);
}
// 发送巴西数据
uint16_t pack_brasil_send_data(gprs_data_t *pGprs, uint32_t totalSeconds)
{
S_RTC_TIME_DATA_T sRTC;
char field[40];
// 打包上报数据（按modbus从机响应的格式）
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
// PSN
strcat((char *) Task_sendBuff, "{\"psn\":");
sprintf(field, "\"20%02d%02d%02d%02d%03d\"",
dcBuff.configBottle.PSN[0], dcBuff.configBottle.PSN[1], dcBuff.configBottle.PSN[2],
dcBuff.configBottle.PSN[3], (dcBuff.configBottle.PSN[4] << 8) | dcBuff.configBottle.PSN[5]);
strcat((char *) Task_sendBuff, field);
// 取数时间
strcat((char *) Task_sendBuff, ",\"time\":");
Wakeup_CalcUTCTime(pGprs->sample_time + RTC_offsetSeconds, &sRTC);
sprintf(field, "\"%04d%02d%02d%02d%02d%02d\"", sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);
strcat((char *) Task_sendBuff, field);
// 差压
strcat((char *) Task_sendBuff, ",\"dp\":");
if(pGprs->sampleData.staDPress.status == SENSOR_STATUS_NOCONNECT
|| pGprs->sampleData.staDPress.status == SENSOR_STATUS_OVERFLOW
|| pGprs->sampleData.staDPress.status == SENSOR_STATUS_UNDERFLOW)
{
// 故障
sprintf(field, "%d", -300);
}
else
{
// mmWC
sprintf(field, "%.0f", KPa2mmH2O(pGprs->sampleData.diff));
}
strcat((char *) Task_sendBuff, field);
// 容积百分比
strcat((char *) Task_sendBuff, ",\"pct\":");
if(pGprs->sampleData.staDPress.status == SENSOR_STATUS_NOCONNECT
|| pGprs->sampleData.staDPress.status == SENSOR_STATUS_OVERFLOW
|| pGprs->sampleData.staDPress.status == SENSOR_STATUS_UNDERFLOW)
{
// 故障
sprintf(field, "%d", 0);
}
else
{
// %
sprintf(field, "%.1f", pGprs->sampleData.volumePct * 0.01);
}
strcat((char *) Task_sendBuff, field);
// 液体体积
strcat((char *) Task_sendBuff, ",\"v\":");
if(pGprs->sampleData.staDPress.status == SENSOR_STATUS_NOCONNECT
|| pGprs->sampleData.staDPress.status == SENSOR_STATUS_OVERFLOW
|| pGprs->sampleData.staDPress.status == SENSOR_STATUS_UNDERFLOW)
{
// 故障
sprintf(field, "%d", 0);
}
else
{
// L
sprintf(field, "%d", pGprs->sampleData.volume);
}
strcat((char *) Task_sendBuff, field);
// 压力
strcat((char *) Task_sendBuff, ",\"p\":");
if(pGprs->sampleData.staPress.status == SENSOR_STATUS_NOCONNECT
|| pGprs->sampleData.staPress.status == SENSOR_STATUS_OVERFLOW
|| pGprs->sampleData.staPress.status == SENSOR_STATUS_UNDERFLOW)
{
// 故障
sprintf(field, "%d", -300);
}
else
{
// 压力：KPa->MPa
sprintf(field, "%.2f", pGprs->sampleData.pressure * 0.001);
}
strcat((char *) Task_sendBuff, field);
// 温度
strcat((char *) Task_sendBuff, ",\"t\":");
if(pGprs->sampleData.staExtTempr[0].status == SENSOR_STATUS_NOCONNECT
|| pGprs->sampleData.staExtTempr[0].status == SENSOR_STATUS_OVERFLOW
|| pGprs->sampleData.staExtTempr[0].status == SENSOR_STATUS_UNDERFLOW)
{
// 故障
sprintf(field, "%d", -300);
}
else
{
// 温度：℃
sprintf(field, "%d", pGprs->sampleData.extTempr[0]);
}
strcat((char *) Task_sendBuff, field);
// 经度
strcat((char *) Task_sendBuff, ",\"x\":");
if(!pGprs->dtuData.recentPosState || pGprs->dtuData.longitude == 0)
sprintf(field, "%d", -300);
else
sprintf(field, "%.6f", pGprs->dtuData.longitude * 0.000001);
strcat((char *) Task_sendBuff, field);
// 纬度
strcat((char *) Task_sendBuff, ",\"y\":");
if(!pGprs->dtuData.recentPosState || pGprs->dtuData.latitude == 0)
sprintf(field, "%d", -300);
else
sprintf(field, "%.6f", pGprs->dtuData.latitude * 0.000001);
strcat((char *) Task_sendBuff, field);
// APN
strcat((char *) Task_sendBuff, ",\"apn\":");
sprintf(field, "\"%s\"", dcBuff.configDisplay.APN);
strcat((char *) Task_sendBuff, field);
// APN-User
strcat((char *) Task_sendBuff, ",\"user\":");
sprintf(field, "\"%s\"", dcBuff.configDisplay.User);
strcat((char *) Task_sendBuff, field);
// APN-Pwd
strcat((char *) Task_sendBuff, ",\"pwd\":");
sprintf(field, "\"%s\"", dcBuff.configDisplay.Pwd);
strcat((char *) Task_sendBuff, field);
// sim card
strcat((char *) Task_sendBuff, ",\"sim\":");
sprintf(field, "\"%s\"", dcBuff.powerInfo.simNumber);
strcat((char *) Task_sendBuff, field);
// type
strcat((char *) Task_sendBuff, ",\"type\":");
sprintf(field, "%d", dcBuff.configBottle.type);
strcat((char *) Task_sendBuff, field);
// diameter
strcat((char *) Task_sendBuff, ",\"dia\":");
sprintf(field, "%d", dcBuff.configBottle.diameter);
strcat((char *) Task_sendBuff, field);
// len
strcat((char *) Task_sendBuff, ",\"len\":");
sprintf(field, "%d", dcBuff.configBottle.len + dcBuff.configBottle.lenExtra);
strcat((char *) Task_sendBuff, field);
// liquid
strcat((char *) Task_sendBuff, ",\"liquid\":");
sprintf(field, "%d", dcBuff.configBottle.source);
strcat((char *) Task_sendBuff, field);
// density
strcat((char *) Task_sendBuff, ",\"density\":");
sprintf(field, "%d", (uint16_t) (Config_GetDensity(dcBuff.configBottle.source) * 1000));
strcat((char *) Task_sendBuff, field);
// send
strcat((char *) Task_sendBuff, ",\"send\":");
sprintf(field, "%d", dcBuff.configData.intervalTrans);
strcat((char *) Task_sendBuff, field);
// save
strcat((char *) Task_sendBuff, ",\"save\":");
sprintf(field, "%d", dcBuff.configData.intervalSample);
strcat((char *) Task_sendBuff, field);
// level1
strcat((char *) Task_sendBuff, ",\"level1\":");
sprintf(field, "%.2f", dcBuff.configBottle.priPct * 0.01);
strcat((char *) Task_sendBuff, field);
// level2
strcat((char *) Task_sendBuff, ",\"level2\":");
sprintf(field, "%.2f", dcBuff.configBottle.orderPct * 0.01);
strcat((char *) Task_sendBuff, field);
// level3
strcat((char *) Task_sendBuff, ",\"level3\":");
sprintf(field, "%.2f", dcBuff.configBottle.emptyPct * 0.01);
strcat((char *) Task_sendBuff, field);
// server
strcat((char *) Task_sendBuff, ",\"server\":");
sprintf(field, "\"%s\"", dcBuff.configData.server);
strcat((char *) Task_sendBuff, field);
// port
strcat((char *) Task_sendBuff, ",\"port\":");
sprintf(field, "%d", dcBuff.configData.port);
strcat((char *) Task_sendBuff, field);
//结束符，多发送一个换行符('\n')
strcat((char *) Task_sendBuff, "}\n");
return strlen((char *) Task_sendBuff);
}
// 解析巴西数据
int parse_brasil_recv_data(char *recv, gprs_data_t *pGprs, uint32_t totalSeconds)
{
char *src = recv;
char psn[14], time[15];
S_RTC_TIME_DATA_T sRTC;
uint8_t i;
uint8_t psnMatch = 0, timeMatch = 0;
if(!JSON_Parse_Record(&src))
return 0;
for(i = 0; i < JSON_FIELD_COUNT; i++)
{
if(JSON_Record[i].type == JSON_TYPE_NULL)
continue;
if(JSON_Record[i].type == JSON_TYPE_INTEGER)
printf("%s\t%s\t%ld\n", JSON_Record[i].name, "INTEGER", JSON_Record[i].i);
else if(JSON_Record[i].type == JSON_TYPE_FLOAT)
printf("%s\t%s\t%f\n", JSON_Record[i].name, "FLOAT", JSON_Record[i].f);
else
printf("%s\t%s\t%s\n", JSON_Record[i].name, "STRING", JSON_Record[i].s);
}
// PSN
sprintf(psn, "20%02d%02d%02d%02d%03d",
dcBuff.configBottle.PSN[0], dcBuff.configBottle.PSN[1], dcBuff.configBottle.PSN[2],
dcBuff.configBottle.PSN[3], (dcBuff.configBottle.PSN[4] << 8) | dcBuff.configBottle.PSN[5]);
// 取数时间
Wakeup_CalcUTCTime(pGprs->sample_time + RTC_offsetSeconds, &sRTC);
sprintf(time, "%04d%02d%02d%02d%02d%02d", sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);
// 检查PSN和数据时间
for(int i = 0; i < JSON_FIELD_COUNT; i++)
{
if(JSON_Record[i].type == JSON_TYPE_NULL)
continue;
if(strcmp(JSON_Record[i].name, "psn") == 0 && strcmp(psn, JSON_Record[i].s) == 0)
{
psnMatch = 1;
}
if(strcmp(JSON_Record[i].name, "time") == 0 && strcmp(time, JSON_Record[i].s) == 0)
{
timeMatch = 1;
}
}
if(psnMatch && timeMatch)
return 1;
printf("psn or time NOT matched\n");
return 0;
}
int save_brasil_issue_parameters()
{
uint8_t i;
int ret = 0;
uint16_t f2i;
for(i = 0; i < JSON_FIELD_COUNT; i++)
{
if(JSON_Record[i].type == JSON_TYPE_NULL)
continue;
if(strcmp(JSON_Record[i].name, "apn") == 0)
{
if(strlen(JSON_Record[i].s) >= 1 && strlen(JSON_Record[i].s) <= 23
&& strcmp(dcBuff.configDisplay.APN, JSON_Record[i].s) != 0)
{
printf("change apn to: %s\n", JSON_Record[i].s);
strcpy(dcBuff.configDisplay.APN, JSON_Record[i].s);
ret++;
}
}
else if(strcmp(JSON_Record[i].name, "user") == 0)
{
if(strlen(JSON_Record[i].s) <= 9
&& strcmp(dcBuff.configDisplay.User, JSON_Record[i].s) != 0)
{
printf("change user to: %s\n", JSON_Record[i].s);
strcpy(dcBuff.configDisplay.User, JSON_Record[i].s);
ret++;
}
}
else if(strcmp(JSON_Record[i].name, "pwd") == 0)
{
if(strlen(JSON_Record[i].s) <= 9
&& strcmp(dcBuff.configDisplay.Pwd, JSON_Record[i].s) != 0)
{
printf("change pwd to: %s\n", JSON_Record[i].s);
strcpy(dcBuff.configDisplay.Pwd, JSON_Record[i].s);
ret++;
}
}
else if(strcmp(JSON_Record[i].name, "type") == 0)
{
if(JSON_Record[i].i >= 0 && JSON_Record[i].i <= 1
&& dcBuff.configBottle.type != JSON_Record[i].i)
{
printf("change type to: %ld\n", JSON_Record[i].i);
dcBuff.configBottle.type = JSON_Record[i].i;
ret++;
}
}
else if(strcmp(JSON_Record[i].name, "dia") == 0)
{
if(JSON_Record[i].i >= 1 && JSON_Record[i].i <= 99999
&& dcBuff.configBottle.diameter != JSON_Record[i].i)
{
printf("change dia to: %ld\n", JSON_Record[i].i);
dcBuff.configBottle.diameter = JSON_Record[i].i;
ret++;
}
}
else if(strcmp(JSON_Record[i].name, "len") == 0)
{
if(JSON_Record[i].i >= 1 && JSON_Record[i].i <= 99999
&& dcBuff.configBottle.len != JSON_Record[i].i)
{
printf("change len to: %ld\n", JSON_Record[i].i);
dcBuff.configBottle.len = JSON_Record[i].i;
dcBuff.configBottle.lenExtra = 0;
ret++;
}
}
else if(strcmp(JSON_Record[i].name, "liquid") == 0)
{
if(JSON_Record[i].i >= 0 && JSON_Record[i].i <= 4
&& dcBuff.configBottle.source != JSON_Record[i].i)
{
printf("change liquid to: %ld\n", JSON_Record[i].i);
dcBuff.configBottle.source = JSON_Record[i].i;
ret++;
}
}
else if(strcmp(JSON_Record[i].name, "send") == 0)
{
if(JSON_Record[i].i >= 300 && JSON_Record[i].i <= 86400
&& dcBuff.configData.intervalTrans != JSON_Record[i].i)
{
printf("change send to: %ld\n", JSON_Record[i].i);
dcBuff.configData.intervalTrans = JSON_Record[i].i;
ret++;
}
}
else if(strcmp(JSON_Record[i].name, "save") == 0)
{
if(JSON_Record[i].i >= 300 && JSON_Record[i].i <= 86400
&& dcBuff.configData.intervalSample != JSON_Record[i].i)
{
printf("change save to: %ld\n", JSON_Record[i].i);
dcBuff.configData.intervalSample = JSON_Record[i].i;
ret++;
}
}
else if(strcmp(JSON_Record[i].name, "level1") == 0)
{
f2i = (uint16_t) (JSON_Record[i].f * 100);
if(f2i >= 0 && f2i <= 100 * 100
&& dcBuff.configBottle.priPct != f2i)
{
printf("change level1 to: %f\n", JSON_Record[i].f);
dcBuff.configBottle.priPct = f2i;
ret++;
}
}
else if(strcmp(JSON_Record[i].name, "level2") == 0)
{
f2i = (uint16_t) (JSON_Record[i].f * 100);
if(f2i >= 0 && f2i <= 100 * 100
&& dcBuff.configBottle.orderPct != f2i)
{
printf("change level2 to: %f\n", JSON_Record[i].f);
dcBuff.configBottle.orderPct = f2i;
ret++;
}
}
else if(strcmp(JSON_Record[i].name, "level3") == 0)
{
f2i = (uint16_t) (JSON_Record[i].f * 100);
if(f2i >= 0 && f2i <= 100 * 100
&& dcBuff.configBottle.emptyPct != f2i)
{
printf("change level3 to: %f\n", JSON_Record[i].f);
dcBuff.configBottle.emptyPct = f2i;
ret++;
}
}
else if(strcmp(JSON_Record[i].name, "server") == 0)
{
if(strlen(JSON_Record[i].s) >= 1 && strlen(JSON_Record[i].s) <= 29
&& strcmp(dcBuff.configData.server, JSON_Record[i].s) != 0)
{
printf("change server to: %s\n", JSON_Record[i].s);
strcpy(dcBuff.configData.server, JSON_Record[i].s);
ret++;
}
}
else if(strcmp(JSON_Record[i].name, "port") == 0)
{
if(JSON_Record[i].i >= 0 && JSON_Record[i].i <= 65535
&& dcBuff.configData.port != JSON_Record[i].i)
{
printf("change port to: %ld\n", JSON_Record[i].i);
dcBuff.configData.port = JSON_Record[i].i;
ret++;
}
}
}
// 最后再修改密度（因为要先确定介质）
for(i = 0; i < JSON_FIELD_COUNT; i++)
{
if(JSON_Record[i].type == JSON_TYPE_NULL)
continue;
if(strcmp(JSON_Record[i].name, "density") == 0)
{
f2i = (uint16_t) (Config_GetDensity(dcBuff.configBottle.source) * 1000);
if(JSON_Record[i].i >= 1 && JSON_Record[i].i <= 9999
&& f2i != JSON_Record[i].i)
{
printf("change density to: %ld\n", JSON_Record[i].i);
Config_SetDensity(dcBuff.configBottle.source, JSON_Record[i].i * 0.001);
ret++;
}
}
}
if(ret > 0)
{
printf("changed %d parameters\n", ret);
return 1;
}
return 0;
}
uint8_t pack_gprs_send_data(gprs_data_t *pGprs, uint32_t totalSeconds)
{
uint8_t i;
bluetooth_sensor_t *pSensor;
bluetooth_mask_t *pMask;
uint32_t relativeTime;
S_RTC_TIME_DATA_T sRTC;
uint16_t crc;
// 打包上报数据（按modbus从机响应的格式）
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
i = 0;
// PSN
memmove(Task_sendBuff + i, dcBuff.configBottle.PSN, 6);
printf("\nSend PSN: 20%02d%02d%02d%02d%03d\n", Task_sendBuff[i], Task_sendBuff[i + 1], Task_sendBuff[i + 2],
Task_sendBuff[i+3], (Task_sendBuff[i + 4] << 8) | Task_sendBuff[i + 5]);
i += 6;
// 功能码
Task_sendBuff[i++] = 0x10;
// 数据长度：先预设为0，最后再修改，位置为Task_sendBuff[7]
Task_sendBuff[i++] = 0;
// 当前差压值
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.diff));
i +=2 ;
// 容积百分比
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.volumePct));
i += 2;
// 当前容积
Int2ByteL(Task_sendBuff, i, htonl(pGprs->sampleData.volume));
i += 4;
// 重量
Int2ByteL(Task_sendBuff, i, htonl(pGprs->sampleData.weight));
i += 4;
// 高度：mmWC
if(!dcBuff.configDisplay.op_USE_CAPACITY_SENSOR && !dcBuff.configDisplay.op_USE_HEIGHT_LEVEL && !dcBuff.configDisplay.op_USE_PCT_LEVEL)
Int2ByteS(Task_sendBuff, i, htons((uint16_t) KPa2mmH2O(pGprs->sampleData.diff)));
else
Int2ByteS(Task_sendBuff, i, htons((uint16_t) pGprs->sampleData.height));
i += 2;
// 压力
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.pressure));
i += 2;
#if 0
// 温度
Int2ByteS(Task_sendBuff, i, htons(pGprs->dtuData.batTempr);
#else
// 用温度表示自启动以来的时间分钟数，32767分钟
Int2ByteS(Task_sendBuff, i, htons((totalSeconds % 1966080ul) / 60));
#endif
i += 2;
// 液源
if(dcBuff.configBottle.source >= SOURCE_LNG && dcBuff.configBottle.source <= SOURCE_POPO)
Task_sendBuff[i] = dcBuff.configBottle.source;
i++;
// 储罐类型
if(dcBuff.configBottle.type == BOTTLE_TYPE_STAND)
Task_sendBuff[i] = 0;
else if(dcBuff.configBottle.type == BOTTLE_TYPE_LYING)
Task_sendBuff[i] = 1;
else if(dcBuff.configBottle.type == BOTTLE_TYPE_SPHERICAL)
Task_sendBuff[i] = 2;
i++;
// 故障码
pSensor = (bluetooth_sensor_t *) (Task_sendBuff + i);
pSensor->staDiff = Bluetooth_ConvertStat(&pGprs->sampleData.staDPress);
pSensor->staPress = Bluetooth_ConvertStat(&pGprs->sampleData.staPress);
pSensor->staEPress1 = Bluetooth_ConvertStat(&pGprs->sampleData.staExtPress[0]);
pSensor->staEPress2 = Bluetooth_ConvertStat(&pGprs->sampleData.staExtPress[1]);
pSensor->staEPress3 = Bluetooth_ConvertStat(&pGprs->sampleData.staExtPress[2]);
pSensor->staETempr1 = Bluetooth_ConvertStat(&pGprs->sampleData.staExtTempr[0]);
pSensor->staETempr2 = Bluetooth_ConvertStat(&pGprs->sampleData.staExtTempr[1]);
pSensor->staETempr3 = Bluetooth_ConvertStat(&pGprs->sampleData.staExtTempr[2]);
i += 2;
// 传感器状态
pMask = (bluetooth_mask_t *) (Task_sendBuff + i);
memset(pMask, 0xFF, 2);
pMask->maskFlow = 1;
pMask->maskLowPower = pGprs->dtuData.batLow;
pMask->maskAbnormal = 0;
pMask->maskCharging = pGprs->sampleData.charging;
i += 2;
// 版本号
Task_sendBuff[i++] = dcBuff.powerInfo.protocolVer.minor;
// rssi
Task_sendBuff[i++] = pGprs->dtuData.rssi;
if(pMask->maskGPS)
{
// 经度
if(pGprs->dtuData.recentPosState)
Int2ByteL(Task_sendBuff, i, htonl(pGprs->dtuData.longitude));
i += 4;
// 纬度
if(pGprs->dtuData.recentPosState)
Int2ByteL(Task_sendBuff, i, htonl(pGprs->dtuData.latitude));
i += 4;
}
// 扩展温度
if(pMask->maskETempr1)
{
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.extTempr[0]));
i += 2;
}
if(pMask->maskETempr2)
{
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.extTempr[1]));
i += 2;
}
if(pMask->maskETempr3)
{
#if 0
// 扩展温度3
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.extTempr[2]));
#else
// 用扩展温度3表示硬件配置
Int2ByteS(Task_sendBuff, i, htons(dcBuff.powerInfo.hardVer.major));
#endif
i += 2;
}
// 电池信息
if(pMask->maskBattery)
{
// 电量百分比
Int2ByteS(Task_sendBuff, i, htons(pGprs->dtuData.batPct));
i += 2;
// 电池内部温度
Int2ByteS(Task_sendBuff, i, htons(pGprs->dtuData.batTempr));
i += 2;
// 电池当前电压
Int2ByteS(Task_sendBuff, i, htons(pGprs->dtuData.batVoltage / 10));
i += 2;
// 电池容量
Int2ByteS(Task_sendBuff, i, htons(pGprs->dtuData.batMaxCapa));
i += 2;
// 电池当前容量
Int2ByteS(Task_sendBuff, i, htons(pGprs->dtuData.batCapa));
i += 2;
#if 0
// 充电电流，电流的符号表示充放电状态
Int2ByteS(Task_sendBuff, i, htons(pGprs->dtuData.batCurrent));
#else
// 用电流的绝对值表示复位原因
// 1-POR, 2-PIN, 4-WDT, 8-LVR, 16-BOD, 32-SYS, 128-CPU, 256-CPULK
Int2ByteS(Task_sendBuff, i, htons(pGprs->dtuData.batCurrent > 0 ? SYS_RSTSTS : -SYS_RSTSTS));
#endif
i += 2;
// 光照强度
Int2ByteS(Task_sendBuff, i, htons(pGprs->dtuData.sunLevel));
i += 2;
}
// 流量计
if(pMask->maskFlow)
{
// 天信MODBUS /A1 通信协议 (BCD码）
// 标况体积总量
memmove(Task_sendBuff + i, pGprs->sampleData.flow.nM3, 6);
i += 6;
// 标况流量
memmove(Task_sendBuff + i, pGprs->sampleData.flow.nM3_h, 4);
i += 4;
// 工况流量
memmove(Task_sendBuff + i, pGprs->sampleData.flow.M3_h, 4);
i += 4;
// 温度
memmove(Task_sendBuff + i, pGprs->sampleData.flow.tempr, 4);
i += 4;
// 压力
memmove(Task_sendBuff + i, pGprs->sampleData.flow.pressure, 4);
i += 4;
}
// 泄露报警
if(pMask->maskLeak)
{
// 类型
Task_sendBuff[i++] = pGprs->sampleData.leak.typeLeak;
// 状态、报警浓度
if(pGprs->sampleData.leak.staLeak == LEAK_STATUS_FAULT || pGprs->sampleData.leak.staLeak == LEAK_STATUS_COMM_FAULT)
Task_sendBuff[i] = 0x80;
else
Task_sendBuff[i] = (pGprs->sampleData.leak.concentrations & 0x7F);
i++;
}
if(pMask->maskStamp)
{
if(dcBuff.powerInfo.protocolVer.minor == 107)
{
// 获取当前时间
RTC_GetDateAndTime(&sRTC);
// 计算自上次gps定位以来的时间
relativeTime = Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second) - pGprs->sample_time;
Int2ByteL(Task_sendBuff, i, htonl(relativeTime));
}
// 时间
i += 4;
// 年月日
i += 4;
}
// 扩展压力
if(pMask->maskEPress1)
{
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.extPressure[0]));
i += 2;
}
if(pMask->maskEPress2)
{
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.extPressure[1]));
i += 2;
}
if(pMask->maskEPress3)
{
#if 0
// 扩展压力3
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.extPressure[2]));
#else
// 上传GPS调试信息: 闪断次数*100+卫星数
// 如2105表示闪断21次，卫星数5颗
Int2ByteS(Task_sendBuff, i, htons(GPS_BOD_COUNT * 100 + pGprs->dtuData.sateCount));
printf("\nGPS_DEBUG_VAL: %d\n", ntohs(Byte2IntS(Task_sendBuff, i)));
#endif
i += 2;
}
printf("\ndcBuff.powerInfo.hardVer.major = %d, dcBuff.powerInfo.softVer.minor = %d\n",
dcBuff.powerInfo.hardVer.major, dcBuff.powerInfo.softVer.minor);
// 硬件版本
//Task_sendBuff[i++] = ((dcBuff.powerInfo.hardVer.minor / 10) << 4) + dcBuff.powerInfo.hardVer.minor % 10;
Task_sendBuff[i++] = dcBuff.powerInfo.hardVer.minor;
// 软件版本
//Task_sendBuff[i++] = ((dcBuff.powerInfo.softVer.minor / 10) << 4) + dcBuff.powerInfo.softVer.minor % 10;;
Task_sendBuff[i++] = dcBuff.powerInfo.softVer.minor;
// 真空传感器1
if(pGprs->sampleData.vacuum[0].staVacuum == VACUUM_STATUS_FAULT || pGprs->sampleData.vacuum[0].staVacuum == VACUUM_STATUS_COMM_FAULT)
Int2ByteS(Task_sendBuff, i, htons(0));
else
Int2ByteS(Task_sendBuff, i, htons(1));
i += 2;
// 使用年限
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.vacuum[0].lifeVacuum));
i += 2;
// 真空度
Int2ByteL(Task_sendBuff, i, htonl(pGprs->sampleData.vacuum[0].vacuum * 100));
i += 4;
// 漏放气速率
Int2ByteL(Task_sendBuff, i, htonl(pGprs->sampleData.vacuum[0].rateVacuum * 100));
i += 4;
// 船级社维持时间
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.ccsRemainDay));
i += 2;
// 算法版本
Int2ByteL(Task_sendBuff, i, htonl(pGprs->sampleData.ccsVer));
i += 4;
// 保留
i += 2;
// 保留
i += 4;
// 气瓶容量
Int2ByteL(Task_sendBuff, i, htonl(pGprs->sampleData.volumeTotal));
i += 4;
// 储罐封头直边长
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.lenExtra));
i += 2;
// 储罐筒长度
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.len));
i += 4;
// 储罐直径
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.diameter));
i += 4;
// 自动发送频率
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configData.intervalTrans / 60));
i += 2;
// 自动发送短信频率（实际发送采集频率）
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configData.intervalSample / 60));
i += 2;
// 修改数据长度
Task_sendBuff[7] = i - 8;
// 校验码
crc = MODBUS_RTU_CRC16((uint8_t *) Task_sendBuff, i);
Int2ByteS(Task_sendBuff, i, htons(crc));
i += 2;
// 结束符
Task_sendBuff[i++] = 0x0d;
Task_sendBuff[i++] = 0x0a;
return i;
}
uint8_t pack_furui_send_data(gprs_data_t *pGprs, uint32_t *relativeTime)
{
uint8_t i;
uint32_t uVal32;
S_RTC_TIME_DATA_T sRTC;
uint16_t crc;
// 打包上报数据（按modbus从机响应的格式）
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
i = 0;
// 起始符
Task_sendBuff[i++] = 0x4C;
// 总长度：先预设为0，最后再修改，位置为Task_sendBuff[1]
Task_sendBuff[i++] = 0;
// 协议版本
Task_sendBuff[i++] = 1;
// 硬件版本
Task_sendBuff[i++] = dcBuff.powerInfo.hardVer.minor;
// 软件版本
Task_sendBuff[i++] = dcBuff.powerInfo.softVer.minor;
// PSN
memmove(Task_sendBuff + i, dcBuff.configBottle.PSN, 6);
printf("\nSend PSN: 20%02d%02d%02d%02d%03d\n", Task_sendBuff[i], Task_sendBuff[i + 1], Task_sendBuff[i + 2],
Task_sendBuff[i+3], (Task_sendBuff[i + 4] << 8) | Task_sendBuff[i + 5]);
i += 6;
// 时间戳
RTC_GetDateAndTime(&sRTC);
*relativeTime = Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second) - pGprs->sample_time;
Int2ByteL(Task_sendBuff, i, htonl(*relativeTime));
i += 4;
// 传感器状态
uVal32 = 0xFFFFFFFFul;
// 连接状态
if(!pGprs->sampleData.staDPress.notConnect)
uVal32 &= ~(1ul << 0);
if(!pGprs->sampleData.staPress.notConnect)
uVal32 &= ~(1ul << 1);
if(!pGprs->sampleData.staExtPress[0].notConnect)
uVal32 &= ~(1ul << 2);
if(!pGprs->sampleData.staExtTempr[0].notConnect)
uVal32 &= ~(1ul << 3);
if(!pGprs->sampleData.staExtTempr[1].notConnect)
uVal32 &= ~(1ul << 4);
if(!(pGprs->sampleData.vacuum[0].staVacuum == VACUUM_STATUS_COMM_FAULT))
uVal32 &= ~(1ul << 5);
if(1) // 流量计
uVal32 &= ~(1ul << 6);
if(!(pGprs->sampleData.leak.staLeak == LEAK_STATUS_COMM_FAULT))
uVal32 &= ~(1ul << 7);
// 故障状态
if(!(pGprs->sampleData.staDPress.overFlow || pGprs->sampleData.staDPress.underFlow))
uVal32 &= ~(1ul << 8);
if(!(pGprs->sampleData.staPress.overFlow || pGprs->sampleData.staPress.underFlow))
uVal32 &= ~(1ul << 9);
if(!(pGprs->sampleData.staExtPress[0].overFlow || pGprs->sampleData.staExtPress[0].underFlow))
uVal32 &= ~(1ul << 10);
if(!(pGprs->sampleData.staExtTempr[0].overFlow || pGprs->sampleData.staExtTempr[0].underFlow))
uVal32 &= ~(1ul << 11);
if(!(pGprs->sampleData.staExtTempr[1].overFlow || pGprs->sampleData.staExtTempr[1].underFlow))
uVal32 &= ~(1ul << 12);
if(!(pGprs->sampleData.vacuum[0].staVacuum == VACUUM_STATUS_FAULT))
uVal32 &= ~(1ul << 13);
if(1) // 流量计
uVal32 &= ~(1ul << 14);
if(!(pGprs->sampleData.leak.staLeak == LEAK_STATUS_FAULT))
uVal32 &= ~(1ul << 15);
Int2ByteL(Task_sendBuff, i, htonl(uVal32));
i += 4;
// 当前差压值：mmWC
if(!dcBuff.configDisplay.op_USE_CAPACITY_SENSOR && !dcBuff.configDisplay.op_USE_HEIGHT_LEVEL && !dcBuff.configDisplay.op_USE_PCT_LEVEL)
Int2ByteS(Task_sendBuff, i, htons((uint16_t) KPa2mmH2O(pGprs->sampleData.diff)));
else
Int2ByteS(Task_sendBuff, i, htons((uint16_t) pGprs->sampleData.height));
i +=2 ;
// 容积百分比
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.volumePct));
i += 2;
// 当前容积
Int2ByteL(Task_sendBuff, i, htonl(pGprs->sampleData.volume));
i += 4;
// 重量
Int2ByteL(Task_sendBuff, i, htonl(pGprs->sampleData.weight));
i += 4;
// 气瓶容量
Int2ByteL(Task_sendBuff, i, htonl(pGprs->sampleData.volumeTotal));
i += 4;
// 压力1
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.pressure));
i += 2;
// 压力2
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.extPressure[0]));
i += 2;
// 温度1
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.extTempr[0]));
i += 2;
// 温度2
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.extTempr[1]));
i += 2;
// 真空度
Int2ByteS(Task_sendBuff, i, htons((uint16_t) (pGprs->sampleData.vacuum[0].vacuum * 100)));
i += 2;
// 真空计温度
Int2ByteS(Task_sendBuff, i, htons((int16_t) pGprs->sampleData.vacuum[0].tempr));
i += 2;
// 天信MODBUS /A1 通信协议 (BCD码）
// 标况体积总量
memmove(Task_sendBuff + i, pGprs->sampleData.flow.nM3, 6);
i += 6;
// 标况流量
memmove(Task_sendBuff + i, pGprs->sampleData.flow.nM3_h, 4);
i += 4;
// 工况流量
memmove(Task_sendBuff + i, pGprs->sampleData.flow.M3_h, 4);
i += 4;
// 流量计温度
memmove(Task_sendBuff + i, pGprs->sampleData.flow.tempr, 4);
i += 4;
// 流量计压力
memmove(Task_sendBuff + i, pGprs->sampleData.flow.pressure, 4);
i += 4;
// 泄露状态
Task_sendBuff[i++] = (pGprs->sampleData.leak.staLeak == LEAK_STATUS_A2_ALARM ? 1 : 0);
// 经度
if(pGprs->dtuData.recentPosState)
Int2ByteL(Task_sendBuff, i, htonl(pGprs->dtuData.longitude));
i += 4;
// 纬度
if(pGprs->dtuData.recentPosState)
Int2ByteL(Task_sendBuff, i, htonl(pGprs->dtuData.latitude));
i += 4;
// rssi
Task_sendBuff[i++] = pGprs->dtuData.rssi;
// 电量百分比
Task_sendBuff[i++] = pGprs->dtuData.batPct;
// 电池当前电压
Int2ByteS(Task_sendBuff, i, htons(pGprs->dtuData.batVoltage / 10));
i += 2;
// 供电状态
Task_sendBuff[i++] = (pGprs->dtuData.batCurrent < 0 ? -1 : 1);
// 液源
if(dcBuff.configBottle.source >= SOURCE_LNG && dcBuff.configBottle.source <= SOURCE_POPO)
Task_sendBuff[i] = dcBuff.configBottle.source;
i++;
// 密度
Int2ByteS(Task_sendBuff, i, htons(Config_GetDensity(dcBuff.configBottle.source) * 1000));
i += 2;
// 储罐类型
if(dcBuff.configBottle.type == BOTTLE_TYPE_STAND)
Task_sendBuff[i] = 0;
else if(dcBuff.configBottle.type == BOTTLE_TYPE_LYING)
Task_sendBuff[i] = 1;
else if(dcBuff.configBottle.type == BOTTLE_TYPE_SPHERICAL)
Task_sendBuff[i] = 2;
i++;
// 储罐直径
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.diameter));
i += 4;
// 储罐筒长度
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.len + dcBuff.configBottle.lenExtra * 2));
i += 4;
// 采集周期
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configData.intervalSample));
i += 4;
// 发送周期
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configData.intervalTrans));
i += 4;
// 满液位百分比
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.warnPressH));
i += 2;
// 压力报警下限
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnPress));
i += 2;
// 温度报警上限
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnTemprH));
i += 2;
// 温度报警下限
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnTempr));
i += 2;
// 真空度报警上限
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnVacuumH));
i += 2;
// 显示控制
Task_sendBuff[i++] = dcBuff.configBottle.dispMode;
// 修改数据长度
Task_sendBuff[1] = i - 1 + 2;
// 校验码
crc = MODBUS_RTU_CRC16(Task_sendBuff + 1, i - 1);
Int2ByteS(Task_sendBuff, i, htons(crc));
i += 2;
// 结束符
Task_sendBuff[i++] = 0x53;
return i;
}
uint8_t pack_huida_send_data(gprs_data_t *pGprs, uint32_t *relativeTime)
{
uint8_t i;
uint32_t uVal32;
S_RTC_TIME_DATA_T sRTC;
uint16_t crc;
// 打包上报数据（按modbus从机响应的格式）
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
i = 0;
// 起始符
Task_sendBuff[i++] = 0x4C;
// 总长度：先预设为0，最后再修改，位置为Task_sendBuff[1]
Task_sendBuff[i++] = 0;
// 协议版本
Task_sendBuff[i++] = 1;
// 硬件版本
Task_sendBuff[i++] = dcBuff.powerInfo.hardVer.minor;
// 软件版本
Task_sendBuff[i++] = dcBuff.powerInfo.softVer.minor;
// PSN
memmove(Task_sendBuff + i, dcBuff.configBottle.PSN, 6);
printf("\nSend PSN: 20%02d%02d%02d%02d%03d\n", Task_sendBuff[i], Task_sendBuff[i + 1], Task_sendBuff[i + 2],
Task_sendBuff[i+3], (Task_sendBuff[i + 4] << 8) | Task_sendBuff[i + 5]);
i += 6;
// 时间戳
RTC_GetDateAndTime(&sRTC);
*relativeTime = Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second) - pGprs->sample_time;
Int2ByteL(Task_sendBuff, i, htonl(*relativeTime));
i += 4;
// 传感器状态
uVal32 = 0xFFFFFFFFul;
// 连接状态
if(!pGprs->sampleData.staDPress.notConnect)
uVal32 &= ~(1ul << 0);
if(!pGprs->sampleData.staPress.notConnect)
uVal32 &= ~(1ul << 1);
if(!pGprs->sampleData.staExtTempr[0].notConnect)
uVal32 &= ~(1ul << 2);
if(!pGprs->sampleData.staExtTempr[1].notConnect)
uVal32 &= ~(1ul << 3);
if(!(pGprs->sampleData.vacuum[0].staVacuum == VACUUM_STATUS_COMM_FAULT))
uVal32 &= ~(1ul << 6);
if(!(pGprs->sampleData.leak.staLeak == LEAK_STATUS_COMM_FAULT))
uVal32 &= ~(1ul << 7);
// 故障状态
if(!(pGprs->sampleData.staDPress.overFlow || pGprs->sampleData.staDPress.underFlow))
uVal32 &= ~(1ul << 8);
if(!(pGprs->sampleData.staPress.overFlow || pGprs->sampleData.staPress.underFlow))
uVal32 &= ~(1ul << 9);
if(!(pGprs->sampleData.staExtTempr[0].overFlow || pGprs->sampleData.staExtTempr[0].underFlow))
uVal32 &= ~(1ul << 10);
if(!(pGprs->sampleData.staExtTempr[1].overFlow || pGprs->sampleData.staExtTempr[1].underFlow))
uVal32 &= ~(1ul << 11);
if(!(pGprs->sampleData.vacuum[0].staVacuum == VACUUM_STATUS_FAULT))
uVal32 &= ~(1ul << 14);
if(!(pGprs->sampleData.leak.staLeak == LEAK_STATUS_FAULT))
uVal32 &= ~(1ul << 15);
Int2ByteL(Task_sendBuff, i, htonl(uVal32));
i += 4;
// 当前差压值：mmWC
if(!dcBuff.configDisplay.op_USE_CAPACITY_SENSOR && !dcBuff.configDisplay.op_USE_HEIGHT_LEVEL && !dcBuff.configDisplay.op_USE_PCT_LEVEL)
Int2ByteS(Task_sendBuff, i, htons((uint16_t) KPa2mmH2O(pGprs->sampleData.diff)));
else
Int2ByteS(Task_sendBuff, i, htons((uint16_t) pGprs->sampleData.height));
i +=2 ;
// 容积百分比
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.volumePct));
i += 2;
// 当前容积
Int2ByteL(Task_sendBuff, i, htonl(pGprs->sampleData.volume));
i += 4;
// 重量
Int2ByteL(Task_sendBuff, i, htonl(pGprs->sampleData.weight));
i += 4;
// 气瓶容量
Int2ByteL(Task_sendBuff, i, htonl(pGprs->sampleData.volumeTotal));
i += 4;
// 压力1
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.pressure));
i += 2;
// 温度1
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.extTempr[0]));
i += 2;
// 温度2
Int2ByteS(Task_sendBuff, i, htons(pGprs->sampleData.extTempr[1]));
i += 2;
// 温度3
i += 2;
// 温度4
i += 2;
// 真空度
Int2ByteS(Task_sendBuff, i, htons((uint16_t) (pGprs->sampleData.vacuum[0].vacuum * 100)));
i += 2;
// 真空计温度
Int2ByteS(Task_sendBuff, i, htons((int16_t) pGprs->sampleData.vacuum[0].tempr));
i += 2;
#if 0
// 天信MODBUS /A1 通信协议 (BCD码）
// 标况体积总量
memmove(Task_sendBuff + i, pGprs->sampleData.flow.nM3, 6);
i += 6;
// 标况流量
memmove(Task_sendBuff + i, pGprs->sampleData.flow.nM3_h, 4);
i += 4;
// 工况流量
memmove(Task_sendBuff + i, pGprs->sampleData.flow.M3_h, 4);
i += 4;
// 流量计温度
memmove(Task_sendBuff + i, pGprs->sampleData.flow.tempr, 4);
i += 4;
// 流量计压力
memmove(Task_sendBuff + i, pGprs->sampleData.flow.pressure, 4);
i += 4;
#endif
// 泄露状态
Task_sendBuff[i++] = (pGprs->sampleData.leak.staLeak == LEAK_STATUS_A2_ALARM ? 1 : 0);
// 经度
if(pGprs->dtuData.recentPosState)
Int2ByteL(Task_sendBuff, i, htonl(pGprs->dtuData.longitude));
i += 4;
// 纬度
if(pGprs->dtuData.recentPosState)
Int2ByteL(Task_sendBuff, i, htonl(pGprs->dtuData.latitude));
i += 4;
// rssi
Task_sendBuff[i++] = pGprs->dtuData.rssi;
// 电量百分比
Task_sendBuff[i++] = pGprs->dtuData.batPct;
// 电池当前电压
Int2ByteS(Task_sendBuff, i, htons(pGprs->dtuData.batVoltage / 10));
i += 2;
// 供电状态
Task_sendBuff[i++] = (pGprs->dtuData.batCurrent < 0 ? -1 : 1);
// 液源
if(dcBuff.configBottle.source >= SOURCE_LNG && dcBuff.configBottle.source <= SOURCE_POPO)
Task_sendBuff[i] = dcBuff.configBottle.source;
i++;
// 密度
Int2ByteS(Task_sendBuff, i, htons(Config_GetDensity(dcBuff.configBottle.source) * 1000));
i += 2;
// 储罐类型
if(dcBuff.configBottle.type == BOTTLE_TYPE_STAND)
Task_sendBuff[i] = 0;
else if(dcBuff.configBottle.type == BOTTLE_TYPE_LYING)
Task_sendBuff[i] = 1;
else if(dcBuff.configBottle.type == BOTTLE_TYPE_SPHERICAL)
Task_sendBuff[i] = 2;
i++;
// 储罐直径
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.diameter));
i += 4;
// 储罐筒长度
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.len + dcBuff.configBottle.lenExtra * 2));
i += 4;
// 采集周期
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configData.intervalSample));
i += 4;
// 发送周期
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configData.intervalTrans));
i += 4;
// 满液位百分比
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.warnPressH));
i += 2;
// 压力报警下限
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnPress));
i += 2;
// 温度报警上限
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnTemprH));
i += 2;
// 温度报警下限
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnTempr));
i += 2;
// 真空度报警上限
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnVacuumH));
i += 2;
// 显示控制
Task_sendBuff[i++] = dcBuff.configBottle.dispMode;
// 修改数据长度
Task_sendBuff[1] = i - 1 + 2;
// 校验码
crc = MODBUS_RTU_CRC16(Task_sendBuff + 1, i - 1);
Int2ByteS(Task_sendBuff, i, htons(crc));
i += 2;
// 结束符
Task_sendBuff[i++] = 0x53;
return i;
}
uint8_t pack_chaoyang_send_data(gprs_data_t *pGprs, uint32_t *relativeTime)
{
uint8_t i;
uint32_t uVal32;
// 打包上报数据（按modbus从机响应的格式）
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
i = 0;
// IMSI
memmove(Task_sendBuff + i, dcBuff.powerInfo.simNumber, strlen(dcBuff.powerInfo.simNumber));
i += 15;
// 压力状态、压力值
if(pGprs->sampleData.staPress.notConnect || pGprs->sampleData.staPress.underFlow || pGprs->sampleData.staPress.overFlow)
{
Task_sendBuff[i++] = '0';
sprintf((s8 *) Task_sendBuff + i, "%05d", 0);
}
else
{
Task_sendBuff[i++] = '1';
sprintf((s8 *) Task_sendBuff + i, "%05d", pGprs->sampleData.pressure / 10); // 0.1MPa
}
i += 5;
// 液位状态、液量值
if(pGprs->sampleData.staDPress.notConnect || pGprs->sampleData.staDPress.underFlow || pGprs->sampleData.staDPress.overFlow)
{
Task_sendBuff[i++] = '0';
sprintf((s8 *) Task_sendBuff + i, "%05d", 0);
}
else
{
Task_sendBuff[i++] = '1';
sprintf((s8 *) Task_sendBuff + i, "%05d", pGprs->sampleData.volume / 10); // 0.1m3
}
i += 5;
// 电池电压
Task_sendBuff[i++] = '1';
sprintf((s8 *) Task_sendBuff + i, "%05d", pGprs->dtuData.batVoltage / 10); // 0.1v
i += 5;
// 充电状态
Task_sendBuff[i++] = '1';
sprintf((s8 *) Task_sendBuff + i, "%05d", VCC_POWER_STATUS() ? 1 * 100 : 0);
i += 5;
// 结束符
sprintf((s8 *) Task_sendBuff + i, "\r\n");
i += 2;
return i;
}
uint8_t parse_furui_recv_data(uint8_t PSN[6], uint32_t relativeTime, uint16_t recvLen)
{
uint8_t i, j, len, protocol;
uint32_t mask, uVal32;
uint16_t uVal16;
int16_t val16;
uint8_t saveConfig = 0;
i = 0;
// 检查起始符、结束符
if(Task_recvBuff[i++] != 0x4C || Task_recvBuff[recvLen - 1] != 0x53)
return 0;
// 检查数据长度和CRC
len = Task_recvBuff[i++];
if(len != recvLen - 2 || MODBUS_RTU_CRC16(Task_recvBuff + 1, len) != 0)
return 0;
// 检查协议版本
protocol = Task_recvBuff[i++];
if(protocol != 1)
return 0;
// 检查PSN
if(memcmp(Task_recvBuff + i, PSN, 6) != 0)
return 0;
i += 6;
// 检查时间戳
if(ntohl(Byte2IntL(Task_recvBuff, i)) != relativeTime)
return 0;
i += 4;
// 参数更新标志
mask = ntohl(Byte2IntL(Task_recvBuff, i));
i += 4;
j = 0;
// 介质
if(mask & (1ul << (j++)))
{
printf("modify source\r\n");
if(dcBuff.configBottle.source != Task_recvBuff[i])
{
dcBuff.configBottle.source = Task_recvBuff[i];
saveConfig = 1;
}
}
i++;
// 密度
if(mask & (1ul << (j++)))
{
printf("modify density\r\n");
uVal16 = ntohs(Byte2IntS(Task_recvBuff, i));
if(Config_GetDensity(dcBuff.configBottle.source) * 1000 != uVal16)
{
Config_SetDensity(dcBuff.configBottle.source, uVal16 / 1000.0);
saveConfig = 1;
}
}
i += 2;
// 储罐类型
if(mask & (1ul << (j++)))
{
printf("modify type\r\n");
if(dcBuff.configBottle.type != Task_recvBuff[i])
{
dcBuff.configBottle.type = Task_recvBuff[i];
saveConfig = 1;
}
}
i++;
// 储罐直径
if(mask & (1ul << (j++)))
{
printf("modify diameter\r\n");
uVal32 = ntohl(Byte2IntL(Task_recvBuff, i));
if(dcBuff.configBottle.diameter != uVal32)
{
dcBuff.configBottle.diameter = uVal32;
saveConfig = 1;
}
}
i += 4;
// 储罐筒长度
if(mask & (1ul << (j++)))
{
printf("modify len\r\n");
uVal32 = ntohl(Byte2IntL(Task_recvBuff, i));
if(dcBuff.configBottle.lenExtra != 0 || dcBuff.configBottle.len != uVal32)
{
dcBuff.configBottle.lenExtra = 0;
dcBuff.configBottle.len = uVal32;
saveConfig = 1;
}
}
i += 4;
// 采集周期
if(mask & (1ul << (j++)))
{
printf("modify intervalSample\r\n");
uVal32 = ntohl(Byte2IntL(Task_recvBuff, i));
if(dcBuff.configData.intervalSample != uVal32)
{
dcBuff.configData.intervalSample = uVal32;
saveConfig = 1;
}
}
i += 4;
// 发送周期
if(mask & (1ul << (j++)))
{
printf("modify intervalTrans\r\n");
uVal32 = ntohl(Byte2IntL(Task_recvBuff, i));
if(dcBuff.configData.intervalTrans != uVal32)
{
dcBuff.configData.intervalTrans = uVal32;
saveConfig = 1;
}
}
i += 4;
// 满液位百分比
if(mask & (1ul << (j++)))
{
printf("modify fullPct\r\n");
uVal16= ntohs(Byte2IntS(Task_recvBuff, i));
if(dcBuff.configBottle.fullPct != uVal16)
{
dcBuff.configBottle.fullPct = uVal16;
saveConfig = 1;
}
}
i += 2;
// 关键液位百分比
if(mask & (1ul << (j++)))
{
printf("modify priPct\r\n");
uVal16= ntohs(Byte2IntS(Task_recvBuff, i));
if(dcBuff.configBottle.priPct != uVal16)
{
dcBuff.configBottle.priPct = uVal16;
saveConfig = 1;
}
}
i += 2;
// 订货位百分比
if(mask & (1ul << (j++)))
{
printf("modify orderPct\r\n");
uVal16= ntohs(Byte2IntS(Task_recvBuff, i));
if(dcBuff.configBottle.orderPct != uVal16)
{
dcBuff.configBottle.orderPct = uVal16;
saveConfig = 1;
}
}
i += 2;
// 空液位百分比
if(mask & (1ul << (j++)))
{
printf("modify emptyPct\r\n");
uVal16= ntohs(Byte2IntS(Task_recvBuff, i));
if(dcBuff.configBottle.emptyPct != uVal16)
{
dcBuff.configBottle.emptyPct = uVal16;
saveConfig = 1;
}
}
i += 2;
// 压力报警上限
if(mask & (1ul << (j++)))
{
printf("modify warnPressH\r\n");
uVal16= ntohs(Byte2IntS(Task_recvBuff, i));
if(dcBuff.configBottle.warnPressH != uVal16)
{
dcBuff.configBottle.warnPressH = uVal16;
saveConfig = 1;
}
}
i += 2;
// 压力报警下限
if(mask & (1ul << (j++)))
{
printf("modify warnPress\r\n");
uVal16= ntohs(Byte2IntS(Task_recvBuff, i));
if(dcBuff.configBottle.warnPress != uVal16)
{
dcBuff.configBottle.warnPress = uVal16;
saveConfig = 1;
}
}
i += 2;
// 温度报警上限
if(mask & (1ul << (j++)))
{
printf("modify warnTemprH\r\n");
uVal16= ntohs(Byte2IntS(Task_recvBuff, i));
memmove(&val16, &uVal16, 2);
if(dcBuff.configBottle.warnTemprH != val16)
{
dcBuff.configBottle.warnTemprH = val16;
saveConfig = 1;
}
}
i += 2;
// 温度报警下限
if(mask & (1ul << (j++)))
{
printf("modify warnTempr\r\n");
uVal16= ntohs(Byte2IntS(Task_recvBuff, i));
memmove(&val16, &uVal16, 2);
if(dcBuff.configBottle.warnTempr != val16)
{
dcBuff.configBottle.warnTempr = val16;
saveConfig = 1;
}
}
i += 2;
// 真空度报警上限
if(mask & (1ul << (j++)))
{
printf("modify warnVacuumH\r\n");
uVal16= ntohs(Byte2IntS(Task_recvBuff, i));
if(dcBuff.configBottle.warnVacuumH != uVal16)
{
dcBuff.configBottle.warnVacuumH = uVal16;
saveConfig = 1;
}
}
i += 2;
// 显示控制
if(mask & (1ul << (j++)))
{
printf("modify dispMode\r\n");
if(dcBuff.configBottle.dispMode != Task_recvBuff[i])
{
dcBuff.configBottle.dispMode = Task_recvBuff[i];
saveConfig = 1;
}
}
i++;
// 保存参数
if(saveConfig)
Config_SaveConfig();
return 1;
}
uint8_t parse_huida_recv_data(uint8_t PSN[6], uint32_t relativeTime, uint16_t recvLen)
{
return parse_furui_recv_data(PSN, relativeTime, recvLen);
}
////////////////////////////////////////////////////////////////////////////////////////
uint8_t pack_rf_send_data(gprs_data_t *pGprs, uint32_t totalSeconds)
{
uint8_t i;
rf_sensor_t *pSensor;
S_RTC_TIME_DATA_T sRTC;
// 打包上报数据（按modbus从机响应的格式）
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
i = 0;
// PSN
printf("\nRf PSN: 20%02d%02d%02d%02d%03d\n", dcBuff.configBottle.PSN[0], dcBuff.configBottle.PSN[1],
dcBuff.configBottle.PSN[2], dcBuff.configBottle.PSN[3],
(dcBuff.configBottle.PSN[4] << 8) | dcBuff.configBottle.PSN[5]);
// 差压测量：差压值 *100(KPa)，称重测量：容积百分比*100，电容测量：液位高度（mm）
if(!dcBuff.configDisplay.op_USE_CAPACITY_SENSOR)
{
if(dcBuff.configBottle.measureType == 0)
Int2ByteS(Task_sendBuff, i, pGprs->sampleData.diff * 100);
else
Int2ByteS(Task_sendBuff, i, pGprs->sampleData.volumePct);
}
else
Int2ByteS(Task_sendBuff, i, pGprs->sampleData.height);
i += 2;
// 压力
Int2ByteS(Task_sendBuff, i, pGprs->sampleData.pressure);
i += 2;
// 温度
Int2ByteS(Task_sendBuff, i, pGprs->sampleData.extTempr[0]);
i += 2;
// 液源/贮罐类型/故障码/测量方式
pSensor = (rf_sensor_t *) (Task_sendBuff + i);
pSensor->staDiff = Bluetooth_ConvertStat(&pGprs->sampleData.staDPress);
pSensor->staPress = Bluetooth_ConvertStat(&pGprs->sampleData.staPress);
pSensor->staETempr1 = Bluetooth_ConvertStat(&pGprs->sampleData.staExtTempr[0]);
pSensor->charging = pGprs->sampleData.charging;
pSensor->bat_low = pGprs->dtuData.batLow;
if(!dcBuff.configDisplay.op_USE_CAPACITY_SENSOR)
pSensor->measure_type = dcBuff.configBottle.measureType;
else
pSensor->measure_type = 2;
pSensor->bottle_type = dcBuff.configBottle.type;
pSensor->L_source = dcBuff.configBottle.source;
i += 2;
// 密度
Int2ByteS(Task_sendBuff, i, Config_GetDensity(dcBuff.configBottle.source) * 1000);
i += 2;
// 经度
if(pGprs->dtuData.recentPosState)
Int2ByteL(Task_sendBuff, i, pGprs->dtuData.longitude);
i += 4;
// 纬度
if(pGprs->dtuData.recentPosState)
Int2ByteL(Task_sendBuff, i, pGprs->dtuData.latitude);
i += 4;
// 电池当前电压
Int2ByteS(Task_sendBuff, i, pGprs->dtuData.batVoltage / 10);
i += 2;
// 电量百分比
Task_sendBuff[i++] = pGprs->dtuData.batPct;
#if 0
// 充电电流，电流的符号表示充放电状态
if(pGprs->dtuData.batCurrent < -128)
Task_sendBuff[i] = -128;
else if(pGprs->dtuData.batCurrent > 127)
Task_sendBuff[i] = 127;
else
Task_sendBuff[i] = pGprs->dtuData.batCurrent;
#else
// 用电流的绝对值表示复位原因
// 1-POR, 2-PIN, 4-WDT, 8-LVR, 16-BOD, 32-SYS
Task_sendBuff[i] = SYS_RSTSTS & 0x7F;
if(pGprs->dtuData.batCurrent < 0)
Task_sendBuff[i] = -Task_sendBuff[i];
#endif
i++;
// 获取当前时间
RTC_GetDateAndTime(&sRTC);
Int2ByteL(Task_sendBuff, i, Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second) - pGprs->sample_time);
i += 4;
printf("\ndcBuff.powerInfo.hardVer.major = %d, dcBuff.powerInfo.softVer.minor = %d\n",
dcBuff.powerInfo.hardVer.major, dcBuff.powerInfo.softVer.minor);
// 硬件版本
Task_sendBuff[i++] = dcBuff.powerInfo.hardVer.minor;
// 软件版本
Task_sendBuff[i++] = dcBuff.powerInfo.softVer.minor;
// 储罐筒长度
Int2ByteL(Task_sendBuff, i, dcBuff.configBottle.len + dcBuff.configBottle.lenExtra * 2);
i += 4;
// 储罐直径
Int2ByteL(Task_sendBuff, i, dcBuff.configBottle.diameter);
i += 4;
// 充装比
Task_sendBuff[i++] = dcBuff.configBottle.chargePct;
return i;
}
////////////////////////////////////////////////////////////////////////////////////////
uint8_t pack_bd_send_data(gprs_data_t *pGprs, uint32_t totalSeconds)
{
uint8_t i;
rf_sensor_t *pSensor;
S_RTC_TIME_DATA_T sRTC;
// 打包上报数据（按modbus从机响应的格式）
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
i = 0;
// PSN
printf("\nBD PSN: 20%02d%02d%02d%02d%03d\n", dcBuff.configBottle.PSN[0], dcBuff.configBottle.PSN[1],
dcBuff.configBottle.PSN[2], dcBuff.configBottle.PSN[3],
(dcBuff.configBottle.PSN[4] << 8) | dcBuff.configBottle.PSN[5]);
// 差压
Int2ByteS(Task_sendBuff, i, pGprs->sampleData.diff);
i += 2;
// 容积百分比
Int2ByteS(Task_sendBuff, i, pGprs->sampleData.volumePct);
i += 2;
// 当前容积
Int2ByteL(Task_sendBuff, i, pGprs->sampleData.volume);
i += 4;
// 重量
Int2ByteL(Task_sendBuff, i, pGprs->sampleData.weight);
i += 4;
// 压力
Int2ByteS(Task_sendBuff, i, pGprs->sampleData.pressure);
i += 2;
// 温度-扩展温度1
Int2ByteS(Task_sendBuff, i, pGprs->sampleData.extTempr[0]);
i += 2;
// 温度-调试信息：标识北斗短信
Int2ByteS(Task_sendBuff, i, 2);
i += 2;
// 液源/贮罐类型/故障码/测量方式
pSensor = (rf_sensor_t *) (Task_sendBuff + i);
pSensor->staDiff = Bluetooth_ConvertStat(&pGprs->sampleData.staDPress);
pSensor->staPress = Bluetooth_ConvertStat(&pGprs->sampleData.staPress);
pSensor->staETempr1 = Bluetooth_ConvertStat(&pGprs->sampleData.staExtTempr[0]);
pSensor->charging = pGprs->sampleData.charging;
pSensor->bat_low = pGprs->dtuData.batLow;
if(!dcBuff.configDisplay.op_USE_CAPACITY_SENSOR)
pSensor->measure_type = dcBuff.configBottle.measureType;
else
pSensor->measure_type = 2;
pSensor->bottle_type = dcBuff.configBottle.type;
pSensor->L_source = dcBuff.configBottle.source;
i += 2;
// 经度
if(pGprs->dtuData.recentPosState)
Int2ByteL(Task_sendBuff, i, pGprs->dtuData.longitude);
i += 4;
// 纬度
if(pGprs->dtuData.recentPosState)
Int2ByteL(Task_sendBuff, i, pGprs->dtuData.latitude);
i += 4;
// 电池当前电压
Int2ByteS(Task_sendBuff, i, pGprs->dtuData.batVoltage / 10);
i += 2;
// 电量百分比
Task_sendBuff[i++] = pGprs->dtuData.batPct;
#if 0
// 充电电流，电流的符号表示充放电状态
if(pGprs->dtuData.batCurrent < -128)
Task_sendBuff[i] = -128;
else if(pGprs->dtuData.batCurrent > 127)
Task_sendBuff[i] = 127;
else
Task_sendBuff[i] = pGprs->dtuData.batCurrent;
#else
// 用电流的绝对值表示复位原因
// 1-POR, 2-PIN, 4-WDT, 8-LVR, 16-BOD, 32-SYS
Task_sendBuff[i] = SYS_RSTSTS & 0x7F;
if(pGprs->dtuData.batCurrent < 0)
Task_sendBuff[i] = -Task_sendBuff[i];
#endif
i++;
// 获取当前时间
RTC_GetDateAndTime(&sRTC);
Int2ByteL(Task_sendBuff, i, Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second) - pGprs->sample_time);
i += 4;
printf("\ndcBuff.powerInfo.hardVer.major = %d, dcBuff.powerInfo.softVer.minor = %d\n",
dcBuff.powerInfo.hardVer.major, dcBuff.powerInfo.softVer.minor);
// 硬件版本
Task_sendBuff[i++] = dcBuff.powerInfo.hardVer.minor;
// 软件版本
Task_sendBuff[i++] = dcBuff.powerInfo.softVer.minor;
// 气瓶容量
Int2ByteL(Task_sendBuff, i, pGprs->sampleData.volumeTotal);
i += 4;
// 储罐筒长度
Int2ByteL(Task_sendBuff, i, dcBuff.configBottle.len + dcBuff.configBottle.lenExtra * 2);
i += 4;
// 储罐直径
Int2ByteL(Task_sendBuff, i, dcBuff.configBottle.diameter);
i += 4;
return i;
}
////////////////////////////////////////////////////////////////////////////////////////
uint16_t pack_json_send_data(gprs_data_t *pGprs, uint32_t totalSeconds)
{
char psn[14], utc[21];
S_RTC_TIME_DATA_T sRTC;
#if 0
unsigned long long ll = 0;
ll = dcBuff.configBottle.PSN[0] * 1000000000ll + dcBuff.configBottle.PSN[1] * 10000000ll
+ dcBuff.configBottle.PSN[2] * 100000ll + dcBuff.configBottle.PSN[3] * 1000ll
+ ((dcBuff.configBottle.PSN[4] << 8) | dcBuff.configBottle.PSN[5]);
sprintf(psn, "%010llX", ll);
#else
sprintf(psn, "20%02d%02d%02d%02d%03d", dcBuff.configBottle.PSN[0], dcBuff.configBottle.PSN[1],
dcBuff.configBottle.PSN[2], dcBuff.configBottle.PSN[3],
(dcBuff.configBottle.PSN[4] << 8) | dcBuff.configBottle.PSN[5]);
#endif
Wakeup_CalcUTCTime(pGprs->sample_time + RTC_offsetSeconds, &sRTC);
sprintf(utc, "%04d-%02d-%02dT%02d:%02d:%02dZ", sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);
json_initialize();
json_new_object();
json_new_array("assets");
json_new_object();
json_new_stringValue("customerReference", "PRAXAIR-GOLD-CN-PROD");
json_new_stringValue("assetIntegrationId", "0");
json_new_array("channels");
json_new_object();
json_new_stringValue("deviceId", psn);
json_new_stringValue("channelType", "Level");
json_new_stringValue("channelNumber", "1");
json_new_stringValue("scaledUnitName", "mm WC");
json_new_array("readings");
json_new_object();
if(!dcBuff.configDisplay.op_USE_CAPACITY_SENSOR && !dcBuff.configDisplay.op_USE_HEIGHT_LEVEL && !dcBuff.configDisplay.op_USE_PCT_LEVEL)
json_new_doubleValue("scaledMeasurement", KPa2mmH2O(pGprs->sampleData.diff));
else
json_new_doubleValue("scaledMeasurement", pGprs->sampleData.height);
json_new_stringValue("timestamp", utc);
json_end_object();
json_end_array();
json_end_object();
if(!dcBuff.configDisplay.op_LEVEL_SENSOR_ONLY){
json_new_object();
json_new_stringValue("deviceId", psn);
json_new_stringValue("channelType", "Pressure");
json_new_stringValue("channelNumber", "2");
json_new_stringValue("scaledUnitName", "BAR");
json_new_array("readings");
json_new_object();
json_new_doubleValue("scaledMeasurement", pGprs->sampleData.pressure * 0.01);
json_new_stringValue("timestamp", utc);
json_end_object();
json_end_array();
json_end_object();}
if(!dcBuff.configDisplay.op_LEVEL_SENSOR_ONLY && !dcBuff.configDisplay.op_DOL_VER){
json_new_object();
json_new_stringValue("deviceId", psn);
json_new_stringValue("channelType", "Temperature");
json_new_stringValue("channelNumber", "3");
json_new_stringValue("scaledUnitName", "Celsius");
json_new_array("readings");
json_new_object();
json_new_intValue("scaledMeasurement", pGprs->sampleData.extTempr[0]);
json_new_stringValue("timestamp", utc);
json_end_object();
json_end_array();
json_end_object();}
json_new_object();
json_new_stringValue("deviceId", psn);
json_new_stringValue("channelType", "Gps");
json_new_stringValue("channelNumber", "4");
json_new_array("readings");
json_new_object();
json_new_intValue("scaledMeasurement", 0);
if(pGprs->dtuData.recentPosState)
{
json_new_doubleValue("longitude", pGprs->dtuData.longitude * 0.000001);
json_new_doubleValue("latitude", pGprs->dtuData.latitude * 0.000001);
}
else
{
json_new_doubleValue("longitude", 0);
json_new_doubleValue("latitude", 0);
}
json_new_stringValue("timestamp", utc);
json_end_object();
json_end_array();
json_end_object();
json_new_object();
json_new_stringValue("deviceId", psn);
json_new_stringValue("channelType", "BatVoltage");
json_new_stringValue("channelNumber", "5");
json_new_stringValue("scaledUnitName", "V");
json_new_array("readings");
json_new_object();
json_new_doubleValue("scaledMeasurement", pGprs->dtuData.batVoltage * 0.001);
json_new_stringValue("timestamp", utc);
json_end_object();
json_end_array();
json_end_object();
if(0){
json_new_object();
json_new_stringValue("deviceId", psn);
json_new_stringValue("channelType", "Diagnostic");
json_new_stringValue("channelNumber", "6");
json_new_array("readings");
json_new_object();
json_new_intValue("scaledMeasurement", dcBuff.powerInfo.hardVer.major);
json_new_stringValue("timestamp", utc);
json_end_object();
json_end_array();
json_end_object();}
if(0){
json_new_object();
json_new_stringValue("deviceId", psn);
json_new_stringValue("channelType", "Diagnostic");
json_new_stringValue("channelNumber", "7");
json_new_array("readings");
json_new_object();
json_new_intValue("scaledMeasurement", dcBuff.powerInfo.hardVer.minor);
json_new_stringValue("timestamp", utc);
json_end_object();
json_end_array();
json_end_object();}
if(0){
json_new_object();
json_new_stringValue("deviceId", psn);
json_new_stringValue("channelType", "Diagnostic");
json_new_stringValue("channelNumber", "8");
json_new_array("readings");
json_new_object();
json_new_intValue("scaledMeasurement", dcBuff.powerInfo.softVer.minor);
json_new_stringValue("timestamp", utc);
json_end_object();
json_end_array();
json_end_object();}
if(0){
json_new_object();
json_new_stringValue("deviceId", psn);
json_new_stringValue("channelType", "Diagnostic");
json_new_stringValue("channelNumber", "9");
json_new_array("readings");
json_new_object();
// 自启动以来的时间分钟数，32767分钟
json_new_intValue("scaledMeasurement", totalSeconds % 1966080ul / 60);
json_new_stringValue("timestamp", utc);
json_end_object();
json_end_array();
json_end_object();}
if(0){
json_new_object();
json_new_stringValue("deviceId", psn);
json_new_stringValue("channelType", "Diagnostic");
json_new_stringValue("channelNumber", "10");
json_new_array("readings");
json_new_object();
// 启动代码，充放电
json_new_intValue("scaledMeasurement", pGprs->dtuData.batCurrent > 0 ? SYS_RSTSTS : -SYS_RSTSTS);
json_new_stringValue("timestamp", utc);
json_end_object();
json_end_array();
json_end_object();}
if(0){
json_new_object();
json_new_stringValue("deviceId", psn);
json_new_stringValue("channelType", "Diagnostic");
json_new_stringValue("channelNumber", "11");
json_new_array("readings");
json_new_object();
// 上传GPS调试信息: 闪断次数*100+卫星数, 如2105表示闪断21次，卫星数5颗
json_new_intValue("scaledMeasurement", GPS_BOD_COUNT * 100 + pGprs->dtuData.sateCount);
json_new_stringValue("timestamp", utc);
json_end_object();
json_end_array();
json_end_object();}
json_end_array();
json_end_object();
json_end_array();
json_end_object();
json_finish();
return strlen(JSON_data());
}
////////////////////////////////////////////////////////////////////////////////////////
// 填写双向通讯的固定字段
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_Ext_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;
if(bat_veryLow)
Task_sendBuff[i] = 2;
else if(dcBuff.dtuData.batLow)
Task_sendBuff[i] = 1;
else
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 | (dcBuff.configBottle.hideVacu << 2);
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 += 30;
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configData.port));
i += 2;
memmove(Task_sendBuff + i, dcBuff.configData.gpsServer, strlen(dcBuff.configData.gpsServer));
i += 30;
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configData.gpsPort));
i += 2;
memmove(Task_sendBuff + i, dcBuff.configData.upgServer, strlen(dcBuff.configData.upgServer));
i += 30;
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 += 24;
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;
strcpy((char *) Task_sendBuff + i, DTU_DecideAPNUser());
i += 10;
strcpy((char *) Task_sendBuff + i, DTU_DecideAPNPwd());
i += 10;
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.floorLevel));
i += 2;
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.span));
i += 2;
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.spanPeriod));
i += 2;
// 测量方式
Task_sendBuff[i++] = dcBuff.configDisplay.op_USE_CAPACITY_SENSOR ? 2 : dcBuff.configBottle.measureType;
Task_sendBuff[i++] = 0;
Task_sendBuff[i++] = dcBuff.configDisplay.op_USE_PT100_SENSOR ? 0 : 1;
// 差压传感器参数
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;
if(dcBuff.configDisplay.op_USE_PT100_SENSOR)
{
// 扩展温度传感器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;
}
else
{
// 扩展温度传感器1参数
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorMTempr[0].lowRange));
i += 2;
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorMTempr[0].highRange));
i += 2;
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorMTempr[0].zeroValue));
i += 2;
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorMTempr[0].fullValue));
i += 2;
// 扩展温度传感器2参数
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorMTempr[1].lowRange));
i += 2;
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorMTempr[1].highRange));
i += 2;
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorMTempr[1].zeroValue));
i += 2;
Int2ByteS(Task_sendBuff, i, htons(dcBuff.configSensor.sensorMTempr[1].fullValue));
i += 2;
}
// 填写固定字段
return fill_biDir_fixFields(0xD045, i);
}
#define D046_PARAM_SIZE (268)
uint8_t parse_param_D046_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] & 0x03;
dcBuff.configBottle.hideVacu = (param[i] >> 2) & 0x01;
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 += 30;
// 远传端口
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 += 30;
// 远传端口
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 += 30;
// 远传端口
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 += 24;
// 北斗指挥机卡号
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;
// APN-User
if(mask.ll & (1ull << (shift++)))
strcpy(dcBuff.configDisplay.User, (char *) param + i);
i += 10;
// APN-Pwd
if(mask.ll & (1ull << (shift++)))
strcpy(dcBuff.configDisplay.Pwd, (char *) param + i);
i += 10;
// 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.span = ntohs(Byte2IntS(param, i));
i += 2;
// TTS-变化量检测时间: 秒
if(mask.ll & (1ull << (shift++)))
dcBuff.configBottle.spanPeriod = ntohs(Byte2IntS(param, i));
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;
if(dcBuff.configDisplay.op_USE_PT100_SENSOR)
{
// 温度传感器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;
}
else
{
// 温度传感器1量程: 低
if(mask.ll & (1ull << (shift++)))
dcBuff.configSensor.sensorMTempr[0].lowRange = ntohs(Byte2IntS(param, i));
i += 2;
// 温度传感器1量程: 高
if(mask.ll & (1ull << (shift++)))
dcBuff.configSensor.sensorMTempr[0].highRange = ntohs(Byte2IntS(param, i));
i += 2;
// 温度传感器1标定: 低
if(mask.ll & (1ull << (shift++)))
dcBuff.configSensor.sensorMTempr[0].zeroValue = ntohs(Byte2IntS(param, i));
i += 2;
// 温度传感器1标定: 高
if(mask.ll & (1ull << (shift++)))
dcBuff.configSensor.sensorMTempr[0].fullValue = ntohs(Byte2IntS(param, i));
i += 2;
// 温度传感器2量程: 低
if(mask.ll & (1ull << (shift++)))
dcBuff.configSensor.sensorMTempr[1].lowRange = ntohs(Byte2IntS(param, i));
i += 2;
// 温度传感器2量程: 高
if(mask.ll & (1ull << (shift++)))
dcBuff.configSensor.sensorMTempr[1].highRange = ntohs(Byte2IntS(param, i));
i += 2;
// 温度传感器2标定: 低
if(mask.ll & (1ull << (shift++)))
dcBuff.configSensor.sensorMTempr[1].zeroValue = ntohs(Byte2IntS(param, i));
i += 2;
// 温度传感器2标定: 高
if(mask.ll & (1ull << (shift++)))
dcBuff.configSensor.sensorMTempr[1].fullValue = ntohs(Byte2IntS(param, i));
i += 2;
}
*reset = ((mask.ll & (1ull << shift)) != 0);
return ((mask.ll & ~(1ull << shift)) != 0);
}
#define D048_CONFIG_SIZE (82)
uint8_t parse_config_D048_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 += 30;
// 远传端口
dcBuff.configData.port = ntohs(Byte2IntS(param, i));
i += 2;
// 远传服务器
strcpy(dcBuff.configData.gpsServer, (char *) param + i);
i += 30;
// 远传端口
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++];
// 只显示毫米水柱
dcBuff.configDisplay.op_DISP_MMWC_ONLY = param[i++];
// 罐箱版本
dcBuff.configDisplay.op_BOX_VER = param[i++];
// 基站定位、不定位
dcBuff.configDisplay.op_CELL_LOCATION = param[i] & 1;
dcBuff.configDisplay.op_NO_LOCATION = (param[i] >> 1) & 1;
i++;
// 发送轨迹
dcBuff.configDisplay.op_SEND_GPS_DATA = param[i++];
// 通信方式
dcBuff.configDisplay.op_SERVER_PROTOCOL = param[i++];
// URL索引
dcBuff.configDisplay.op_SERVER_INDEX = param[i++];
// 单向通信
dcBuff.configDisplay.op_UNIDIR_COMM = param[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;
}
}
}
// 关闭和服务器的连接
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;
uint8_t gpsCount, gpsDone;
uint16_t gpsInterval;
uint32_t totalSeconds;
uint32_t relativeTime;
S_RTC_TIME_DATA_T sRTC;
gprs_data_t *pGprs;
uint8_t try_count;
uint16_t recvLen;
uint8_t upgrade;
uint8_t ackUpgrade;
uint8_t downloadParam;
uint8_t ackParam;
uint8_t downloadConfig;
uint8_t ackConfig;
uint8_t reset = 0;
param_data_t *pParam;
TUpgradeHeader upHeader;
upgrade_frame_t *pFrame;
gps_data_t gps;
uint16_t nextPtr;
uint8_t write_count;
uint8_t rf_fail_count = 0;
uint8_t semSync, semGPRS, semGPS;
uint8_t recentLocate;
uint32_t tick;
// 从FRAM读取阿里云密钥信息
FRAM_LoadInfo(FRAM_ALIYUN_SECRET_BASE, (uint8_t *) &aliyunSecret, sizeof(aliyunSecret));
// 从FRAM读取GPS信息
FRAM_LoadInfo(gpsBuff.info_base, (uint8_t *) &gpsBuff.info, sizeof(gpsBuff.info));
if(gpsBuff.info.rdPtr > gpsBuff.maxItemCount || gpsBuff.info.wtPtr > gpsBuff.maxItemCount)
memset(&gpsBuff.info, 0, sizeof(gpsBuff.info));
// 船级社维持时间算法初始化
//CCS_Init();
// 清除数据
memset(&dcBuff.dtuData, 0, sizeof(dcBuff.dtuData));
// 读取其它板子的配置数据
// 启动定时器
GPS_tranTick = GetDelayTick(dcBuff.configData.intervalGPSTrans * 1000);
if(dcBuff.configDisplay.op_BOX_VER)
{
// 检查是否有BD模块
BD_PowerOn();
BD_PowerOff();
}
// // 检查是否有RF模块
// RF_PowerOn();
// RF_PowerOff();
if(RF_initStatus && dcBuff.configDisplay.op_LNG_LORA)
RF_PowerOn();
// 打开槽车充液泵
if(dcBuff.configDisplay.op_SEND_GPS_DATA)
KZ_PUMP_ON();
// 上电运行一次任务
DTU_semSync = 1;
DTU_semGPRS = 1;
DTU_semGPS = 1;
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;
// 打开或关闭槽车的RF接收
if(dcBuff.configDisplay.op_SEND_GPS_DATA && RF_initStatus && !dcBuff.configDisplay.op_LNG_LORA)
{
if(VCC_POWER_STATUS())
RF_PowerOn();
else
RF_PowerOff();
}
// 槽车充液泵控制
if(dcBuff.configDisplay.op_SEND_GPS_DATA && !IS_PUMP_ON())
{
// 等待30分钟，或者离开5分钟
if(totalSeconds >= Pump_Stop_Time + 1800 || (totalSeconds >= Pump_Stop_Time + 300 && rf_is_truck_leave()))
KZ_PUMP_ON();
}
// 读取信号量
semSync = DTU_semSync;
DTU_semSync = 0;
semGPRS = DTU_semGPRS;
DTU_semGPRS = 0;
semGPS = DTU_semGPS;
DTU_semGPS = 0;
// 本地显示：无4G模块
if(dcBuff.configDisplay.op_LOCAL_DISP)
{
if(semGPS || semSync)
{
// 先清除信号量
GPRS_semSampled = 0;
// 采集数据
Sample_Notify();
tick = GetDelayTick(3000);
while(!GPRS_semSampled && !IsTickOut(tick))
{
}
}
// 休眠
Wakeup_Powerdown();
continue;
}
// 默认不保存、不发送
GPRS_Send_Task = 0;
GPRS_Save_Task = 0;
// 是否强制上传
if(DTU_dataConn)
{
DTU_dataConn = 0;
GPRS_Send_Task = 1;
}
// 是否强制定位
if(GPS_Locate)
{
GPS_Locate = 0;
// 强制定位：保存和发送
GPRS_Send_Task = 1;
GPRS_Save_Task = 1;
// 设置超时定时器
if(!dcBuff.configDisplay.op_NO_LOCATION)
{
GPS_waitTick = GetDelayTick(DTU_tmrLocate * 1000);
GPS_Waiting = 1;
}
}
// GPS发送周期：检查电池电量
if(semGPS || semSync)
{
delay_ms(200);
// 先清除信号量
GPRS_semSampled = 0;
// 采集数据
Sample_Notify();
tick = GetDelayTick(3000);
while(!GPRS_semSampled && !IsTickOut(tick))
{
}
// 根据电量设置工作模式
Wakeup_SetWorkMode();
}
// 检测唤醒同步信号
if(semGPRS || semSync)
{
printf("\n*** dcBuff.sampleData.warnning = %d ***\n", dcBuff.sampleData.warnning);
if(dcBuff.sampleData.warnning)
{
GPRS_Send_Task = 1;
dcBuff.sampleData.warnning = 0;
}
// 判断是否发送周期
// 如果发送时间到了，或者队列中的数据够了，则发送数据（为了工程测试方便，刚开始几次按照不大于5分钟的频率发送）
if(dcBuff.configDisplay.op_SEND_GPS_DATA)
{
// 发送间隔最小值
if(totalSeconds + 3 >= GPRS_Send_Time + (dcBuff.configData.intervalTrans > 300 ? 300 : dcBuff.configData.intervalTrans))
GPRS_Send_Task = 1;
}
else
{
if(((SYS_RSTSTS & 0x13) && !(SYS_RSTSTS & 0x04) && // 上电或手动复位, 非看门狗复位
totalSeconds < INITIAL_TRAN_COUNT * (dcBuff.configData.intervalSample > 300 ? 300 : dcBuff.configData.intervalSample))
|| totalSeconds + 3 >= GPRS_Send_Time + dcBuff.configData.intervalTrans
// || LoopBuff_GetCount(&gprsBuff) >= dcBuff.configData.intervalTrans / dcBuff.configData.intervalSample - 1
)
////// if(LoopBuff_GetCount(&gprsBuff) >= 11)
{
// 发送间隔最小值
if(totalSeconds + 3 >= GPRS_Send_Time + (dcBuff.configData.intervalTrans > 300 ? 300 : dcBuff.configData.intervalTrans))
GPRS_Send_Task = 1;
}
// else if(Config_CheckUpdate(&dcBuff))
// {
// GPRS_Send_Task = 1;
// }
}
// 判断是否保存周期
if(GPRS_Send_Task || totalSeconds + 3 >= GPRS_Save_Time + dcBuff.configData.intervalSample)
GPRS_Save_Task = 1;
if(GPRS_Send_Task && ((dcBuff.configDisplay.op_BOX_VER && (Motion_Detected || Motion_Status))
|| (dcBuff.configDisplay.op_SEND_GPS_DATA && Wakeup_GetWorkMode() == WORK_MODE_NORMAL)))
{
GPS_Located = 0;
// 设置超时定时器
if(!dcBuff.configDisplay.op_NO_LOCATION)
{
GPS_waitTick = GetDelayTick(DTU_tmrLocate * 1000);
GPS_Waiting = 1;
}
}
}
// 运行数据发送周期：检测信号强度
if(semGPRS || semSync)
{
if(Wakeup_GetWorkMode() == WORK_MODE_NORMAL && GPRS_Send_Task)
{
delay_ms(200);
// 打开DTU（开始定位）
dcBuff.dtuData.networked = 0;
if(RF_initStatus && dcBuff.configDisplay.op_BOX_VER && !dcBuff.configDisplay.op_LNG_LORA)
{
// 打开射频模块
RF_PowerOn();
// 检查中继器是否存在
rf_check_gateway();
// 关闭射频模块
RF_PowerOff();
}
if(!rf_has_gateway() || GPS_Waiting || dcBuff.configDisplay.op_SEND_GPS_DATA)
{
DTU_PowerOn();
// 重新开始定位计时，保证足够定位时间
GPS_waitTick = GetDelayTick(DTU_tmrLocate * 1000);
// 采集信号强度和注册信息
Sim808_ReadGPRS();
printf("\ndcBuff.dtuData.networked: %d\n", dcBuff.dtuData.networked);
// 如果有GPRS但是信号很弱
if(rf_has_gateway() && dcBuff.dtuData.rssi < 30)
dcBuff.dtuData.networked = 0;
if(!dcBuff.dtuData.networked)
dcBuff.dtuData.rssi = 0;
}
}
// 每小时保存1条数据
if(Wakeup_GetWorkMode() == WORK_MODE_NORMAL && GPRS_Save_Task)
{
if(GPRS_Send_Task)
{
// GPRS拨号和GPS定位同时进行，以节省时间
if(dcBuff.dtuData.networked)
Sim808_GPRSDial();
// 如果不发送轨迹数据，则等待定位完成再发送运行数据
recentLocate = (!dcBuff.configDisplay.op_SEND_GPS_DATA && Wakeup_GetWorkMode() == WORK_MODE_NORMAL && GPS_Waiting);
while(!dcBuff.configDisplay.op_SEND_GPS_DATA && Wakeup_GetWorkMode() == WORK_MODE_NORMAL && GPS_Waiting)
{
delay_ms(200);
}
if(!dcBuff.configDisplay.op_SEND_GPS_DATA)
{
// 关闭GPS
DTU_DisableGPS();
}
// 获取基站定位数据
if(recentLocate)
{
if(DTU_model == DTU_MODEL_LIERDA && Sim808_GetCellLocPosition())
{
dcBuff.dtuData.posState = 1;
dcBuff.dtuData.recentPosState = 1;
// 没有卫星定位或者卫星定位的坐标离基站太远（3000米），直接用基站定位坐标
if(!GPS_Located || GetDistance(dcBuff.dtuData.latitude, dcBuff.dtuData.longitude, DTU_latitude, DTU_longitude) >= 3000)
{
dcBuff.dtuData.longitude = DTU_longitude;
dcBuff.dtuData.latitude = DTU_latitude;
}
}
else if(!GPS_Located)
dcBuff.dtuData.recentPosState = 0;
}
// 本次定位结束
GPS_Located = 1;
// 下次有运动才定位（罐箱）
Motion_Detected = 0;
// 先清除信号量
GPRS_semSampled = 0;
// 采集数据
Sample_Notify();
tick = GetDelayTick(3000);
while(!GPRS_semSampled && !IsTickOut(tick))
{
}
// 记录本次发送的时间
GPRS_Send_Time = totalSeconds;
}
// 船级社维持时间计算
//CCS_Predict();
// 加入队列，待发送
printf("\nPut gprs data to queue...\n");
if(dcBuff.configDisplay.op_SERVER_PROTOCOL == SERVER_PROTOCOL_CHAOYANG)
LoopBuff_Clear(&gprsBuff);
GPRS_PutToQueue(&gprsBuff, &dcBuff.dtuData, &dcBuff.sampleData);
// 每条记录，北斗发送2次
if(BD_initStatus)
{
GPRS_PutToQueue(&bd_gprsBuff, &dcBuff.dtuData, &dcBuff.sampleData);
GPRS_PutToQueue(&bd_gprsBuff, &dcBuff.dtuData, &dcBuff.sampleData);
}
// 记录本次保存的时间
GPRS_Save_Time = totalSeconds;
}
}
// 用北斗发送数据
if(BD_initStatus && (semGPRS || semSync))
{
// 每采集1条就发送1条
if(LoopBuff_GetCount(&bd_gprsBuff) > 0)
{
if(Wakeup_GetWorkMode() == WORK_MODE_NORMAL)
{
// 打开北斗模块
BD_PowerOn();
if(BD_initStatus)
{
FRAM_BufferRead(LoopBuff_GetDataPos(&bd_gprsBuff, bd_gprsBuff.info.rdPtr), (uint8_t *) &gprsRWBuf, sizeof(gprs_data_t));
pGprs = &gprsRWBuf;
// 打包上报数据（按北斗精简报文的格式）
i = pack_bd_send_data(pGprs, totalSeconds);
bd_rf_app_send_data(i, Task_sendBuff);
delay_ms(200);
}
// 关闭北斗模块
BD_PowerOff();
}
// 不管是否发送成功，都移除记录（因为1分钟发送一次，没有重发机制）
LoopBuff_RemoveItems(&bd_gprsBuff, 1);
}
}
// 优先用射频发送数据
if(rf_has_gateway() && (semGPRS || semSync))
{
if(Wakeup_GetWorkMode() == WORK_MODE_NORMAL && GPRS_Send_Task)
{
// 关闭GPRS
DTU_PowerOff();
// 打开射频模块
RF_PowerOn();
k = LoopBuff_GetCount(&gprsBuff);
while(k--)
{
FRAM_BufferRead(LoopBuff_GetDataPos(&gprsBuff, gprsBuff.info.rdPtr), (uint8_t *) &gprsRWBuf, sizeof(gprs_data_t));
pGprs = &gprsRWBuf;
// 打包上报数据（按RF精简报文的格式）
i = pack_rf_send_data(pGprs, totalSeconds);
try_count = 3;
while(try_count--)
{
j = rf_app_send_data(i, Task_sendBuff);
if(j == 1)
{
rf_fail_count = 0;
LoopBuff_RemoveItems(&gprsBuff, 1);
break;
}
}
if(j == 0)
{
rf_fail_count++;
if(rf_fail_count >= 3)
{
// 清除网关信息
rf_fail_count = 0;
rf_clear_gateway();
}
// 下次再来
break;
}
}
// 关闭射频模块
RF_PowerOff();
}
}
// 如果没有卡，或者没有注册进网络，采集以后休眠
if(!dcBuff.dtuData.networked)
{
// 检查是否进入掉电模式
Wakeup_Powerdown();
continue;
}
// 检测发送采集数据的信号
if(semGPRS || semSync)
{
if(Wakeup_GetWorkMode() == WORK_MODE_NORMAL && GPRS_Send_Task)
{
// 是否下载参数：数据服务器
downloadParam = 0;
ackParam = 0;
if(dcBuff.configDisplay.op_SERVER_PROTOCOL == SERVER_PROTOCOL_HTTPS)
{
try_count = 2;
while((try_count--) && LoopBuff_GetCount(&gprsBuff) > 0)
{
// 第一条记录，连接就开始计数
if(LoopBuff_GetCount(&gprsBuff) > 0)
dcBuff.powerInfo.gprsSendCount++;
if(Sim808_Connect(1, dcBuff.configData.server, dcBuff.configData.port))
{
nextPtr = gprsBuff.info.rdPtr;
for(k = 0; k < LoopBuff_GetCount(&gprsBuff); k++)
{
if(k > 0) // 第一条发送计数在连接之前
dcBuff.powerInfo.gprsSendCount++;
FRAM_BufferRead(LoopBuff_GetDataPos(&gprsBuff, nextPtr), (uint8_t *) &gprsRWBuf, sizeof(gprs_data_t));
pGprs = &gprsRWBuf;
nextPtr = LoopBuff_GetNextPtr(&gprsBuff, nextPtr);
// 打包上报数据（按modbus从机响应的格式）
i = pack_json_send_data(pGprs, totalSeconds);
sprintf((char *) Task_sendBuff, http_header_fmt, SERVER_URLs[dcBuff.configDisplay.op_SERVER_INDEX], dcBuff.configData.server, i);
//printf("\n\n%s%s\n", Task_sendBuff, JSON_data());
recvLen = 0; // 发送HTTP头，完了直接返回，不等结果
if(!Sim808_SendAndRecv(1, Task_sendBuff, strlen((char *) Task_sendBuff), &recvLen, Task_recvBuff, sizeof(Task_recvBuff)))
break;
recvLen = 15; // 发送数据，完了等结果
if(!Sim808_SendAndRecv(1, (uint8_t *) JSON_data(), i, &recvLen, Task_recvBuff, sizeof(Task_recvBuff)))
break;
printf("\n\n%s\n", Task_recvBuff);
if(!strstr((char *) Task_recvBuff, "HTTP/1.1 200 OK"))
{
strcpy(dcBuff.powerInfo.gprsFailCode, "HTTP");
break;
}
dcBuff.powerInfo.gprsSuccCount++;
// 最近一条上传数据的采集时间
DTU_dataTime = pGprs->sample_time;
}
// 移除已成功发送的数据
if(k > 0)
LoopBuff_RemoveItems(&gprsBuff, k);
// 关闭和服务器的连接
DTU_Close(1);
}
}
}
else if(dcBuff.configDisplay.op_SERVER_PROTOCOL == SERVER_PROTOCOL_MQTT)
{
// 检查阿里云密钥是否有效，如无效则下载
try_count = 2;
while((try_count--) &&
(aliyunSecret.check != 0x55AA || memcmp(aliyunSecret.PSN, dcBuff.configBottle.PSN, 6) != 0))
{
// 连接升级服务器
if(Sim808_Connect(0, dcBuff.configData.upgServer, dcBuff.configData.upgPort))
{
printf("\nDownload aliyun secret ...\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(0xD037, 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)
{
if(recvLen >= sizeof(bluetooth_recv_t) + ALIYUN_SECRET_SIZE + 2
&& pRecv->cmd == ntohs(0x0037)
&& MODBUS_RTU_CRC16(Task_recvBuff, sizeof(bluetooth_recv_t) + ALIYUN_SECRET_SIZE + 2) == 0)
{
// 保存参数
memmove(aliyunSecret.PSN, dcBuff.configBottle.PSN, 6);
strcpy(aliyunSecret.product, (char *) Task_recvBuff + sizeof(bluetooth_recv_t));
strcpy(aliyunSecret.device, (char *) Task_recvBuff + sizeof(bluetooth_recv_t) + sizeof(aliyunSecret.product));
strcpy(aliyunSecret.secret, (char *) Task_recvBuff + sizeof(bluetooth_recv_t) + sizeof(aliyunSecret.product) + sizeof(aliyunSecret.device));
FRAM_SaveInfo(FRAM_ALIYUN_SECRET_BASE, (uint8_t *) &aliyunSecret, sizeof(aliyunSecret));
}
}
}
\
// 关闭和服务器的连接
DTU_Close(0);
}
}
try_count = 2;
while((try_count--) && aliyunSecret.check == 0x55AA
&& memcmp(aliyunSecret.PSN, dcBuff.configBottle.PSN, 6) == 0
&& LoopBuff_GetCount(&gprsBuff) > 0)
{
// 第一条记录，连接就开始计数
if(LoopBuff_GetCount(&gprsBuff) > 0)
dcBuff.powerInfo.gprsSendCount++;
if(Sim808_MqttConnect(SERVER_URLs[dcBuff.configDisplay.op_SERVER_INDEX], dcBuff.configData.port, aliyunSecret.product, aliyunSecret.device, aliyunSecret.secret))
{
nextPtr = gprsBuff.info.rdPtr;
for(k = 0; k < LoopBuff_GetCount(&gprsBuff); k++)
{
if(k > 0) // 第一条发送计数在连接之前
dcBuff.powerInfo.gprsSendCount++;
FRAM_BufferRead(LoopBuff_GetDataPos(&gprsBuff, nextPtr), (uint8_t *) &gprsRWBuf, sizeof(gprs_data_t));
pGprs = &gprsRWBuf;
nextPtr = LoopBuff_GetNextPtr(&gprsBuff, nextPtr);
// 打包上报数据（按modbus从机响应的格式）
i = pack_gprs_send_data(pGprs, totalSeconds);
if(!Sim808_MqttPublish(Task_sendBuff, i, aliyunSecret.product, aliyunSecret.device))
break;
dcBuff.powerInfo.gprsSuccCount++;
// 最近一条上传数据的采集时间
DTU_dataTime = pGprs->sample_time;
}
// 移除已成功发送的数据
if(k > 0)
LoopBuff_RemoveItems(&gprsBuff, k);
// 关闭和服务器的连接
MQTT_Close();
}
}
}
else if(dcBuff.configDisplay.op_SERVER_PROTOCOL == SERVER_PROTOCOL_TCP)
{
try_count = 2;
while((try_count--) && (LoopBuff_GetCount(&gprsBuff) > 0 // || Config_CheckUpdate(&dcBuff)
|| downloadParam || ackParam))
{
// 第一条记录，连接就开始计数
if(LoopBuff_GetCount(&gprsBuff) > 0)
dcBuff.powerInfo.gprsSendCount++;
if(Sim808_Connect(0, dcBuff.configData.server, dcBuff.configData.port))
{
// 普莱克斯、林德、宝钢的不再上传
if(dcBuff.configBottle.serverVer != 3 && dcBuff.configBottle.serverVer != 4 &&
dcBuff.configBottle.serverVer != 5
&& !dcBuff.configDisplay.op_UNIDIR_COMM && Config_CheckUpdate(&dcBuff))
{
printf("\nUpload 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;
// 打包参数
pParam = (param_data_t *) (Task_sendBuff + i);
pack_param_DO23_data(pParam);
i += sizeof(param_data_t);
// 填写固定字段
i = fill_biDir_fixFields(0xD023, 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
&& pRecv->cmd == ntohs(0x0023)
&& MODBUS_RTU_CRC16(Task_recvBuff, sizeof(bluetooth_recv_t) + 2) == 0)
{
// 清除更新标志，保存参数
dcBuff.configBottle.updateFlag = 0;
Config_SaveConfig();
// Can_Write(CONFIG_BOARD_SAMPLE,CAN_DC_BOTTLE_CONFIG, &display_modifi);
}
}
else
{
// 关闭和服务器的连接
DTU_Close(0);
// 重连
continue;
}
}
nextPtr = gprsBuff.info.rdPtr;
for(k = 0; k < LoopBuff_GetCount(&gprsBuff); k++)
{
if(k > 0) // 第一条发送计数在连接之前
dcBuff.powerInfo.gprsSendCount++;
FRAM_BufferRead(LoopBuff_GetDataPos(&gprsBuff, nextPtr), (uint8_t *) &gprsRWBuf, sizeof(gprs_data_t));
pGprs = &gprsRWBuf;
nextPtr = LoopBuff_GetNextPtr(&gprsBuff, nextPtr);
// 打包上报数据（按modbus从机响应的格式）
i = pack_gprs_send_data(pGprs, totalSeconds);
recvLen = 2;
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
break;
dcBuff.powerInfo.gprsSuccCount++;
// 最近一条上传数据的采集时间
DTU_dataTime = pGprs->sample_time;
// 从GPRS切换到RF，需要重新搜索网关
rf_fail_count = 0;
rf_clear_gateway();
if(!dcBuff.configDisplay.op_UNIDIR_COMM)
{
if(recvLen >= 2 && Task_recvBuff[0] == 0xFF && Task_recvBuff[1] == 0x0F)
{
// 普莱克斯、林德的不再下载
if(dcBuff.configBottle.serverVer != 3 && dcBuff.configBottle.serverVer != 4)
downloadParam = 1;
}
}
}
// 移除已成功发送的数据
if(k > 0)
LoopBuff_RemoveItems(&gprsBuff, 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;
// 宝钢版本：用D046替代D021, 因为服务器端没有完整的参数信息，只能修改个别参数
if(dcBuff.configBottle.serverVer == 5)
{
// 填写固定字段
i = fill_biDir_fixFields(0xD046, i);
}
else
{
// 参数时间戳
Int2ByteL(Task_sendBuff, i, htonl(dcBuff.configBottle.ts));
i += 4;
// 填写固定字段
i = fill_biDir_fixFields(0xD021, 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) + sizeof(param_data_t) + 2
&& pRecv->cmd == ntohs(0x0021)
&& MODBUS_RTU_CRC16(Task_recvBuff, sizeof(bluetooth_recv_t) + sizeof(param_data_t) + 2) == 0)
{
// 解析参数
pParam = (param_data_t *) (Task_recvBuff + sizeof(bluetooth_recv_t));
parse_param_D021_data(pParam);
// 清除更新标志，
dcBuff.configBottle.updateFlag = 0;
}
else if(recvLen >= sizeof(bluetooth_recv_t) + D046_PARAM_SIZE + 2
&& pRecv->cmd == ntohs(0x0046)
&& MODBUS_RTU_CRC16(Task_recvBuff, sizeof(bluetooth_recv_t) + D046_PARAM_SIZE + 2) == 0)
{
// 保存参数
parse_param_D046_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);
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;
}
// 关闭和服务器的连接
DTU_Close(0);
}
}
}
else if(dcBuff.configDisplay.op_SERVER_PROTOCOL == SERVER_PROTOCOL_AOYANG)
{
try_count = 2;
while((try_count--) && LoopBuff_GetCount(&gprsBuff) > 0)
{
// 第一条记录，连接就开始计数
if(LoopBuff_GetCount(&gprsBuff) > 0)
dcBuff.powerInfo.gprsSendCount++;
if(Sim808_Connect(0, dcBuff.configData.server, dcBuff.configData.port))
{
nextPtr = gprsBuff.info.rdPtr;
for(k = 0; k < LoopBuff_GetCount(&gprsBuff); k++)
{
if(k > 0) // 第一条发送计数在连接之前
dcBuff.powerInfo.gprsSendCount++;
FRAM_BufferRead(LoopBuff_GetDataPos(&gprsBuff, nextPtr), (uint8_t *) &gprsRWBuf, sizeof(gprs_data_t));
pGprs = &gprsRWBuf;
nextPtr = LoopBuff_GetNextPtr(&gprsBuff, nextPtr);
// 打包上报数据（按modbus从机响应的格式）
i = pack_aoyang_send_data(pGprs, totalSeconds);
printf("\ni=%d:%s\n", i, (char *) Task_sendBuff);
recvLen = 7;
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
break;
dcBuff.powerInfo.gprsSuccCount++;
// 最近一条上传数据的采集时间
DTU_dataTime = pGprs->sample_time;
// 从GPRS切换到RF，需要重新搜索网关
rf_fail_count = 0;
rf_clear_gateway();
}
// 移除已成功发送的数据
if(k > 0)
LoopBuff_RemoveItems(&gprsBuff, k);
// 关闭和服务器的连接
DTU_Close(0);
}
}
}
else if(dcBuff.configDisplay.op_SERVER_PROTOCOL == SERVER_PROTOCOL_BRASIL)
{
try_count = 2;
while((try_count--) && LoopBuff_GetCount(&gprsBuff) > 0)
{
// 第一条记录，连接就开始计数
if(LoopBuff_GetCount(&gprsBuff) > 0)
dcBuff.powerInfo.gprsSendCount++;
if(Sim808_Connect(0, dcBuff.configData.server, dcBuff.configData.port))
{
nextPtr = gprsBuff.info.rdPtr;
for(k = 0; k < LoopBuff_GetCount(&gprsBuff); k++)
{
if(k > 0) // 第一条发送计数在连接之前
dcBuff.powerInfo.gprsSendCount++;
FRAM_BufferRead(LoopBuff_GetDataPos(&gprsBuff, nextPtr), (uint8_t *) &gprsRWBuf, sizeof(gprs_data_t));
pGprs = &gprsRWBuf;
nextPtr = LoopBuff_GetNextPtr(&gprsBuff, nextPtr);
// 打包上报数据（按modbus从机响应的格式）
i = pack_brasil_send_data(pGprs, totalSeconds);
printf("\ni=%d:%s\n", i, (char *) Task_sendBuff);
recvLen = 47;
memset(Task_recvBuff, 0, sizeof(Task_recvBuff));
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE - 1))
break;
if(!parse_brasil_recv_data((char *) Task_recvBuff, pGprs, totalSeconds))
continue;
if(save_brasil_issue_parameters())
{
// 保存参数
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);
}
dcBuff.powerInfo.gprsSuccCount++;
// 最近一条上传数据的采集时间
DTU_dataTime = pGprs->sample_time;
// 从GPRS切换到RF，需要重新搜索网关
rf_fail_count = 0;
rf_clear_gateway();
}
// 移除已成功发送的数据
if(k > 0)
LoopBuff_RemoveItems(&gprsBuff, k);
// 关闭和服务器的连接
DTU_Close(0);
}
}
}
else if(dcBuff.configDisplay.op_SERVER_PROTOCOL == SERVER_PROTOCOL_FURUI
|| dcBuff.configDisplay.op_SERVER_PROTOCOL == SERVER_PROTOCOL_HUIDA)
{
try_count = 2;
while((try_count--) && LoopBuff_GetCount(&gprsBuff) > 0)
{
// 第一条记录，连接就开始计数
if(LoopBuff_GetCount(&gprsBuff) > 0)
dcBuff.powerInfo.gprsSendCount++;
if(Sim808_Connect(0, dcBuff.configData.server, dcBuff.configData.port))
{
nextPtr = gprsBuff.info.rdPtr;
for(k = 0; k < LoopBuff_GetCount(&gprsBuff); k++)
{
if(k > 0) // 第一条发送计数在连接之前
dcBuff.powerInfo.gprsSendCount++;
FRAM_BufferRead(LoopBuff_GetDataPos(&gprsBuff, nextPtr), (uint8_t *) &gprsRWBuf, sizeof(gprs_data_t));
pGprs = &gprsRWBuf;
nextPtr = LoopBuff_GetNextPtr(&gprsBuff, nextPtr);
// 打包上报数据（按modbus从机响应的格式）
if(dcBuff.configDisplay.op_SERVER_PROTOCOL == SERVER_PROTOCOL_FURUI)
i = pack_furui_send_data(pGprs, &relativeTime);
else
i = pack_huida_send_data(pGprs, &relativeTime);
printf("\nSend %d bytes to server:\n", i);
for(j = 0; j < i; j++)
printf("%02X ", Task_sendBuff[j]);
printf("\n");
recvLen = 6;
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
break;
if((dcBuff.configDisplay.op_SERVER_PROTOCOL == SERVER_PROTOCOL_FURUI && !parse_furui_recv_data(dcBuff.configBottle.PSN, relativeTime, recvLen))
|| (dcBuff.configDisplay.op_SERVER_PROTOCOL == SERVER_PROTOCOL_HUIDA && !parse_huida_recv_data(dcBuff.configBottle.PSN, relativeTime, recvLen)))
{
break;
}
dcBuff.powerInfo.gprsSuccCount++;
// 最近一条上传数据的采集时间
DTU_dataTime = pGprs->sample_time;
// 从GPRS切换到RF，需要重新搜索网关
rf_fail_count = 0;
rf_clear_gateway();
}
// 移除已成功发送的数据
if(k > 0)
LoopBuff_RemoveItems(&gprsBuff, k);
// 关闭和服务器的连接
DTU_Close(0);
}
}
}
else if(dcBuff.configDisplay.op_SERVER_PROTOCOL == SERVER_PROTOCOL_CHAOYANG)
{
try_count = 2;
while((try_count--) && LoopBuff_GetCount(&gprsBuff) > 0)
{
// 第一条记录，连接就开始计数
if(LoopBuff_GetCount(&gprsBuff) > 0)
dcBuff.powerInfo.gprsSendCount++;
if(Sim808_Connect(0, dcBuff.configData.server, dcBuff.configData.port))
{
nextPtr = gprsBuff.info.rdPtr;
for(k = 0; k < LoopBuff_GetCount(&gprsBuff); k++)
{
if(k > 0) // 第一条发送计数在连接之前
dcBuff.powerInfo.gprsSendCount++;
FRAM_BufferRead(LoopBuff_GetDataPos(&gprsBuff, nextPtr), (uint8_t *) &gprsRWBuf, sizeof(gprs_data_t));
pGprs = &gprsRWBuf;
nextPtr = LoopBuff_GetNextPtr(&gprsBuff, nextPtr);
// 打包上报数据（按modbus从机响应的格式）
i = pack_chaoyang_send_data(pGprs, &relativeTime);
printf("\nSend %d bytes to server:\n", i);
for(j = 0; j < i; j++)
printf("%c", Task_sendBuff[j]);
printf("\n");
recvLen = 0; // 服务器无应答
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
break;
dcBuff.powerInfo.gprsSuccCount++;
// 最近一条上传数据的采集时间
DTU_dataTime = pGprs->sample_time;
// 从GPRS切换到RF，需要重新搜索网关
rf_fail_count = 0;
rf_clear_gateway();
}
// 移除已成功发送的数据
if(k > 0)
LoopBuff_RemoveItems(&gprsBuff, k);
// 关闭和服务器的连接
DTU_Close(0);
}
}
}
// 是否连接维护平台：每隔12小时一次（普莱克斯、林德的每次连接）
if(dcBuff.configBottle.serverVer == 3 || dcBuff.configBottle.serverVer == 4 ||
(!dcBuff.configDisplay.op_UNIDIR_COMM &&
(totalSeconds < INITIAL_TRAN_COUNT * (dcBuff.configData.intervalSample > 300 ? 300 : dcBuff.configData.intervalSample)
|| totalSeconds + 3 >= DTU_ldmsTime + 43200 || DTU_ldmsConn)))
{
// 清除强制连接维护平台标志
DTU_ldmsConn = 0;
// 保存连接维护平台时间（刚复位时连续上传6次，但只保存第一次）
if(totalSeconds >= 3600)
DTU_ldmsTime = totalSeconds;
// 是否升级或下载参数：维护平台
upgrade = 0;
ackUpgrade = 0;
downloadParam = 0;
ackParam = 0;
downloadConfig = 0;
ackConfig = 0;
reset = 0;
k = 1; // 发送1条诊断信息
try_count = 2;
while((try_count--) && (k || upgrade || ackUpgrade || downloadParam || ackParam || downloadConfig || ackConfig))
{
// 连接升级服务器
if(Sim808_Connect(0, dcBuff.configData.upgServer, dcBuff.configData.upgPort))
{
if(k)
{
// 发送诊断信息，至少接收12个字节
i = pack_ldms_info_Ext_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(0x0045))
{
upgrade = Task_recvBuff[sizeof(bluetooth_recv_t)];
downloadParam = Task_recvBuff[sizeof(bluetooth_recv_t) + 1];
downloadConfig = Task_recvBuff[sizeof(bluetooth_recv_t) + 2];
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(0xD046, 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) + D046_PARAM_SIZE + 2
&& pRecv->cmd == ntohs(0x0046)
&& MODBUS_RTU_CRC16(Task_recvBuff, sizeof(bluetooth_recv_t) + D046_PARAM_SIZE + 2) == 0)
{
// 保存参数
if(parse_param_D046_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(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(0xD048, 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) + D048_CONFIG_SIZE + 2
&& pRecv->cmd == ntohs(0x0048)
&& MODBUS_RTU_CRC16(Task_recvBuff, sizeof(bluetooth_recv_t) + D048_CONFIG_SIZE + 2) == 0)
{
// 保存参数
if(parse_config_D048_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();
}
}
}
}
}
// 刚处理完，清除等待的信号。等下一个周期再执行（如果有报警必须立即上传）
if(dcBuff.sampleData.warnning == 0)
DTU_semGPRS = 0;
}
// 检测发送GPS定位信号
if(semGPS || semSync)
{
if(Wakeup_GetWorkMode() == WORK_MODE_NORMAL)
{
if(dcBuff.configDisplay.op_SEND_GPS_DATA && Sim808_Connect(0, dcBuff.configData.gpsServer, dcBuff.configData.gpsPort))
{
// 如果有待发送数据
do
{
// 根据发送缓冲区的大小，决定一次最多发几条数据
// 每条记录占12个字节，另外有24个字节的固定字段，比如头信息、PSN、crc等
// 如果没有合法的记录，发送一条空记录
gpsCount = GPS_LookData((TASK_SENDBUFF_SIZE - 24) / 12, &gpsInterval, &gpsDone);
if(gpsCount > 0)
{
nextPtr = gpsBuff.info.rdPtr;
FRAM_BufferRead(LoopBuff_GetDataPos(&gpsBuff, nextPtr), (uint8_t *) &gps, sizeof(gps_data_t));
}
memset(Task_sendBuff, 0, TASK_SENDBUFF_SIZE);
i = sizeof(bluetooth_send_t);
// PSN
memmove(Task_sendBuff + i, dcBuff.configBottle.PSN, 6);
i += 6;
// 坐标个数
if(gpsCount > 0)
Int2ByteS(Task_sendBuff, i, htons(gpsCount));
else
Int2ByteS(Task_sendBuff, i, htons(1));
i += 2;
// 起始时间戳
if(gpsCount > 0)
Int2ByteL(Task_sendBuff, i, htonl(gps.time.tm));
i += 4;
// 时间戳增量
if(gpsCount > 0)
Int2ByteS(Task_sendBuff, i, htons(gpsInterval));
i += 2;
for(j = 0; j < (gpsCount ? gpsCount : 1); j++)
{
// 状态
if(gpsCount > 0)
Task_sendBuff[i] = gps.state;
else
{
// 车辆是否启动（根据充电状态决定）
if(VCC_POWER_STATUS())
Task_sendBuff[i] |= (1 << 6);
// 车辆启动状态是否改变）
Task_sendBuff[i] |= (bat_CurrentEvent << 7);
bat_CurrentEvent = 0;
}
i++;
// 保留
i++;
// 经度
if(gpsCount > 0)
Int2ByteL(Task_sendBuff, i, htonl(gps.longitude));
i += 4;
// 纬度
if(gpsCount > 0)
Int2ByteL(Task_sendBuff, i, htonl(gps.latitude));
i += 4;
// 速度
if(gpsCount > 0)
Int2ByteS(Task_sendBuff, i, htons(gps.speed * 100));
i += 2;
nextPtr = LoopBuff_GetNextPtr(&gpsBuff, nextPtr);
FRAM_BufferRead(LoopBuff_GetDataPos(&gpsBuff, nextPtr), (uint8_t *) &gps, sizeof(gps_data_t));
}
// 填写固定字段
i = fill_biDir_fixFields(0xD010, i);
// 发送i个字节到服务器，至少接收10个字节
// 如果失败，下次再发送
recvLen = sizeof(bluetooth_recv_t) + 2;
if(!Sim808_SendAndRecv(0, Task_sendBuff, i, &recvLen, Task_recvBuff, TASK_RECVBUFF_SIZE))
break;
if(gpsCount > 0)
{
// 将这几条记录移除
GPS_MoveFromQueue(gpsCount);
if(gpsDone)
{
GPS_Located = 1;
// 停止超时定时器
GPS_Waiting = 0;
}
}
} while(!gpsDone);
}
// 无论如何，关闭和服务器的连接
DTU_Close(0);
// 刚处理完，清除等待的信号。等下一个周期再执行
DTU_semGPS = 0;
}
}
if(semSync)
{
// 刚处理完，清除等待的信号。等下一个周期再执行
DTU_semSync = 0;
}
// 检查是否进入掉电模式
Wakeup_Powerdown();
}
}
Reference in New Issue View Git Blame Copy Permalink