void messageArrived(MessageData* md)
{
MQTTMessage* message = md->message;
if (opts.showtopics)
printf("topic %.*s\t", md->topicName->lenstring.len, md->topicName->lenstring.data);
if (opts.nodelimiter)
printf("delimiter %.*s", (int)message->payloadlen, (char*)message->payload);
else
printf("delimiter is %.*s%s", (int)message->payloadlen, (char*)message->payload, opts.delimiter);
//fflush(stdout);
char *payload_type_c = strchr(md->topicName->lenstring.data, '/');
uint16_t type = 0;
if (payload_type_c == NULL)
{
printf("Found payload type failed.\n");
return;
}
else
{
printf("\n%c, len %d\n", *(payload_type_c + 1), (int)message->payloadlen);
}
switch (*(payload_type_c + 1))
{
case 'c':
type = PAYLOAD_TYPE_COMMAND;
break;
case 'e':
type = PAYLOAD_TYPE_EVENT;
break;
case 'd':
type = PAYLOAD_TYPE_DATA;
break;
default:
printf("Wrong type of message: %c\n", *(payload_type_c + 1));
return;
}
struct pando_buffer *msg_payload = NULL;
msg_payload = pando_buffer_create(message->payloadlen,0);
pd_memcpy(msg_payload->buffer, message->payload, msg_payload->buff_len);
printf("before decode, %d\n", recv_count);
show_package(msg_payload->buffer + msg_payload->offset,
msg_payload->buff_len - msg_payload->offset);
pando_protocol_decode(msg_payload, type);
recv_count++;
printf("after decode, %d\n", recv_count);
show_package(msg_payload->buffer + msg_payload->offset,
msg_payload->buff_len - msg_payload->offset);
}
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);
}
// 创建事件包的步骤
// 1. 使用create_params_block添加第一个参数
// 2. add_next_param直到添加完全部参数
// 3. create_event_package创建数据包，并delete_params_block来释放params_block
struct sub_device_buffer * FUNCTION_ATTRIBUTE construct_sub_device_event()
{
struct sub_device_buffer *event_buffer = NULL;
struct TLVs *params_block = NULL;
uint16_t event_num = 0x0911;
uint16_t flag = 0x0011;
uint32_t event_param1 = 0xa1b2c3d4;
uint8_t event_param2 = 0xc1;
char event_param3[] = "test data";
event_buffer = create_event_package(flag);
if (NULL == event_buffer)
{
pd_printf("Create event package failed.");
return NULL;
}
params_block = create_params_block();
if (params_block == NULL)
{
pd_printf("Create first tlv param failed.\n");
return NULL;
}
if (add_next_param(params_block, TLV_TYPE_UINT8, sizeof(event_param2), &event_param2))
{
delete_params_block(params_block);
pd_printf("Add next tlv param failed.\n");
return NULL;
}
if (add_next_param(params_block, TLV_TYPE_UINT32, sizeof(event_param1), &event_param1))
{
delete_params_block(params_block);
pd_printf("Add next tlv param failed.\n");
return NULL;
}
if (add_next_param(params_block, TLV_TYPE_BYTES, sizeof(event_param3), event_param3))
{
delete_params_block(params_block);
pd_printf("Add next tlv param failed.\n");
return NULL;
}
// 3. create event with flag, priority and tlv params
add_event(event_buffer, event_num, 0, params_block);
delete_params_block(params_block);
finish_package(event_buffer);
show_package(event_buffer->buffer, event_buffer->buffer_length);
return event_buffer;
}
/******************************************************************************
* FunctionName : zero_device_data_process.
* Description : process the received data of zero device(zero device is the gateway itself).
* Parameters : uint.
* Returns : none.
*******************************************************************************/
static void FUNCTION_ATTRIBUTE
zero_device_data_process(uint8_t * buffer, uint16_t length)
{
struct pando_command cmd_body;
uint16_t type = 0;
uint16_t len = 0;
struct sub_device_buffer * device_buffer = (struct sub_device_buffer *)pd_malloc(sizeof(struct sub_device_buffer));
if(device_buffer == NULL)
{
pd_printf("%s:malloc error!\n", __func__);
return;
}
device_buffer->buffer = (uint8_t*)pd_malloc(length);
if(device_buffer->buffer == NULL)
{
pd_printf("%s:malloc error!\n", __func__);
pd_free(device_buffer);
return;
}
pd_memcpy(device_buffer->buffer, buffer, length);
device_buffer->buffer_length = length;
struct TLVs *cmd_param = get_sub_device_command(device_buffer, &cmd_body);
if(COMMON_COMMAND_SYN_TIME == cmd_body.command_num )
{
pd_printf("PANDO: synchronize time\n");
uint64_t time = get_next_uint64(cmd_param);
show_package((uint8_t*)(&time), sizeof(time));
// pando_set_system_time(time);
}
if( device_buffer->buffer != NULL)
{
pd_free( device_buffer->buffer);
device_buffer->buffer = NULL;
}
if(device_buffer != NULL)
{
pd_free(device_buffer);
device_buffer = NULL;
}
}
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);
}
/**
* @brief Client received callback function.
* @param arg: contain the ip link information
* @param pdata: received data
* @param len: the lenght of received data
* @retval None
*/
void ICACHE_FLASH_ATTR
mqtt_tcpclient_recv(void *arg, char *pdata, unsigned short len)
{
INFO("TCP: data received %d bytes\r\n", len);
uint8_t msg_type;
uint8_t msg_qos;
uint16_t msg_id;
struct espconn *pCon = (struct espconn*)arg;
MQTT_Client *client = (MQTT_Client *)pCon->reverse;
if(len > MQTT_BUF_SIZE || len == 0)
{
INFO("receive length is invalid.\n");
return;
}
os_memcpy(client->mqtt_state.in_buffer + client->mqtt_state.message_length_read, pdata, len);
client->mqtt_state.message_length_read += len;
READPACKET:
if(client->mqtt_state.message_length_read == 1)
{
INFO("not enough data for read package length.\n!");
return;
}
client->mqtt_state.message_length = mqtt_get_total_length(client->mqtt_state.in_buffer, client->mqtt_state.message_length_read);
INFO("message length:%d\n", client->mqtt_state.message_length);
show_package(client->mqtt_state.in_buffer, client->mqtt_state.message_length_read);
if(client->mqtt_state.message_length > client->mqtt_state.message_length_read)
{
INFO("not enough data.\n");
return;
}
msg_type = mqtt_get_type(client->mqtt_state.in_buffer);
msg_qos = mqtt_get_qos(client->mqtt_state.in_buffer);
msg_id = mqtt_get_id(client->mqtt_state.in_buffer, client->mqtt_state.message_length);
INFO("client->connstate:%d, type:%d, Qos:%d, id:%d, message length:%d\n", client->connState, msg_type, msg_qos, \
msg_id, client->mqtt_state.message_length);
switch(client->connState)
{
case MQTT_CONNECT_SENDING:
if(msg_type == MQTT_MSG_TYPE_CONNACK)
{
if(client->mqtt_state.pending_msg_type != MQTT_MSG_TYPE_CONNECT)
{
INFO("MQTT: Invalid packet\r\n");
if(client->security)
{
espconn_secure_disconnect(client->pCon);
}
else
{
espconn_disconnect(client->pCon);
}
}
else
{
INFO("MQTT: Connected to %s:%d\r\n", client->host, client->port);
client->connState = MQTT_DATA;
if(client->connectedCb)
client->connectedCb((uint32_t*)client);
}
}
break;
case MQTT_DATA:
switch(msg_type)
{
case MQTT_MSG_TYPE_SUBACK:
if(client->mqtt_state.pending_msg_type == MQTT_MSG_TYPE_SUBSCRIBE && client->mqtt_state.pending_msg_id == msg_id)
INFO("MQTT: Subscribe successful\r\n");
break;
case MQTT_MSG_TYPE_UNSUBACK:
if(client->mqtt_state.pending_msg_type == MQTT_MSG_TYPE_UNSUBSCRIBE && client->mqtt_state.pending_msg_id == msg_id)
INFO("MQTT: UnSubscribe successful\r\n");
break;
case MQTT_MSG_TYPE_PUBLISH:
if(msg_qos == 1)
client->mqtt_state.outbound_message = mqtt_msg_puback(&client->mqtt_state.mqtt_connection, msg_id);
else if(msg_qos == 2)
client->mqtt_state.outbound_message = mqtt_msg_pubrec(&client->mqtt_state.mqtt_connection, msg_id);
if(msg_qos == 1 || msg_qos == 2)
{
INFO("MQTT: Queue response QoS: %d\r\n", msg_qos);
if(QUEUE_Puts(&client->msgQueue, client->mqtt_state.outbound_message->data,\
client->mqtt_state.outbound_message->length) == -1)
{
INFO("MQTT: Queue full\r\n");
}
}
show_package(client->mqtt_state.in_buffer, client->mqtt_state.message_length);
deliver_publish(client, client->mqtt_state.in_buffer, client->mqtt_state.message_length);
break;
case MQTT_MSG_TYPE_PUBACK:
if(client->mqtt_state.pending_msg_type == MQTT_MSG_TYPE_PUBLISH && client->mqtt_state.pending_msg_id == msg_id)
{
INFO("MQTT: received MQTT_MSG_TYPE_PUBACK, finish QoS1 publish\r\n");
}
break;
case MQTT_MSG_TYPE_PUBREC:
client->mqtt_state.outbound_message = mqtt_msg_pubrel(&client->mqtt_state.mqtt_connection, msg_id);
if(QUEUE_Puts(&client->msgQueue, client->mqtt_state.outbound_message->data, client->mqtt_state.outbound_message->length) == -1)
{
INFO("MQTT: Queue full\r\n");
}
break;
case MQTT_MSG_TYPE_PUBREL:
client->mqtt_state.outbound_message = mqtt_msg_pubcomp(&client->mqtt_state.mqtt_connection, msg_id);
if(QUEUE_Puts(&client->msgQueue, client->mqtt_state.outbound_message->data, client->mqtt_state.outbound_message->length) == -1)
{
INFO("MQTT: Queue full\r\n");
}
break;
case MQTT_MSG_TYPE_PUBCOMP:
if(client->mqtt_state.pending_msg_type == MQTT_MSG_TYPE_PUBLISH && client->mqtt_state.pending_msg_id == msg_id)
{
INFO("MQTT: receive MQTT_MSG_TYPE_PUBCOMP, finish QoS2 publish\r\n");
}
break;
case MQTT_MSG_TYPE_PINGREQ:
client->mqtt_state.outbound_message = mqtt_msg_pingresp(&client->mqtt_state.mqtt_connection);
if(QUEUE_Puts(&client->msgQueue, client->mqtt_state.outbound_message->data, client->mqtt_state.outbound_message->length) == -1)
{
INFO("MQTT: Queue full\r\n");
}
break;
case MQTT_MSG_TYPE_PINGRESP:
INFO("receive a heart beat response!\n");
client->heart_beat_flag = 1;
break;
}
break;
}
// process package adhesive.
uint16_t remain_length = client->mqtt_state.message_length_read - client->mqtt_state.message_length;
client->mqtt_state.message_length_read = remain_length;
INFO("client->mqtt_state.message_length_read = %d\n", client->mqtt_state.message_length_read);
INFO("client->mqtt_state.message_length = %d\n", client->mqtt_state.message_length);
INFO("the package is\n");
show_package(client->mqtt_state.in_buffer, client->mqtt_state.message_length);
if(remain_length > 0)
{
int i = 0;
for(i = 0; i< remain_length; i++)
{
client->mqtt_state.in_buffer[i] = \
client->mqtt_state.in_buffer[client->mqtt_state.message_length_read - remain_length + i];
}
INFO("Get another published message\r\n");
goto READPACKET;
}
system_os_post(MQTT_TASK_PRIO, 0, (os_param_t)client);
}
int8_t module_data_handler(void* data)
{
uint8_t urc = 0;
struct module_buf* module_data = (struct module_buf*)data;
printf("module response:%s\n", module_data->buf);
show_package(module_data->buf, module_data->length);
if(module_data->length < 3)
{
printf("module response not enough length!");
if(module_data != NULL)
{
if(module_data->buf != NULL)
{
free(module_data->buf);
module_data->buf = NULL;
}
free(module_data);
module_data = NULL;
}
return -1;
}
if(MODULE_START == s_module_status)
{
if((strstr(module_data->buf, "OK")))
{
printf("the \"at\" cmd response \"OK\"\n");
s_module_status = MODULE_SYNC;
}
}
if (MODULE_INIT ==s_module_status|| MODULE_INIT_DONE == s_module_status)
{
int i = 0;
if (NULL != s_current_at_command)
{
for (i = 0; i <sizeof(atCmdTable)/sizeof(atCmdTable[0]); i++)
{
if(!strcmp(s_current_at_command->at_name, atCmdTable[i].name))
{
s_at_status =atCmdTable[i].at_cmd_handle(&urc, module_data->buf);
if (ATC_RSP_FINISH ==s_at_status)
{
myfree(s_current_at_command);
s_current_at_command = NULL;
}
break;
}
}
}
else
{
if(data_process(module_data) == 1)
{
printf("%s\n", __func__);
show_package(module_data->buf, module_data->length);
if(tcp_recv_cb != NULL)
{
tcp_recv_cb(0, module_data->buf, module_data->length);
}
}
else
{
printf("the data is urc\n");
}
}
}
if(module_data != NULL)
{
if(module_data->buf != NULL)
{
free(module_data->buf);
module_data->buf = NULL;
}
free(module_data);
module_data = NULL;
}
return 0;
}
/**
* @brief Client received callback function.
* @param arg: contain the ip link information
* @param pdata: received data
* @param len: the lenght of received data
* @retval None
*/
void ICACHE_FLASH_ATTR
mqtt_tcpclient_recv(void *arg, char *pdata, unsigned short len)
{
uint8_t msg_type;
uint8_t msg_qos;
uint16_t msg_id;
struct espconn *pCon = (struct espconn*)arg;
MQTT_Client *client = (MQTT_Client *)pCon->reverse;
READPACKET:
INFO("TCP: data received %d bytes:\r\n", len);
show_package(pdata, len);
if(len < MQTT_BUF_SIZE && len > 0){
os_memcpy(client->mqtt_state.in_buffer, pdata, len);
msg_type = mqtt_get_type(client->mqtt_state.in_buffer);
msg_qos = mqtt_get_qos(client->mqtt_state.in_buffer);
msg_id = mqtt_get_id(client->mqtt_state.in_buffer, client->mqtt_state.in_buffer_length);
PRINTF("client->connstate:%d, type:%d, Qos:%d, id:%d\n", client->connState, msg_type, msg_qos, msg_id);
switch(client->connState){
case MQTT_CONNECT_SENDING:
if(msg_type == MQTT_MSG_TYPE_CONNACK){
if(client->mqtt_state.pending_msg_type != MQTT_MSG_TYPE_CONNECT){
INFO("MQTT: Invalid packet\r\n");
if(client->security){
espconn_secure_disconnect(client->pCon);
}
else {
espconn_disconnect(client->pCon);
}
} else {
INFO("MQTT: Connected to %s:%d\r\n", client->host, client->port);
client->connState = MQTT_DATA;
if(client->connectedCb)
client->connectedCb((uint32_t*)client);
}
}
break;
case MQTT_DATA:
client->mqtt_state.message_length_read = len;
client->mqtt_state.message_length = mqtt_get_total_length(client->mqtt_state.in_buffer, client->mqtt_state.message_length_read);
INFO("mqtt actual length:%d\n", client->mqtt_state.message_length);
switch(msg_type)
{
case MQTT_MSG_TYPE_SUBACK:
if(client->mqtt_state.pending_msg_type == MQTT_MSG_TYPE_SUBSCRIBE && client->mqtt_state.pending_msg_id == msg_id)
INFO("MQTT: Subscribe successful\r\n");
break;
case MQTT_MSG_TYPE_UNSUBACK:
if(client->mqtt_state.pending_msg_type == MQTT_MSG_TYPE_UNSUBSCRIBE && client->mqtt_state.pending_msg_id == msg_id)
INFO("MQTT: UnSubscribe successful\r\n");
break;
case MQTT_MSG_TYPE_PUBLISH:
if(msg_qos == 1)
client->mqtt_state.outbound_message = mqtt_msg_puback(&client->mqtt_state.mqtt_connection, msg_id);
else if(msg_qos == 2)
client->mqtt_state.outbound_message = mqtt_msg_pubrec(&client->mqtt_state.mqtt_connection, msg_id);
if(msg_qos == 1 || msg_qos == 2){
INFO("MQTT: Queue response QoS: %d\r\n", msg_qos);
if(QUEUE_Puts(&client->msgQueue, client->mqtt_state.outbound_message->data, client->mqtt_state.outbound_message->length) == -1){
INFO("MQTT: Queue full\r\n");
}
}
deliver_publish(client, client->mqtt_state.in_buffer, client->mqtt_state.message_length_read);
break;
case MQTT_MSG_TYPE_PUBACK:
if(client->mqtt_state.pending_msg_type == MQTT_MSG_TYPE_PUBLISH && client->mqtt_state.pending_msg_id == msg_id){
INFO("MQTT: received MQTT_MSG_TYPE_PUBACK, finish QoS1 publish\r\n");
}
break;
case MQTT_MSG_TYPE_PUBREC:
client->mqtt_state.outbound_message = mqtt_msg_pubrel(&client->mqtt_state.mqtt_connection, msg_id);
if(QUEUE_Puts(&client->msgQueue, client->mqtt_state.outbound_message->data, client->mqtt_state.outbound_message->length) == -1){
INFO("MQTT: Queue full\r\n");
}
break;
case MQTT_MSG_TYPE_PUBREL:
client->mqtt_state.outbound_message = mqtt_msg_pubcomp(&client->mqtt_state.mqtt_connection, msg_id);
if(QUEUE_Puts(&client->msgQueue, client->mqtt_state.outbound_message->data, client->mqtt_state.outbound_message->length) == -1){
INFO("MQTT: Queue full\r\n");
}
break;
case MQTT_MSG_TYPE_PUBCOMP:
if(client->mqtt_state.pending_msg_type == MQTT_MSG_TYPE_PUBLISH && client->mqtt_state.pending_msg_id == msg_id){
INFO("MQTT: receive MQTT_MSG_TYPE_PUBCOMP, finish QoS2 publish\r\n");
}
break;
case MQTT_MSG_TYPE_PINGREQ:
client->mqtt_state.outbound_message = mqtt_msg_pingresp(&client->mqtt_state.mqtt_connection);
if(QUEUE_Puts(&client->msgQueue, client->mqtt_state.outbound_message->data, client->mqtt_state.outbound_message->length) == -1){
INFO("MQTT: Queue full\r\n");
}
break;
case MQTT_MSG_TYPE_PINGRESP:
// TODO : the heart beat ack, if not receive heart beat...
break;
}
// NOTE: this is done down here and not in the switch case above
// because the PSOCK_READBUF_LEN() won't work inside a switch
// statement due to the way protothreads resume.
if(msg_type == MQTT_MSG_TYPE_PUBLISH)
{
INFO("PUBLISH MESSAGE,receive length:%d, actual length:%d\n",client->mqtt_state.message_length, client->mqtt_state.message_length_read);
len = client->mqtt_state.message_length_read;
if(client->mqtt_state.message_length < client->mqtt_state.message_length_read)
{
INFO("uu3\n");
//client->connState = MQTT_PUBLISH_RECV;
//Not Implement yet
len -= client->mqtt_state.message_length;
pdata += client->mqtt_state.message_length;
INFO("Get another published message\r\n");
goto READPACKET;
}
}
break;
}
} else {
INFO("ERROR: Message too long\r\n");
}
system_os_post(MQTT_TASK_PRIO, 0, (os_param_t)client);
}
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);
}
struct sub_device_buffer * FUNCTION_ATTRIBUTE construct_sub_device_data()
{
struct sub_device_buffer *data_buffer = NULL;
struct TLVs *params_block = NULL;
int ret = 0;
uint16_t property_num = 0x1516;
uint16_t property_num2 = 0x1122;
uint16_t flag = 0;
uint32_t data_param1 = 0xa1b2c3d4;
uint8_t data_param2 = 0xc1;
char data_param3[] = "test data";
//create buffer, remember delete
data_buffer = create_data_package(flag);
if (data_buffer == NULL)
{
pd_printf("Create data package failed.");
}
params_block = create_params_block();
if (params_block == NULL)
{
pd_printf("Create first tlv param failed.\n");
return NULL;
}
if (add_next_uint32(params_block, data_param1))
{
delete_params_block(params_block);
pd_printf("Add next tlv param failed.\n");
return NULL;
}
if (add_next_uint8(params_block, data_param2))
{
delete_params_block(params_block);
pd_printf("Add next tlv param failed.\n");
return NULL;
}
if (add_next_bytes(params_block, strlen(data_param3), data_param3))
{
delete_params_block(params_block);
pd_printf("Add next tlv param failed.\n");
return NULL;
}
add_next_property(data_buffer, property_num, params_block);
// once the params block has been added to data package
//you must delete it even you are going to add another block to the package
delete_params_block(params_block);
//add different property
params_block = create_params_block();
if (params_block == NULL)
{
pd_printf("Create first tlv param failed.\n");
return NULL;
}
if (add_next_uint8(params_block, data_param2))
{
delete_params_block(params_block);
pd_printf("Add next tlv param failed.\n");
return NULL;
}
if (add_next_bytes(params_block, strlen(data_param3), data_param3))
{
delete_params_block(params_block);
pd_printf("Add next tlv param failed.\n");
return NULL;
}
ret = add_next_property(data_buffer, property_num2, params_block);
if (ret != 0)
{
delete_params_block(params_block);
pd_printf("add_next_property failed.");
return NULL;
}
//do not forget to delete params block again
delete_params_block(params_block);
finish_package(data_buffer);
show_package(data_buffer->buffer, data_buffer->buffer_length);
return data_buffer;
}
