945 lines
31 KiB
C
945 lines
31 KiB
C
/*
|
|
* dbn_ble_srv.c
|
|
*
|
|
* Created on: Aug 27, 2024
|
|
* Author: Thinkpad
|
|
*/
|
|
|
|
#include "dbn_ble_srv.h"
|
|
#include "cmcng.h"
|
|
#include "storage.h"
|
|
#include <string.h>
|
|
#include "net_srv.h"
|
|
|
|
|
|
uint8_t g_flag_notify_temp = 0; //临时通知notify flag, 0 disable, 1 enable
|
|
|
|
BLE_Notify_Buf g_notify_buftemp = {0,0, ""};
|
|
BLE_Notify_Buf g_ble_rcv_buf = {0,0, ""};
|
|
BLE_Notify_Buf g_tmp_report_buf = {0,0, ""};
|
|
|
|
Buf_DBN_BLE g_buf_ble_response = {0,0,0,0,0,0,0,""};
|
|
|
|
DBN_BLE_State g_dbn_ble_state_acs_enable = {0};
|
|
|
|
uint8_t tmp_ble_buf[MAX_BLE_TMP_BUF_LEN] = "";
|
|
|
|
extern uint8_t loop1_FLAG_CUT;
|
|
|
|
|
|
void clear_ble_notify_buf(BLE_Notify_Buf * buf)
|
|
{
|
|
buf->len = 0;
|
|
buf->flag = 0;
|
|
memset(buf, 0, MAX_BLE_Notify_Buf_LEN);
|
|
}
|
|
|
|
void clear_buf_dbn_ble(Buf_DBN_BLE * buf)
|
|
{
|
|
uint8_t i = 0;
|
|
|
|
|
|
buf->flag = 0;
|
|
buf->magic = 0;
|
|
buf->cmd = 0;
|
|
memset(buf->dat, 0, buf->dat_len);
|
|
buf->dat_len = 0;
|
|
buf->dat_offset = 0;
|
|
buf->pkg_amount = 0;
|
|
buf->pkg_seq = 0;
|
|
}
|
|
|
|
void clear_buf_dbn_ble_all(Buf_DBN_BLE * buf)
|
|
{
|
|
uint8_t i = 0;
|
|
// if(g_flag_debug)
|
|
{
|
|
// PRINT("\nclear_buf_dbn_ble_flag:%02X,magic:%02X,pkg_amount:%02X,seq:%02X,cmd:%02X, dat_len:%d,offset:%d\n",
|
|
// buf->flag,buf->magic,buf->pkg_amount, buf->pkg_seq,buf->cmd, buf->dat_len,buf->dat_offset);
|
|
// for(i = 0; i < buf->dat_len; i++)
|
|
// {
|
|
// PRINT(" %02X", buf->dat[i]);
|
|
// }
|
|
// PRINT("\n");
|
|
}
|
|
buf->flag = 0;
|
|
buf->magic = 0;
|
|
buf->cmd = 0;
|
|
memset(buf->dat, 0, MAX_BLE_BUF_LEN);
|
|
buf->dat_len = 0;
|
|
buf->dat_offset = 0;
|
|
buf->pkg_amount = 0;
|
|
buf->pkg_seq = 0;
|
|
}
|
|
|
|
|
|
// 0: 包检测异常
|
|
//检测包是否完整，Magic Byte, Header Byte, CK Byte, 校验字节（异或校验，以及和校验）
|
|
uint8_t check_pkg(uint8_t * pkg, uint8_t len)
|
|
{
|
|
if(len < 6) //min length of ble pkg is 6
|
|
return 0;
|
|
uint8_t magic = pkg[0];
|
|
uint8_t _len = pkg[2]; //data_len
|
|
if(magic == 0x9F){
|
|
// if(_len + 4 < len){
|
|
// return 0;
|
|
// }
|
|
if(pkg[1] == 0x01 && pkg[2] == 0x00 && pkg[3] == 0x01 && pkg[4] == 0xA5 && pkg[5] == 0xA7){
|
|
g_flag_counter_ota.tick = 0;
|
|
g_flag_counter_ota.flag = 1;
|
|
PRINT("Come into OTA___\n");
|
|
}
|
|
}
|
|
if(_len + 5 < len)
|
|
{
|
|
return 0;
|
|
}
|
|
uint8_t _dxor = 0;
|
|
uint8_t _dsum = 0;
|
|
uint8_t _cklen = _len + 3; //不计算 校验字节
|
|
uint8_t i = 0;
|
|
for(i = 1; i < _cklen; i++)
|
|
{
|
|
_dxor ^= pkg[i];
|
|
_dsum += pkg[i];
|
|
}
|
|
if((_dxor != pkg[_cklen]) || (_dsum != pkg[_cklen+1]))
|
|
{
|
|
// if(g_flag_debug)
|
|
// {
|
|
// PRINT("_dxor:0x%02X - 0x%02X, _dsum:0x%02X - 0x%02X\r\n", _dxor, pkg[_cklen], _dsum, pkg[_cklen + 1] );
|
|
// }
|
|
return 0;
|
|
}
|
|
|
|
return magic;
|
|
}
|
|
|
|
static uint8_t set_dev_info_to_ready(uint8_t *dat_dst)
|
|
{
|
|
uint8_t i = 0, j = 0;
|
|
for(i = 0; i < 6; i++)
|
|
{
|
|
dat_dst[i] = gMacAddr[i];
|
|
// PRINT(" %02X",dat_dst[i] );
|
|
}
|
|
// memcpy(dat_dst, MACAddr, sizeof(MACAddr));
|
|
// i += sizeof(MACAddr);
|
|
dat_dst[i++] = HARDWARE_VER_MAIN;
|
|
dat_dst[i++] = HARDWARE_VER_SUB;
|
|
dat_dst[i++] = FIRMWARE_VER_MAIN;
|
|
dat_dst[i++] = FIRMWARE_VER_SUB;
|
|
|
|
// Dev Model
|
|
dat_dst[i++] = strlen(PRODUCT_MODEL);
|
|
memcpy(&dat_dst[i], PRODUCT_MODEL, strlen(PRODUCT_MODEL));
|
|
i += strlen(PRODUCT_MODEL);
|
|
|
|
// Dev Number
|
|
for(j = 0; j < 6; j++, i++)
|
|
{
|
|
dat_dst[i] = g_dev_number[j];
|
|
}
|
|
// sub_code
|
|
// memcpy(&dat_dst[i], &(g_sub_code_enable.code_set), sizeof(g_sub_code_enable.code_set));
|
|
// i += sizeof(g_sub_code_enable.code_set);
|
|
dat_dst[i++] = 0;
|
|
dat_dst[i++] = 0;
|
|
|
|
|
|
dat_dst[i++] = 0; // g_bus_dus_amount_stored.bus1_amount;
|
|
dat_dst[i++] = 0; //g_bus_dus_amount_stored.bus2_amount;
|
|
return i;
|
|
}
|
|
|
|
static uint8_t set_net_info_to_ready(uint8_t * dat_dst)
|
|
{
|
|
uint8_t i = 0;
|
|
memcpy(&dat_dst[i], local_net_cfg.lip, 4);
|
|
i += 4;
|
|
memcpy(&dat_dst[i], local_net_cfg.sub, 4);
|
|
i += 4;
|
|
memcpy(&dat_dst[i], local_net_cfg.gw, 4);
|
|
i += 4;
|
|
memcpy(&dat_dst[i], net_center_info.lssc_ip, 4);
|
|
i += 4;
|
|
memcpy(&dat_dst[i], local_net_cfg.dns, 4);
|
|
i += 4;
|
|
dat_dst[i++] = local_net_cfg.port_ssc_tcp;
|
|
dat_dst[i++] = local_net_cfg.port_ssc_tcp >> 8;
|
|
dat_dst[i++] = local_net_cfg.port_ssc_udp;
|
|
dat_dst[i++] = local_net_cfg.port_ssc_udp >> 8;
|
|
dat_dst[i++] = local_net_cfg.port_ssc_udp_message;
|
|
dat_dst[i++] = local_net_cfg.port_ssc_udp_message >> 8;
|
|
|
|
dat_dst[i++] = local_net_cfg.port_dev_tcp;
|
|
dat_dst[i++] = local_net_cfg.port_dev_tcp >> 8;
|
|
dat_dst[i++] = local_net_cfg.port_dev_udp;
|
|
dat_dst[i++] = local_net_cfg.port_dev_udp >> 8;
|
|
|
|
return i;
|
|
}
|
|
|
|
void set_response_iot_net(Buf_DBN_BLE *response_dst)
|
|
{ // config iot_net
|
|
uint8_t ret = 0;
|
|
uint8_t i = 0;
|
|
int _len = 0;
|
|
clear_buf_dbn_ble(response_dst);
|
|
response_dst->magic = MAGIC_BYTE_DBN_DEFAULT;
|
|
response_dst->cmd = CMD_DBN_GET_IOT_NET;
|
|
|
|
memcpy(response_dst->dat, iot_net_info.remote_addr, strlen(iot_net_info.remote_addr));
|
|
i += strlen(iot_net_info.remote_addr);
|
|
i++;
|
|
_len = sprintf(&(response_dst->dat[i]), "%d", iot_net_info.mqtt_port);
|
|
i += _len;
|
|
i++;
|
|
memcpy(&(response_dst->dat[i]), iot_net_info.client_id, strlen(iot_net_info.client_id));
|
|
i += strlen(iot_net_info.client_id);
|
|
i++;
|
|
memcpy(&(response_dst->dat[i]), iot_net_info.username, strlen(iot_net_info.username));
|
|
i += strlen(iot_net_info.username);
|
|
i++;
|
|
memcpy(&(response_dst->dat[i]), iot_net_info.password, strlen(iot_net_info.password));
|
|
i += strlen(iot_net_info.password);
|
|
response_dst->dat_len = i;
|
|
response_dst->pkg_amount = i / MAX_BLE_DAT_RESPONSE_LEN;
|
|
if((i % MAX_BLE_DAT_RESPONSE_LEN) > 0)
|
|
{
|
|
response_dst->pkg_amount += 1;
|
|
}
|
|
response_dst->pkg_seq = 0;
|
|
|
|
response_dst->flag = 1;
|
|
}
|
|
|
|
void set_response_iot_topic(Buf_DBN_BLE *response_dst)
|
|
{ //config iot_topic
|
|
uint8_t ret = 0;
|
|
uint8_t i = 0;
|
|
int _len = 0;
|
|
clear_buf_dbn_ble(response_dst);
|
|
response_dst->magic = MAGIC_BYTE_DBN_DEFAULT;
|
|
response_dst->cmd = CMD_DBN_GET_IOT_TOPIC;
|
|
response_dst->dat[0] = g_iot_topic.clientid_enable + 0x30;
|
|
i++;
|
|
i++;
|
|
memcpy(&(response_dst->dat[i]), g_iot_topic.topic_pub, strlen(g_iot_topic.topic_pub));
|
|
i += strlen(g_iot_topic.topic_pub);
|
|
i++;
|
|
memcpy(&(response_dst->dat[i]), g_iot_topic.topic_sub, strlen(g_iot_topic.topic_sub));
|
|
i += strlen(g_iot_topic.topic_sub);
|
|
response_dst->dat_len = i;
|
|
response_dst->pkg_amount = i / MAX_BLE_DAT_RESPONSE_LEN;
|
|
if((i % MAX_BLE_DAT_RESPONSE_LEN) > 0)
|
|
{
|
|
response_dst->pkg_amount += 1;
|
|
}
|
|
response_dst->pkg_seq = 0;
|
|
response_dst->flag = 1;
|
|
}
|
|
|
|
|
|
uint8_t set_response_buf(Buf_DBN_BLE *response_dst, uint8_t magic, uint8_t cmd, uint8_t * dat, uint8_t dat_len)
|
|
{
|
|
uint8_t ret = 0;
|
|
uint8_t i = 0;
|
|
clear_buf_dbn_ble(response_dst);
|
|
response_dst->magic = magic;
|
|
response_dst->cmd = cmd;
|
|
|
|
uint8_t _amount = dat_len / MAX_BLE_DAT_RESPONSE_LEN;
|
|
if((dat_len % MAX_BLE_DAT_RESPONSE_LEN) > 0)
|
|
{
|
|
_amount++;
|
|
}
|
|
response_dst->pkg_amount = _amount;
|
|
response_dst->pkg_seq = 0;
|
|
response_dst->dat_len = dat_len;
|
|
for(i = 0; i < dat_len; i++)
|
|
{
|
|
response_dst->dat[i] = dat[i];
|
|
}
|
|
response_dst->flag = 1;
|
|
|
|
return ret;
|
|
}
|
|
|
|
uint16_t compute_ckb(uint8_t header_0, uint8_t header_1, uint8_t header_cmd, uint8_t *dat, uint8_t dat_len)
|
|
{
|
|
uint16_t ret = 0;
|
|
uint8_t i = 0;
|
|
uint8_t _dxor = header_0 ^ header_1 ^ header_cmd;
|
|
uint8_t _dsum = header_0 + header_1 + header_cmd;
|
|
|
|
for(i = 0; i < dat_len; i++)
|
|
{
|
|
_dxor ^= dat[i];
|
|
_dsum += dat[i];
|
|
}
|
|
ret = _dxor;
|
|
ret = (ret << 8) + (_dsum % 0x100);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
uint8_t set_response_tran_to_notify(uint8_t *dat_ori, uint8_t dat_len, BLE_Notify_Buf * notify_dst)
|
|
{
|
|
uint8_t ret = 0;
|
|
uint8_t i = 0;
|
|
if(g_flag_bt_state == 0){
|
|
return ret;
|
|
}
|
|
if(notify_dst->flag)
|
|
{ //dst not idle
|
|
return ret;
|
|
}
|
|
if(dat_len < 6)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
for(i = 0; i < dat_len; i++)
|
|
{
|
|
notify_dst->buf[i] = dat_ori[i];
|
|
}
|
|
notify_dst->len = dat_len;
|
|
notify_dst->flag = 1;
|
|
}
|
|
|
|
|
|
//response_ori must set_response_buf first
|
|
uint8_t set_response_to_notify(Buf_DBN_BLE *response_ori, BLE_Notify_Buf * notify_dst)
|
|
{
|
|
uint8_t ret = 0;
|
|
uint8_t i = 0;
|
|
uint16_t _ckbl = 0;
|
|
if(notify_dst->flag)
|
|
{ //dst not idle
|
|
return ret;
|
|
}
|
|
if(response_ori->flag == 0)
|
|
{ //ori idle
|
|
return ret;
|
|
}
|
|
if(response_ori->pkg_amount <= 1)
|
|
{
|
|
//没有分包的情况
|
|
notify_dst->buf[0] = response_ori->magic;
|
|
if(response_ori->magic == MAGIC_BYTE_DBN_TRANSPARENT)
|
|
{
|
|
notify_dst->buf[1] = response_ori->pkg_seq;
|
|
}
|
|
else
|
|
{
|
|
notify_dst->buf[1] = 0;
|
|
}
|
|
notify_dst->buf[2] = response_ori->dat_len + 1; // 1 is cmd_byte
|
|
notify_dst->buf[3] = response_ori->cmd;
|
|
_ckbl = compute_ckb(notify_dst->buf[1], notify_dst->buf[2], notify_dst->buf[3], response_ori->dat, response_ori->dat_len);
|
|
for(i = 0; i < response_ori->dat_len; i++)
|
|
{
|
|
notify_dst->buf[i + 4] = response_ori->dat[i];
|
|
}
|
|
notify_dst->buf[i + 4] = (uint8_t)(_ckbl >> 8);
|
|
i++;
|
|
notify_dst->buf[i + 4] = (uint8_t)(_ckbl);
|
|
i++;
|
|
notify_dst->len = i + 4;
|
|
// if(g_flag_debug)
|
|
// {
|
|
// PRINT("set_response_to_notify_dst__\n");
|
|
// for(i = 0; i < notify_dst->len; i++)
|
|
// {
|
|
// PRINT(" %02X", notify_dst->buf[i]);
|
|
// }
|
|
// }
|
|
notify_dst->flag = 1;
|
|
|
|
clear_buf_dbn_ble(response_ori);
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
notify_dst->buf[0] = response_ori->magic;
|
|
uint8_t _pkg_amount = response_ori->pkg_amount;
|
|
uint8_t _pkg_seq = response_ori->pkg_seq;
|
|
uint8_t _remain_len = response_ori->dat_len - response_ori->dat_offset;
|
|
if(_remain_len > MAX_BLE_DAT_RESPONSE_LEN)
|
|
{
|
|
_remain_len = MAX_BLE_DAT_RESPONSE_LEN;
|
|
}
|
|
_pkg_seq += 1;
|
|
notify_dst->buf[1] = (_pkg_amount << 4)|(_pkg_seq);
|
|
notify_dst->buf[2] = _remain_len + 1; // 1 is cmd_byte
|
|
notify_dst->buf[3] = response_ori->cmd;
|
|
|
|
_ckbl = compute_ckb(notify_dst->buf[1], notify_dst->buf[2], notify_dst->buf[3],
|
|
&(response_ori->dat[response_ori->dat_offset]), _remain_len);
|
|
for(i = 0; i < _remain_len; i++)
|
|
{
|
|
notify_dst->buf[i + 4] = response_ori->dat[response_ori->dat_offset + i];
|
|
}
|
|
notify_dst->buf[i + 4] = (uint8_t)(_ckbl >> 8);
|
|
i++;
|
|
notify_dst->buf[i + 4] = (uint8_t)(_ckbl);
|
|
i++;
|
|
|
|
response_ori->dat_offset += _remain_len;
|
|
response_ori->pkg_seq += 1;
|
|
notify_dst->len = i + 4;
|
|
|
|
|
|
// if(g_flag_debug)
|
|
// {
|
|
// PRINT("\nset_notify_dst,amount:%d,seq:%d,offset:%d\n", response_ori->pkg_amount,response_ori->pkg_seq, response_ori->dat_offset);
|
|
// for(i = 0; i < notify_dst->len; i++)
|
|
// {
|
|
// PRINT(" %02X", notify_dst->buf[i]);
|
|
// }
|
|
// PRINT("\n");
|
|
// }
|
|
|
|
notify_dst->flag = 1;
|
|
if(response_ori->pkg_amount == response_ori->pkg_seq)
|
|
{
|
|
clear_buf_dbn_ble(response_ori);
|
|
}
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static uint8_t unpack_packs(uint8_t *pkg, uint8_t len)
|
|
{
|
|
static uint8_t _offset = 0;
|
|
uint8_t _header_0 = pkg[1];
|
|
uint8_t _header_0_high = _header_0 >> 4;
|
|
uint8_t _header_0_low = _header_0 % 0x10;
|
|
uint8_t _len = pkg[2];
|
|
uint8_t _cmd = pkg[3];
|
|
uint8_t i = 0, j = 0, k = 0;
|
|
uint8_t _amount = 0;
|
|
|
|
if(_header_0_high)
|
|
{
|
|
if(_header_0_low == 1)
|
|
{
|
|
g_buf_ble_response.magic = pkg[0];
|
|
g_buf_ble_response.pkg_amount = _header_0_high;
|
|
g_buf_ble_response.pkg_seq = _header_0_low;
|
|
g_buf_ble_response.cmd = _cmd;
|
|
memcpy(&g_buf_ble_response.dat, &pkg[4], _len - 1);
|
|
_offset = _len - 1;
|
|
g_buf_ble_response.dat_len = _len - 1;
|
|
}
|
|
else
|
|
{
|
|
if((g_buf_ble_response.pkg_amount != _header_0_high) || (g_buf_ble_response.cmd != _cmd))
|
|
{
|
|
//printf("\nNot_the_right_sub_pack!\n");
|
|
clear_buf_dbn_ble_all(&g_buf_ble_response);
|
|
return 0;
|
|
}
|
|
if(g_buf_ble_response.pkg_seq != (_header_0_low -1))
|
|
{
|
|
//printf("\nNot_the_right_sub_pack!!\n");
|
|
clear_buf_dbn_ble_all(&g_buf_ble_response);
|
|
return 0;
|
|
}
|
|
g_buf_ble_response.pkg_seq = _header_0_low;
|
|
g_buf_ble_response.dat_len += (_len - 1); // not include cmd_byte
|
|
memcpy(&g_buf_ble_response.dat[_offset], &pkg[4], _len - 1);
|
|
_offset += (_len - 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
clear_buf_dbn_ble(&g_buf_ble_response);
|
|
g_buf_ble_response.magic = pkg[0];
|
|
g_buf_ble_response.pkg_amount = 1;
|
|
g_buf_ble_response.pkg_seq = 0;
|
|
g_buf_ble_response.cmd = _cmd;
|
|
g_buf_ble_response.dat_len = (_len - 1);
|
|
memcpy(g_buf_ble_response.dat, &pkg[4], _len - 1);
|
|
}
|
|
|
|
if(_header_0_high == _header_0_low)
|
|
{
|
|
// received end.
|
|
// if(g_flag_debug)
|
|
// {
|
|
// printf("\nReceive_pack_over:\n");
|
|
// for(i = 0; i < g_buf_ble_response.dat_len; i++)
|
|
// {
|
|
// printf(" %02X", g_buf_ble_response.dat[i]);
|
|
// }
|
|
// printf("\nEnd\n");
|
|
// }
|
|
|
|
|
|
if(g_buf_ble_response.cmd == CMD_DBN_CHECK_PASS)
|
|
{
|
|
memset(tmp_ble_buf, 0, MAX_BLE_TMP_BUF_LEN);
|
|
if(g_buf_ble_response.dat_len != 6)
|
|
{
|
|
//response pass failed
|
|
tmp_ble_buf[0] = 0x01;
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, 1);
|
|
}
|
|
else
|
|
{
|
|
char _pass = check_ble_safe_pass(g_buf_ble_response.dat);
|
|
if(_pass)
|
|
{
|
|
//response ok
|
|
tmp_ble_buf[0] = 0x0;
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, 1);
|
|
}
|
|
else
|
|
{
|
|
//response failed
|
|
tmp_ble_buf[0] = 0x01;
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, 1);
|
|
}
|
|
}
|
|
|
|
} //end if g_buf_ble_response.cmd == CMD_DBN_CHECK_PASS
|
|
else if(g_buf_ble_response.cmd == CMD_DBN_MODIFY_PASS)
|
|
{
|
|
memset(tmp_ble_buf, 0, MAX_BLE_TMP_BUF_LEN);
|
|
if(g_buf_ble_response.dat_len != 12)
|
|
{
|
|
//response failed
|
|
tmp_ble_buf[0] = 0x01;
|
|
}
|
|
else
|
|
{
|
|
char _pass = check_ble_safe_pass(g_buf_ble_response.dat);
|
|
if(_pass)
|
|
{
|
|
//response ok
|
|
set_ble_safe_pass(&g_buf_ble_response.dat[6]);
|
|
tmp_ble_buf[0] = 0x00;
|
|
}
|
|
else
|
|
{
|
|
//response failed
|
|
tmp_ble_buf[0] = 0x01;
|
|
}
|
|
}
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, 1);
|
|
} //end if g_buf_ble_response.cmd == CMD_DBN_MODIFY_PASS
|
|
else if(g_buf_ble_response.cmd == CMD_DBN_SET_SUB_CODE){
|
|
g_sub_code_enable.code_set = pkg[4] | (pkg[5] << 8);
|
|
PRINT("\nWill_set_sub_code:0x%04X\n", g_sub_code_enable.code_set);
|
|
|
|
g_sub_code_enable.net_enable = g_sub_code_enable.code_set & 0x01;
|
|
g_sub_code_enable.iot_enable = (g_sub_code_enable.code_set >> 1) & 0x01;
|
|
g_sub_code_enable.custom_enable = (g_sub_code_enable.code_set >> 2) & 0x01;
|
|
g_sub_code_enable.loop_enable = (g_sub_code_enable.code_set >> 3) & 0x01;
|
|
g_sub_code_enable.dgdus_enable = (g_sub_code_enable.code_set >> 4) & 0x01;
|
|
g_sub_code_enable.wbdus_enable = (g_sub_code_enable.code_set >> 5) & 0x01;
|
|
g_sub_code_enable.radar_enable = (g_sub_code_enable.code_set >> 6) & 0x01;
|
|
g_sub_code_enable.laser_enable = (g_sub_code_enable.code_set >> 9) & 0x01;
|
|
g_sub_code_enable.lora_enable = (g_sub_code_enable.code_set >> 15) & 0x01;
|
|
|
|
|
|
update_sub_code_enable();
|
|
}
|
|
else if(g_buf_ble_response.cmd == CMD_DBN_SET_IOT_NET)
|
|
{
|
|
for(i = 0, j = 0, k = 0; i < g_buf_ble_response.dat_len; i++)
|
|
{
|
|
if(g_buf_ble_response.dat[i] == 0x00)
|
|
{
|
|
j++;
|
|
if(k == 0)
|
|
{
|
|
//iot _host
|
|
PRINT("Rcv_Host:%s\n", tmp_ble_buf);
|
|
memcpy(iot_net_info.remote_addr, tmp_ble_buf, j);
|
|
|
|
}
|
|
else if(k == 1)
|
|
{
|
|
PRINT("Rcv_Port:%s\n", tmp_ble_buf);
|
|
uint16_t _port = 0;
|
|
for(j = 0; j < strlen(tmp_ble_buf); j++)
|
|
{
|
|
_port *= 10;
|
|
_port += tmp_ble_buf[j] - 0x30;
|
|
}
|
|
iot_net_info.mqtt_port = _port;
|
|
}
|
|
else if(k == 2)
|
|
{
|
|
PRINT("Rcv_Client:%s\n", tmp_ble_buf);
|
|
if((strlen(tmp_ble_buf) == 1) && (tmp_ble_buf[0] == 0x20))
|
|
{
|
|
PRINT("Client_use local_serial\n");
|
|
}
|
|
else
|
|
{
|
|
memcpy(iot_net_info.client_id, tmp_ble_buf, j);
|
|
}
|
|
}
|
|
else if(k == 3)
|
|
{
|
|
PRINT("Rcv_Username:%s\n", tmp_ble_buf);
|
|
memcpy(iot_net_info.username, tmp_ble_buf, j);
|
|
}
|
|
else if(k == 4)
|
|
{
|
|
PRINT("Rcv_Pass:%s\n", tmp_ble_buf);
|
|
memcpy(iot_net_info.password, tmp_ble_buf, j);
|
|
}
|
|
k++;
|
|
memset(tmp_ble_buf, 0, MAX_BLE_TMP_BUF_LEN);
|
|
j = 0;
|
|
}
|
|
else
|
|
{
|
|
tmp_ble_buf[j] = g_buf_ble_response.dat[i];
|
|
j++;
|
|
}
|
|
}
|
|
if(k == 4)
|
|
{
|
|
PRINT("Rcv_Pass:%s\n", tmp_ble_buf);
|
|
|
|
memcpy(iot_net_info.password, tmp_ble_buf, strlen(tmp_ble_buf) + 1);
|
|
}
|
|
memset(tmp_ble_buf, 0, MAX_BLE_TMP_BUF_LEN);
|
|
write_net_config(&local_net_cfg, &net_center_info, &iot_net_info, &g_iot_topic);
|
|
|
|
// response finally
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, 1);
|
|
//clear_buf_dbn_ble_all(&g_buf_ble_response);
|
|
} //end if CMD_DBN_SET_IOT_NET
|
|
else if(g_buf_ble_response.cmd == CMD_DBN_SET_IOT_TOPIC)
|
|
{
|
|
for(i = 0, j = 0, k = 0; i < g_buf_ble_response.dat_len; i++)
|
|
{
|
|
if(g_buf_ble_response.dat[i] == 0x00)
|
|
{
|
|
//j++;
|
|
if(k == 0)
|
|
{
|
|
g_iot_topic.clientid_enable = tmp_ble_buf[0] - 0x30;
|
|
}
|
|
else if(k == 1)
|
|
{
|
|
// if(g_flag_debug)
|
|
// {
|
|
// printf("rcv_topic_pub_:%s\n", tmp_ble_buf);
|
|
// for(f = 0; f < j; f++)
|
|
// {
|
|
// printf(" %02X", tmp_ble_buf[f]);
|
|
// }
|
|
// printf(", j:%d\n", j);
|
|
// }
|
|
memset(g_iot_topic.topic_pub, 0, MAX_TOPIC_LENGTH);
|
|
memcpy(g_iot_topic.topic_pub, tmp_ble_buf, j + 1);
|
|
}
|
|
|
|
k++;
|
|
j = 0;
|
|
memset(tmp_ble_buf, 0, MAX_BLE_TMP_BUF_LEN);
|
|
}
|
|
else
|
|
{
|
|
tmp_ble_buf[j] = g_buf_ble_response.dat[i];
|
|
j++;
|
|
}
|
|
}
|
|
if(k == 2)
|
|
{
|
|
// if(g_flag_debug)
|
|
// {
|
|
// printf("rcv_topic_sub_:%s\n", tmp_ble_buf);
|
|
// }
|
|
memset(g_iot_topic.topic_sub, 0, MAX_TOPIC_LENGTH);
|
|
memcpy(g_iot_topic.topic_sub, tmp_ble_buf, strlen(tmp_ble_buf) + 1);
|
|
}
|
|
memset(tmp_ble_buf, 0, MAX_BLE_TMP_BUF_LEN);
|
|
write_net_config(&local_net_cfg, &net_center_info, &iot_net_info, &g_iot_topic);
|
|
|
|
// response finally
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, 1);
|
|
} // end if CMD_DBN_SET_IOT_TOPIC
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
void manage_dbn_ble_default(uint8_t *pkg, uint8_t len)
|
|
{
|
|
uint8_t _header_0 = pkg[1];
|
|
uint8_t _header_0_high = 0;
|
|
uint8_t _header_0_low = _header_0 % 0x10;
|
|
uint8_t _len = pkg[2];
|
|
uint8_t _cmd = pkg[3];
|
|
uint8_t _tmp = 0;
|
|
uint8_t i = 0, k = 0;
|
|
|
|
memset(tmp_ble_buf, 0, MAX_BLE_TMP_BUF_LEN);
|
|
|
|
switch(_cmd)
|
|
{
|
|
case CMD_DBN_GET_DEV_INFO:
|
|
{
|
|
i = set_dev_info_to_ready(tmp_ble_buf);
|
|
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, i);
|
|
|
|
// printf("\nGet_dev_info\n");
|
|
} break;
|
|
case CMD_DBN_SET_LSSC_NET:
|
|
{
|
|
//printf("Set_Net_info_len:%d\n", len);
|
|
if(len < 34)
|
|
{
|
|
return;
|
|
}
|
|
|
|
i = 4;
|
|
memcpy(local_net_cfg.lip, &pkg[i], 4);
|
|
i += 4;
|
|
memcpy(local_net_cfg.sub, &pkg[i], 4);
|
|
i += 4;
|
|
memcpy(local_net_cfg.gw, &pkg[i], 4);
|
|
i += 4;
|
|
memcpy(net_center_info.lssc_ip, &pkg[i], 4);
|
|
//i += 4;
|
|
//printf("Reset_lip:%d\n",local_net_cfg.lip[3]);
|
|
i = 24;
|
|
//printf("Reset_lport:%02X %02X\n",pkg[24], pkg[25]);
|
|
//memcpy(local_net_cfg.dns
|
|
// local_net_cfg.port_ssc_tcp = *(uint16_t *)(&pkg[24]); //TOOD: Will err, why?
|
|
local_net_cfg.port_ssc_tcp = (pkg[25] << 8) | pkg[24];// This is OK
|
|
i += 2;
|
|
// local_net_cfg.port_ssc_udp = *(uint16_t *)(&pkg[i]);
|
|
local_net_cfg.port_ssc_udp =(pkg[27] <<8 ) | pkg[26];
|
|
i += 2;
|
|
// local_net_cfg.port_ssc_udp_message = *(uint16_t *)(&pkg[i]);
|
|
local_net_cfg.port_ssc_udp_message = (pkg[29] << 8) | pkg[28];
|
|
i += 2;
|
|
// local_net_cfg.port_dev_tcp = *(uint16_t *)(&pkg[i]);
|
|
local_net_cfg.port_dev_tcp = (pkg[31] << 8) | pkg[30];
|
|
net_center_info.tcp_port = local_net_cfg.port_dev_tcp;
|
|
i += 2;
|
|
// local_net_cfg.port_dev_udp = *(uint16_t *)(&pkg[32]);
|
|
local_net_cfg.port_dev_udp = (pkg[33] << 8) | pkg[32];
|
|
//printf("Will_reset_net_param___\n");
|
|
write_net_config(&local_net_cfg, &net_center_info, &iot_net_info, &g_iot_topic);
|
|
//response
|
|
tmp_ble_buf[0] = 0;
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, 1);
|
|
|
|
} break;
|
|
case CMD_DBN_GET_LSSC_NET:
|
|
{
|
|
i = set_net_info_to_ready(tmp_ble_buf);
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, i);
|
|
// printf("Get_Net_Info\n");
|
|
} break;
|
|
case CMD_DBN_GET_IOT_NET:
|
|
{
|
|
set_response_iot_net(&g_buf_ble_response);
|
|
} break;
|
|
case CMD_DBN_SET_IOT_NET:
|
|
{
|
|
unpack_packs(pkg, len);
|
|
} break;
|
|
case CMD_DBN_SET_IOT_TOPIC:
|
|
{
|
|
unpack_packs(pkg, len);
|
|
} break;
|
|
case CMD_DBN_GET_IOT_TOPIC:
|
|
{
|
|
set_response_iot_topic(&g_buf_ble_response);
|
|
} break;
|
|
case CMD_DBN_SET_SUB_CODE:
|
|
{
|
|
PRINT("\nSet_Sub_Code\n");
|
|
unpack_packs(pkg, len);
|
|
} break;
|
|
case CMD_DBN_RESET_DEV:
|
|
{
|
|
//Restart Dev
|
|
NVIC_SystemReset();
|
|
} break;
|
|
case CMD_DBN_CHECK_PASS:
|
|
{
|
|
unpack_packs(pkg, len);
|
|
} break;
|
|
case CMD_DBN_SET_CJQ_PARAM:
|
|
{
|
|
// PRINT("\nSet_Cjq_param\n");
|
|
// unpack_pkg_set_cjq_param(pkg, len);
|
|
tmp_ble_buf[0] = 0;
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, 1);
|
|
|
|
// para_store_init();
|
|
} break;
|
|
case CMD_DBN_GET_CJQ_PARAM:
|
|
{
|
|
i = 0;
|
|
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, i);
|
|
// PRINT("\nGet_Cjq_param\n");
|
|
} break;
|
|
case CMD_DBN_LOOP_SENS_LIST: {
|
|
// PRINT("SENS_CNG: %02X\n", pkg[4]);
|
|
memset(tmp_ble_buf, 0, MAX_BLE_TMP_BUF_LEN);
|
|
|
|
|
|
} break;
|
|
case CMD_DBN_SET_FACTORY:
|
|
case CMD_DBN_SET_CJQ_FACTORY: {
|
|
// 出厂初始化
|
|
tmp_ble_buf[0] = 0;
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, 1);
|
|
factory_dev_info();
|
|
|
|
Delay_Ms(10);
|
|
|
|
//TODO: 不整个设备复位，复位除了蓝牙的部分，即蓝牙正常，其他部分重新初始化
|
|
|
|
} break;
|
|
case CMD_DBN_RW_UART_BAUD:{ //
|
|
uint8_t _rw = pkg[4];
|
|
uint32_t _baud = 0;
|
|
i = 0;
|
|
tmp_ble_buf[i++] = _rw;
|
|
tmp_ble_buf[i++] = 0x01; //status
|
|
|
|
if(_rw == 0){// read baud
|
|
tmp_ble_buf[i++] = g_max_counter_bt_min; // Idle Ble timeout
|
|
tmp_ble_buf[i++] = (uint8_t)g_storage_uart_baud; //1 g_storage_uart_baud? 2 g_storage_uart_baud_2
|
|
tmp_ble_buf[i++] = (uint8_t)(g_storage_uart_baud >> 8);
|
|
tmp_ble_buf[i++] = (uint8_t)(g_storage_uart_baud >> 16);
|
|
tmp_ble_buf[i++] = 0x02;
|
|
tmp_ble_buf[i++] = (uint8_t)g_storage_uart_baud_2;
|
|
tmp_ble_buf[i++] = (uint8_t)(g_storage_uart_baud_2 >> 8);
|
|
tmp_ble_buf[i++] = (uint8_t)(g_storage_uart_baud_2 >> 16);
|
|
// 4BYte Reserved
|
|
|
|
}
|
|
else { // write baud
|
|
alter_dev_baud(&pkg[5]); //
|
|
g_storage_uart_num = pkg[5];
|
|
g_storage_uart_baud = pkg[6];
|
|
g_storage_uart_baud |= (uint16_t)(pkg[7] << 8) & 0xFF00;
|
|
g_storage_uart_baud |= (uint32_t)(pkg[8] << 16) & 0xFF0000;
|
|
|
|
tmp_ble_buf[i++] = g_storage_uart_baud;
|
|
tmp_ble_buf[i++] = (uint8_t)g_storage_uart_baud;
|
|
tmp_ble_buf[i++] = (uint8_t)(g_storage_uart_baud >> 8);
|
|
tmp_ble_buf[i++] = (uint8_t)(g_storage_uart_baud >> 16);
|
|
tmp_ble_buf[i++] = 0x00; tmp_ble_buf[i++] = 0x00; tmp_ble_buf[i++] = 0x00; tmp_ble_buf[i++] = 0x00; // 4BYte Reserved
|
|
}
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, i);
|
|
} break;
|
|
case CMD_DBN_UPDATE_DEV_SERIAL:
|
|
{
|
|
alter_dev_serila(&pkg[4]);
|
|
//response
|
|
tmp_ble_buf[0] = 1;
|
|
set_response_buf(&g_buf_ble_response, MAGIC_BYTE_DBN_DEFAULT, _cmd, tmp_ble_buf, 1);
|
|
} break;
|
|
case CMD_SENS_ACS_ENABLE: {
|
|
// 线圈动态
|
|
g_dbn_ble_state_acs_enable.enable = pkg[5];
|
|
|
|
if(g_dbn_ble_state_acs_enable.enable){
|
|
g_dbn_ble_state_acs_enable.interval = pkg[6] * 0x7F;
|
|
g_dbn_ble_state_acs_enable.timeout_min = pkg[7];
|
|
if(g_dbn_ble_state_acs_enable.timeout_min){
|
|
g_dbn_ble_state_acs_enable.counter = mstick();
|
|
g_dbn_ble_state_acs_enable.timeout_counter = g_dbn_ble_state_acs_enable.timeout_min * 60 * 100; // TODO: min --> ms
|
|
}
|
|
g_dbn_ble_state_acs_enable.flag = 1;
|
|
}
|
|
else{
|
|
g_dbn_ble_state_acs_enable.flag = 0;
|
|
}
|
|
PRINT("Rcv_acs_enable_flag: %d\n", g_dbn_ble_state_acs_enable.flag);
|
|
} break;
|
|
default:
|
|
{
|
|
} break;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void manage_dbn_ble_transparent(uint8_t *pkg, uint8_t len)
|
|
{
|
|
//
|
|
// transparent_485(pkg, len);
|
|
// UART1_SendString(pkg, len);
|
|
UART2_SendString(pkg, len);
|
|
}
|
|
|
|
void poll_dbn_ble(void)
|
|
{
|
|
uint8_t i = 0;
|
|
uint8_t magic = 0;
|
|
if(g_ble_rcv_buf.flag)
|
|
{
|
|
if(g_flag_debug && g_flag_counter_ota.flag == 0)
|
|
{
|
|
PRINT("profile ChangeCB CHAR1?..:%s, len:%d \n", g_ble_rcv_buf.buf, g_ble_rcv_buf.len);
|
|
for(i = 0; i < g_ble_rcv_buf.len; i++)
|
|
{
|
|
PRINT(" %02X", g_ble_rcv_buf.buf[i]);
|
|
}
|
|
PRINT("\n");
|
|
}
|
|
if(g_flag_counter_ota.flag == 0){
|
|
magic = check_pkg(g_ble_rcv_buf.buf, g_ble_rcv_buf.len);
|
|
}
|
|
|
|
// printf("_magic: %02X\n", magic);
|
|
if(g_flag_counter_ota.flag){
|
|
manage_dbn_ble_transparent(g_ble_rcv_buf.buf, g_ble_rcv_buf.len);
|
|
}
|
|
else{
|
|
if(magic != 0)
|
|
{
|
|
if(magic == MAGIC_BYTE_DBN_DEFAULT)
|
|
{
|
|
manage_dbn_ble_default(g_ble_rcv_buf.buf, g_ble_rcv_buf.len);
|
|
}
|
|
else if (magic == MAGIC_BYTE_DBN_TRANSPARENT)
|
|
{
|
|
manage_dbn_ble_transparent(g_ble_rcv_buf.buf, g_ble_rcv_buf.len);
|
|
}
|
|
}
|
|
}
|
|
|
|
// memcpy(g_notify_buftemp.buf, g_ble_rcv_buf.buf, g_ble_rcv_buf.len);
|
|
// g_notify_buftemp.len = g_ble_rcv_buf.len;
|
|
// g_flag_notify_temp = 1;
|
|
clear_ble_notify_buf(&g_ble_rcv_buf);
|
|
}
|
|
if(g_notify_buftemp.flag == 0)
|
|
{
|
|
// report_sens_acs();
|
|
g_flag_notify_temp = set_response_to_notify(&g_buf_ble_response, &g_notify_buftemp);
|
|
}
|
|
}
|
|
|
|
|
|
|