コード例 #1
0
uint16_t FUNCTION_ATTRIBUTE get_tlv_len(struct TLV *params_in)
{
    uint8_t need_length;
    uint16_t type = 0;
    uint16_t length = 0;
    void *value_pos = NULL;

    if (params_in == NULL)
    {
        return -1;
    }
    
    pd_memcpy(&type, &(params_in->type), sizeof(params_in->type));
    type = net16_to_host(type);
    
    need_length = is_tlv_need_length(type);
    if (need_length == 1)
    {        
        pd_memcpy(&length, &(params_in->length), sizeof(params_in->length));
        length = net16_to_host(length);
    }
    else
    {
        length = get_type_length(type);
    }

    return length;
}
コード例 #2
0
int FUNCTION_ATTRIBUTE pando_protocol_encode(struct pando_buffer *pdbuf, uint16_t *payload_type)
{
	uint8_t *position = pdbuf->buffer + pdbuf->offset;
	uint8_t *buffer_end = pdbuf->buffer + pdbuf->buff_len;
	struct mqtt_bin_header m_header;
	struct device_header sub_device_header;
	struct device_header *header = (struct device_header*)position;
    
    if ((position += DEV_HEADER_LEN) > buffer_end)
    {
        pd_printf("Incorrect encode buffer length.\n");
        return -1;
    }

    pd_memcpy(&payload_type, &(header->payload_type), sizeof(header->payload_type));
    *payload_type = net16_to_host(*payload_type);
    pd_memcpy(&(sub_device_header.flags), &(header->flags), sizeof(header->flags));
	sub_device_header.flags = net16_to_host(sub_device_header.flags);	
	
	if (init_pdbin_header(&m_header, &sub_device_header))
	{
		pd_printf("Init pdbin header failed.\n");
		return -1;
	}    
    
	
	position -= GATE_HEADER_LEN;
	pd_memcpy(position, &m_header, GATE_HEADER_LEN);
	pdbuf->offset = pdbuf->offset + DEV_HEADER_LEN - GATE_HEADER_LEN;
	return 0;
}
コード例 #3
0
char *pando_protocol_get_uri(struct pando_buffer *pdbuf)
{
	if (pdbuf == NULL)
	{
		return NULL;
	}

	struct sub_device_buffer device_buffer;
	device_buffer.buffer_length = pdbuf->buff_len - pdbuf->offset;
	device_buffer.buffer = pdbuf->buffer + pdbuf->offset;

	struct pando_command cmd_body;
	struct TLV *cmd_param = get_sub_device_command(&device_buffer, &cmd_body);
	
	int i = 0;
	uint16_t tlv_type, tlv_length;
	for (i = 0; i < cmd_body.params->count; i++)
	{
		pd_memcpy(&tlv_type, &(cmd_param->type), sizeof(tlv_type));
		tlv_type = net16_to_host(tlv_type);

		pd_memcpy(&tlv_length, &(cmd_param->length), sizeof(tlv_length));
		tlv_length = net16_to_host(tlv_length);

		if (tlv_type == TLV_TYPE_URI)
		{
			return (char *)cmd_param->value;
		}

		cmd_param = (struct TLV *)((uint8_t *)cmd_param + sizeof(struct TLV) + tlv_length);
	}

	return NULL;
}
コード例 #4
0
struct TLV *get_next_property(struct pando_property *next_property, struct pando_property *property_body)
{
    property_body->sub_device_id = net16_to_host(next_property->sub_device_id);
    property_body->property_num = net16_to_host(next_property->property_num);
    property_body->params->count = net16_to_host(next_property->params->count);


    return (struct TLV *)(next_property + sizeof(struct pando_property));
}
コード例 #5
0
struct TLV * FUNCTION_ATTRIBUTE get_tlv_value(struct TLV *params_in, void *value)
{
    uint8_t need_length;
    void *value_pos = NULL;
    uint16_t type_p;
    uint16_t length_p;
    uint16_t *type = &type_p;
    uint16_t *length = &length_p;

    pd_memcpy(type, &(params_in->type), sizeof(params_in->type));
    *type = net16_to_host(*type);
    
