void ICACHE_FLASH_ATTR
pando_subdevice_recv(uint8_t * buffer, uint16_t length)
{
if(NULL == buffer)
{
return;
}
PRINTF("subdevive receive a package: \n");
show_package(buffer, length);
struct sub_device_buffer *device_buffer = (struct sub_device_buffer *)pd_malloc(sizeof(struct sub_device_buffer));
device_buffer->buffer_length = length;
device_buffer->buffer = (uint8 *)pd_malloc(length);
pd_memcpy(device_buffer->buffer, buffer, length);
uint16 payload_type = get_sub_device_payloadtype(device_buffer);
switch (payload_type) {
case PAYLOAD_TYPE_DATA:
decode_data(device_buffer);
break;
case PAYLOAD_TYPE_COMMAND:
decode_command(device_buffer);
break;
default:
PRINTF("unsuported paload type : %d", payload_type);
break;
}
delete_device_package(device_buffer);
}
struct pando_buffer * FUNCTION_ATTRIBUTE construct_data_package_to_server(uint16_t *payload_type)
{
struct pando_buffer *gateway_data_buffer = NULL;
struct sub_device_buffer *device_data_buffer = NULL;
uint16_t buf_len = 0;
//构建子设备数据包
device_data_buffer = construct_sub_device_data();
buf_len = GATE_HEADER_LEN - DEV_HEADER_LEN + device_data_buffer->buffer_length;
gateway_data_buffer = pando_buffer_create(buf_len, GATE_HEADER_LEN - DEV_HEADER_LEN);
if (gateway_data_buffer->buffer == NULL)
{
pd_printf("constuct_event_package_to_server malloc failed.\n");
return NULL;
}
printf("len %d, offset %d\n", gateway_data_buffer->buff_len, gateway_data_buffer->offset);
//复制子设备事件包内容，并释放
pd_memcpy(
gateway_data_buffer->buffer + gateway_data_buffer->offset,
device_data_buffer->buffer, device_data_buffer->buffer_length);
delete_device_package(device_data_buffer);
if (pando_protocol_encode(gateway_data_buffer, payload_type))
{
pd_printf("pando_protocol_encode error.\n");
}
pando_protocol_set_sub_device_id(gateway_data_buffer, 112);
show_package(gateway_data_buffer->buffer, gateway_data_buffer->buff_len);
return gateway_data_buffer;
}
/* event exactly the same as command */
void FUNCTION_ATTRIBUTE decode_command(struct pando_buffer *buf, uint16_t payload_type)
{
// 网关解包
pando_protocol_decode(buf, payload_type);
// 网关向子设备传递数据包,如果是向子设备发包，请用对应的设备send函数
struct sub_device_buffer *device_buffer = pd_malloc(sizeof(struct sub_device_buffer));
device_buffer->buffer_length = pando_get_package_length(buf);
device_buffer->buffer = pd_malloc(device_buffer->buffer_length);
// 从网关数据包中获取子设备数据包
pd_memcpy(device_buffer->buffer, pando_get_package_begin(buf), device_buffer->buffer_length);
// 获取数据完成，释放网关缓冲区
pando_buffer_delete(buf);
/* 以下是子设备解析代码 */
struct pando_command cmd_body;
// 1.子设备解命令包, 返回参数区的起始位置
struct TLVs *cmd_params_block = get_sub_device_command(device_buffer, &cmd_body);
pd_printf("sub id %02x, cmd num %02x, pri %02x, count: %d\n",
cmd_body.sub_device_id, cmd_body.command_num,
cmd_body.priority, cmd_body.params->count);
// 2.子设备获取命令参数
uint16_t tlv_length;
uint8_t *value = pd_malloc(100);
uint8_t param1 = get_next_uint8(cmd_params_block);
show_package(¶m1, sizeof(param1));
uint32_t param2 = get_next_uint32(cmd_params_block);
show_package(¶m2, sizeof(param2));
char *param_bytes = get_next_bytes(cmd_params_block, &tlv_length);
pd_memcpy(value, param_bytes, tlv_length);
show_package(value, tlv_length);
pd_free(value);
// 3. 删除子设备缓冲区
delete_device_package(device_buffer);
}
static void ICACHE_FLASH_ATTR
send_current_status()
{
struct sub_device_buffer* data_buffer;
data_buffer = create_data_package(0);
if(NULL == data_buffer)
{
PRINTF("create data package error\n");
return;
}
pando_object* obj = NULL;
pando_objects_iterator* it = create_pando_objects_iterator();
while(obj = pando_objects_iterator_next(it)){
PARAMS* params = create_params_block();
if (params == NULL)
{
PRINTF("Create params block failed.\n");
return ;
}
obj->pack(params);
int ret = add_next_property(data_buffer, obj->no, params);
if (ret != 0)
{
PRINTF("add_next_property failed.");
}
delete_params_block(params);
}
delete_pando_objects_iterator(it);
channel_send_to_device(PANDO_CHANNEL_PORT_1, data_buffer->buffer, data_buffer->buffer_length);
show_package(data_buffer->buffer, data_buffer->buffer_length);
delete_device_package(data_buffer);
}
void FUNCTION_ATTRIBUTE decode_data(struct pando_buffer *buf, uint16_t payload_type)
{
// 网关解包
pando_protocol_decode(buf, payload_type);
// 网关向子设备传递数据包,如果是向子设备发包，请用对应的设备send函数
struct sub_device_buffer *device_buffer = pd_malloc(sizeof(struct sub_device_buffer));
device_buffer->buffer_length = pando_get_package_length(buf);
device_buffer->buffer = pd_malloc(device_buffer->buffer_length);
// 从网关数据包中获取子设备数据包
pd_memcpy(device_buffer->buffer, pando_get_package_begin(buf), device_buffer->buffer_length);
// 获取数据完成，释放网关缓冲区
pando_buffer_delete(buf);
show_package(device_buffer->buffer, device_buffer->buffer_length);
/* 以下是子设备解析代码 */
struct pando_property data_body;
uint8_t *buf_end = device_buffer->buffer + device_buffer->buffer_length;
int i = 0;
uint16_t tlv_type, tlv_length;
uint8_t *value = pd_malloc(100);
struct TLV *param = NULL;
struct TLVs *property_block;
// 2.子设备获取命令参数
uint32_t param1 = 0;
uint8_t param2 = 0;
char *param_bytes = NULL;
while(1)
{
property_block = get_sub_device_property(device_buffer, &data_body);
if (property_block == NULL)
{
pd_printf("reach end of buffer\n");
break;
}
pd_printf("count: %d\n", data_body.params->count);
if (data_body.params->count == 3)
{
param1 = get_next_uint32(property_block);
show_package(¶m1, sizeof(param1));
param2 = get_next_uint8(property_block);
show_package(¶m2, sizeof(param2));
param_bytes = get_next_bytes(property_block, &tlv_length);
pd_memcpy(value, param_bytes, tlv_length);
show_package(value, tlv_length);
}
else if (data_body.params->count == 2)
{
param2 = get_next_uint8(property_block);
show_package(¶m2, sizeof(param2));
param_bytes = get_next_bytes(property_block, &tlv_length);
pd_memcpy(value, param_bytes, tlv_length);
show_package(value, tlv_length);
}
}
pd_free(value);
// 3. 删除子设备缓冲区
delete_device_package(device_buffer);
}