    need_length = is_tlv_need_length(*type);
    if (need_length == 1)
    {        
        pd_memcpy(length, &(params_in->length), sizeof(params_in->length));
        *length = net16_to_host(*length);
        pd_memcpy(value, params_in->value, *length);
    }
    else
    {
        *length = get_type_length(*type);
        value_pos = (uint8_t *)params_in + sizeof(params_in->type);
        pd_memcpy(value, value_pos, *length);
        switch (*type)
        {
            case TLV_TYPE_FLOAT64:
                net64f_to_host(*(double *)value);
                break;
            case TLV_TYPE_UINT64:
            case TLV_TYPE_INT64:
                net64_to_host(*(uint64_t *)value);
                break;
            case TLV_TYPE_FLOAT32:
                net32f_to_host(*(float *)value);
                break;
            case TLV_TYPE_UINT32:
            case TLV_TYPE_INT32:
                net32_to_host(*(uint32_t *)value);
                break;
            case TLV_TYPE_INT8:
            case TLV_TYPE_UINT8:
            case TLV_TYPE_BOOL:
                break;
            case TLV_TYPE_INT16:
            case TLV_TYPE_UINT16:
                net16_to_host(*(uint16_t *)value);
                break;
            default:
                break;
        }//switch            
    }//need_length == 0
    
	return (struct TLV *)((uint8_t *)params_in + *length + sizeof(struct TLV) 
        - (!need_length) * sizeof(*length));    
}
コード例 #6
0
struct TLVs * FUNCTION_ATTRIBUTE get_next_property(
    struct pando_property *next_property, struct pando_property *property_body)
{
    property_body->sub_device_id = net16_to_host(next_property->sub_device_id);
    property_body->property_num = net16_to_host(next_property->property_num);
    property_body->params->count = net16_to_host(next_property->params->count);


    return (struct TLVs *)((uint8_t *)next_property 
        + sizeof(struct pando_property)
        - sizeof(struct TLVs));
}
コード例 #7
0
struct TLV *get_tlv_param(struct TLV *params_in, uint16_t *type, 
    uint16_t *length, void *value)

{
    uint8_t need_length;

    pd_memcpy(type, &(params_in->type), sizeof(params_in->type));
    pd_memcpy(length, &(params_in->length), sizeof(params_in->type));
    *type = net16_to_host(*type);
    *length = net16_to_host(*length);

    
    need_length = is_tlv_need_length(*type);
    if (need_length == 1)
    {
        value = params_in->value;
    }
    else
    {
        pd_memcpy(value, params_in->value, *length);

        switch (*type)
        {
            case TLV_TYPE_FLOAT64:
                net64f_to_host(*(double *)value);
                break;
            case TLV_TYPE_UINT64:
            case TLV_TYPE_INT64:
                net64_to_host(*(uint64_t *)value);
                break;
            case TLV_TYPE_FLOAT32:
                net32f_to_host(*(float *)value);
                break;
            case TLV_TYPE_UINT32:
            case TLV_TYPE_INT32:
                net32_to_host(*(uint32_t *)value);
                break;
            case TLV_TYPE_INT8:
            case TLV_TYPE_UINT8:
            case TLV_TYPE_BOOL:
                break;
            case TLV_TYPE_INT16:
            case TLV_TYPE_UINT16:
                net16_to_host(*(uint16_t *)value);
                break;
            default:
                break;
        }//switch            
    }//need_length == 0
    
	return (params_in + *length + sizeof(struct TLV) - need_length * sizeof(*length));
}
コード例 #8
0
struct TLV * FUNCTION_ATTRIBUTE get_sub_device_property(struct sub_device_buffer *device_buffer, struct pando_property *property_body)
{
    struct pando_property *tmp_body = (struct pando_property *)(device_buffer->buffer + DEV_HEADER_LEN);

    struct device_header *head = (struct device_header *)device_buffer->buffer;
	base_params.command_sequence = net32_to_host(head->frame_seq);

    property_body->sub_device_id = net16_to_host(tmp_body->sub_device_id);
    property_body->property_num = net16_to_host(tmp_body->property_num);
    property_body->params->count = net16_to_host(tmp_body->params->count);
	
	return (struct TLV *)(device_buffer->buffer + DEV_HEADER_LEN + sizeof(struct pando_property));
}
コード例 #9
0
uint16_t FUNCTION_ATTRIBUTE get_tlv_type(struct TLV *params_in)
{
    uint16_t type = 0;
    pd_memcpy(&type, &(params_in->type), sizeof(params_in->type));
    type = net16_to_host(type);
    return type;
}
コード例 #10
0
struct TLVs * FUNCTION_ATTRIBUTE get_sub_device_command(
    struct sub_device_buffer *device_buffer, struct pando_command *command_body)
{
	struct pando_command *tmp_body = (struct pando_command *)(device_buffer->buffer + DEV_HEADER_LEN);

	//需要对包头进行校验,尚未编写
	struct device_header *head = (struct device_header *)device_buffer->buffer;
	base_params.command_sequence = net32_to_host(head->frame_seq);
    command_body->sub_device_id = net16_to_host(tmp_body->sub_device_id);

	command_body->command_num = net16_to_host(tmp_body->command_num);
	command_body->priority = net16_to_host(tmp_body->priority);
	command_body->params->count = net16_to_host(tmp_body->params->count);
	
	return (struct TLVs *)(device_buffer->buffer + DEV_HEADER_LEN 
        + sizeof(struct pando_command) - sizeof(struct TLVs));
}
コード例 #11
0
//pdbuf points to the buffer contains command from server ,it's big endian.
uint16_t pando_protocol_get_payload_type(struct pando_buffer *pdbuf)
{
	if (pdbuf == NULL)
	{
		return -1;
	}

	struct device_header *gateway_header = (struct device_header *)(pdbuf->buffer + pdbuf->offset);
	return net16_to_host(gateway_header->payload_type);
}
コード例 #12
0
static struct TLV FUNCTION_ATTRIBUTE *get_current_tlv(struct TLVs *params)
{
    if (s_current_param.handled_length == 0) //first tlv
    {
        s_current_param.tlv_count = net16_to_host(params->count);        
    }
    
    return (struct TLV *)((uint8_t *)params + sizeof(struct TLVs) 
        + s_current_param.handled_length);   
}
コード例 #13
0
struct TLV * FUNCTION_ATTRIBUTE get_sub_device_command(struct sub_device_buffer *device_buffer, struct pando_command *command_body)
{
	struct pando_command *tmp_body = (struct pando_command *)(device_buffer->buffer + DEV_HEADER_LEN);

	//需要对包头进行校验,尚未编写
	struct device_header *head = (struct device_header *)device_buffer->buffer;
	base_params.command_sequence = net32_to_host(head->frame_seq);
    command_body->sub_device_id = net16_to_host(tmp_body->sub_device_id);
/*
	if ((command_body->sub_device_id = net16_to_host(tmp_body->sub_device_id)) != base_params.sub_device_id)
	{
		pd_printf("Local sub device id: %d, receive a command to id : %d.\n", base_params.sub_device_id, command_body->sub_device_id);
		return -1;
	}*/
	command_body->command_id = net16_to_host(tmp_body->command_id);
	command_body->priority = net16_to_host(tmp_body->priority);
	command_body->params->count = net16_to_host(tmp_body->params->count);
	
	return (struct TLV *)(device_buffer->buffer + DEV_HEADER_LEN + sizeof(struct pando_command));
}
コード例 #14
0
uint16_t FUNCTION_ATTRIBUTE get_sub_device_payloadtype(struct sub_device_buffer *package)
{
    struct device_header *head;
 
    if (package == NULL)
	{
		return -1;
	}
    
    head = (struct device_header *)package->buffer;

    return net16_to_host(head->payload_type);
}
コード例 #15
0
int pando_protocol_get_sub_device_id(struct pando_buffer *buf, uint16_t *sub_device_id)
{
    uint8_t *pos = buf->buffer + GATE_HEADER_LEN + buf->offset;
    
	if (pos == NULL)
	{
		pd_printf("subdevice null\n");
		return -1;
	}
	else
	{
        pd_memcpy(sub_device_id, pos, sizeof(*sub_device_id));
        *sub_device_id = net16_to_host(*sub_device_id);
		return 0;
	}

}
コード例 #16
0
int add_next_property(struct sub_device_buffer *data_package, uint16_t property_num, struct TLVs *next_data_params)
{
    uint8_t *new_buffer = NULL;
    uint8_t *position = NULL;
    struct device_header *hdr = (struct device_header *)data_package->buffer;
    uint16_t payload_len = 0;
    
    uint16_t append_len = sizeof(struct pando_property) + current_tlv_block_size - sizeof(struct TLVs);
    

    if (data_package == NULL)
    {
        return -1;
    }

    /* append payload length */
    payload_len = net16_to_host(hdr->payload_len);
    data_package->buffer_length += append_len;
    payload_len += append_len;
    hdr->payload_len = host16_to_net(payload_len);
    
    new_buffer = (uint8_t *)pd_malloc(data_package->buffer_length);
    pd_memset(new_buffer, 0, data_package->buffer_length);

    /* copy buffer content, skip subdev id, copy property num and tlv params */
    position = new_buffer + data_package->buffer_length - append_len;
    pd_memcpy(new_buffer, data_package->buffer, data_package->buffer_length);

    position += 2;  //sub device id
    property_num = host16_to_net(property_num);
    pd_memcpy(position, &property_num, sizeof(property_num));
    
    position += sizeof(property_num);
    pd_memcpy(position, next_data_params, current_tlv_block_size);  
    pd_free(data_package->buffer);
    data_package->buffer = new_buffer;

    return 0;
}
コード例 #17
0
ファイル: weektask.c プロジェクト: Zhang-Jia/ds1307-plug-demo
void ICACHE_FLASH_ATTR
weektask_set(struct weektask* value) {
	// TODO: implement object set function here.
	// the set function read value and operate the hardware.
	int len1 = os_strlen(value->weekday);
	int len2 = os_strlen(value->time);
	uint8 temp[5];
	uint16 delay = net16_to_host(value->delay);   //minute
	int8 repeat = value->repeat;   //1:repeat, 0: not repeat
	int8 enable = value->enable;	//1: enable, 0: disable
	int i,j=0;
	uint16 id = 0;

	for(i=0; i<2*TASK_BUF_MAX_LENGTH; i++)
	{
		task_buf[i] = 0;
	}

	PRINTF("\nweektask_set weekday:%s, time:%s, len1:%d,len2:%d,delay:%d,repeat:%d, enable:%d\n",
			value->weekday, value->time,len1, len2, delay, repeat, enable);
	if((len1 <= 0) || (len1 > 7))
	{
		PRINTF("\nlen1:%d\n",len1);
		return;
	}
	PRINTF("\npass len1:%d\n",len1);
	if(len2 != 5)
	{
		PRINTF("\nlen2:%d\n",len2);
		return;
	}
	if((repeat != 0) && (repeat != 1))
	{
		PRINTF("\nrepeat:%d\n",repeat);
		return;
	}
	if((enable != 0) && (enable != 1))
	{
		PRINTF("\nenable:%d\n",enable);
		return;
	}

	spi_flash_read((PRIV_PARAM_START_SEC + WEEKTASK_FLASH_SECTOR_NO) * SPI_FLASH_SEC_SIZE,
		    	(uint32 *)task_buf, TASK_BUF_MAX_LENGTH);

	for(i=0; i<4; i++)
	{
		temp[i] = task_buf[i];
	}
	temp[i] = '\0';

	id =  (uint16)strtol(temp, NULL, 16);
	if(id >= 0xFFFD)
	{
		id = 0;
	}
	id++;

	os_sprintf(&task_buf[0], "%04X", id);

	j=4;
	for(i=0; i < len1; i++)
	{
		if((value->weekday[i]> '0') && (value->weekday[i] <= '7'))
			task_buf[j++] = value->weekday[i];
	}
	if(j<11)
	{
		for(i=j; i<11; i++)
			task_buf[i] = '0';
	}
	for(i=0,j=11; i<len2; i++)
	{
		if((i == 2) && (value->time[i] != ':'))
		{
			PRINTF("\nquit i:%d\n",i);
			return;
		}
		else if((i!=2) && ((value->time[i] < '0') || (value->time[i] > '9')))
		{
			PRINTF("\nvalue->time[%d]:%X\n",i, value->time[i]);
			return;
		}
		task_buf[j++] = value->time[i];
	}

	os_sprintf(&task_buf[j], "%04X%X%X", delay, repeat, enable);

	PRINTF("\n Get weektask:%s\n", task_buf);

	for(i=0, j=TASK_BUF_MAX_LENGTH; i<TASK_BUF_MAX_LENGTH; i++,j++)
	{
		task_buf[j] = task_buf[i];
	}


	spi_flash_erase_sector(PRIV_PARAM_START_SEC + WEEKTASK_FLASH_SECTOR_NO);
	spi_flash_write((PRIV_PARAM_START_SEC + WEEKTASK_FLASH_SECTOR_NO) * SPI_FLASH_SEC_SIZE,
	    	    (uint32 *)task_buf, 2*TASK_BUF_MAX_LENGTH);
}
コード例 #18
0
int FUNCTION_ATTRIBUTE add_next_param(struct TLVs *params_block, uint16_t next_type, uint16_t next_length, void *next_value)
{
	uint16_t type;
    uint16_t conver_length;
    uint8_t need_length;
    uint8_t tlv_length;
	uint8_t tmp_value[8];
    uint8_t *tlv_position;
	struct TLVs *new_property_block = NULL;
	uint16_t current_count = net16_to_host(params_block->count);	//由于create的时候就对该值进行了端转换,因此需要回转

    need_length = is_tlv_need_length(next_type);
    if (1 == need_length)
    {
        
    }
    else if (0 == need_length)
    {
        if(next_length != get_type_length(next_type))
        {
            printf("Param type dismatch with the input length\n");
            return -1;
        }
    }
    else
    {
        return -1;
    }
    
	//信息区扩容
	if (current_tlv_block_size + next_length + sizeof(struct TLV) 
        - (!need_length) * sizeof(next_length) > tlv_block_buffer_size)
	{
		tlv_block_buffer_size = tlv_block_buffer_size + DEFAULT_TLV_BLOCK_SIZE + next_length;
		new_property_block = (struct TLVs *)pd_malloc(tlv_block_buffer_size);
		pd_memcpy(new_property_block, params_block, current_tlv_block_size);
		pd_free(params_block);
		params_block = new_property_block;
	} 

	current_count++;
	tlv_position = (uint8_t *)params_block + current_tlv_block_size;

	//将count保存为网络字节序,便于创建事件或数据包时直接赋值
	params_block->count = host16_to_net(current_count);
	
	//复制tlv内容,并大小端转换,修正tlv长度和type的设置方式,解决跨字错误
	type = host16_to_net(next_type);
	pd_memcpy(tlv_position, &type, sizeof(type));
    tlv_position += sizeof(type);

    
	if (need_length)
	{
        conver_length = host16_to_net(next_length);
	    pd_memcpy(tlv_position, &conver_length, sizeof(conver_length));
        tlv_position += sizeof(conver_length);
    }
	

	switch(next_type)
	{
	    case TLV_TYPE_FLOAT64 :
		    *((double *)tmp_value) = host64f_to_net(*((uint64_t *)next_value));
		    pd_memcpy(tlv_position, tmp_value, next_length);
		    break;
    	case TLV_TYPE_FLOAT32 :
    		*((float *)tmp_value) = host32f_to_net(*((float *)next_value));
    		pd_memcpy(tlv_position, tmp_value, next_length);
    			break;
	    case TLV_TYPE_INT16:
		    *((int16_t *)tmp_value) = host16_to_net(*((int16_t *)next_value));
    		pd_memcpy(tlv_position, tmp_value, next_length);
	    	break;
    	case TLV_TYPE_UINT16:
	    	*((uint16_t *)tmp_value) = host16_to_net(*((uint16_t *)next_value));
		    pd_memcpy(tlv_position, tmp_value, next_length);
		    break;
    	case TLV_TYPE_INT32:
	    	*((int32_t *)tmp_value) = host32_to_net(*((int32_t *)next_value));
		    pd_memcpy(tlv_position, tmp_value, next_length);
		    break;
	    case TLV_TYPE_UINT32:
		    *((uint32_t *)tmp_value) = host32_to_net(*((uint32_t *)next_value));
		    pd_memcpy(tlv_position, tmp_value, next_length);
    	    break;
	    case TLV_TYPE_UINT64:
    		*((uint64_t *)tmp_value) = host64_to_net(*((uint64_t *)next_value));
	    	pd_memcpy(tlv_position, tmp_value, next_length);
		    break;
    	case TLV_TYPE_INT64:
	    	*((int64_t *)tmp_value) = host64_to_net(*((int64_t *)next_value));
		    pd_memcpy(tlv_position, tmp_value, next_length);
		    break;
	    default:
	        pd_memcpy(tlv_position, next_value, next_length);
		    break;
	}

	current_tlv_block_size = current_tlv_block_size + next_length 
        + sizeof(struct TLV) - (!need_length) * sizeof(next_length);
    
	return 0;
}