PowLu/TencentOS-tiny
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit for opensource

Browse Source 
first commit for opensource
This commit is contained in:
supowang
2019-09-16 13:19:50 +08:00
parent 08ab013b8e
commit edb2879617
6303 changed files with 5472815 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
examples/LoRaWAN/lora_demo.c Normal file
View File

@@ -0,0 +1,30 @@
#include "lora_demo.h"
void lorawan_demo(void)
{
int count = 1;
extern int rhf76_lora_init(hal_uart_port_t uart_port);
rhf76_lora_init(HAL_UART_PORT_0);
tos_lora_module_join();
while (1) {
if (count % 20 == 0) {
// printf("############task1 count is %d \r\n",count++);
tos_lora_module_send("test data",sizeof("test data"));
}
count++;
osDelay(500);
}
}
void application_entry(void *arg)
{
lorawan_demo();
while (1) {
printf("This is a lorawan demo!\r\n");
tos_task_delay(1000);
}
}

24
examples/LoRaWAN/lora_demo.h Normal file
View File

@@ -0,0 +1,24 @@
#ifndef __APP_DEMO_H__
#define __APP_DEMO_H__
#include "mcu_init.h"
#include "tos_at.h"
#include "string.h"
#include "cmsis_os.h"
#include "lora_module_wrapper.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct
{
char data[32];
}ReportData_TypeDef;
void application_entry(void *arg);
#ifdef __cplusplus
}
#endif
#endif /* __APP_DEMO_H__ */

276
examples/farm_ai_demo/farm_ai_demo.c Normal file
View File

@@ -0,0 +1,276 @@
#include "farm_ai_demo.h"
#include "tos_farm_ai_config.h"
#include "cJSON.h"
#include "E53_IA1.h"
#include "mcu_init.h"
//#define USE_NB_BC35
#define USE_ESP8266
int sock_id = 0;
double math_keep_ndot(double num,char dot){
char temp[100];
sprintf((char *)temp,"%.*lf",dot,num);
sscanf(temp,"%lf",&num);
return num;
}
static int str_to_hex(const char *bufin, int len, char *bufout)
{
int i = 0;
unsigned char tmp2 = 0x0;
unsigned int tmp = 0;
if (NULL == bufin || len <= 0 || NULL == bufout)
{
return -1;
}
for(i = 0; i < len; i = i+2)
{
tmp2 = bufin[i];
tmp2 = tmp2 <= '9'?tmp2-0x30:tmp2-0x37;
tmp = bufin[i+1];
tmp = tmp <= '9'?tmp-0x30:tmp-0x37;
bufout[i/2] =(tmp2<<4)|(tmp&0x0F);
}
return 0;
}
int mq_dev_report(void)
{
char *data;
char topic[50]={0};
cJSON *root = NULL;
mqtt_pub_opt_t pub_opt;
pub_opt.dup = 0;
pub_opt.qos = 0;
pub_opt.retained = 0;
pub_opt.id = 0;
pub_opt.topic = MQTT_PUBLISH_TOPIC;
// {"motor":0,"light":1,"temperature":22.22,"humidity":55.55,"light_intensity":100.00}
// printf("motor:%d,light:%d,tem:%f,humi:%f,lux:%f\n",E53_IA1_Data.MotorMode,E53_IA1_Data.LightMode,E53_IA1_Data.Temperature,E53_IA1_Data.Humidity,E53_IA1_Data.Lux);
root = cJSON_CreateObject();
cJSON_AddNumberToObject(root, "motor",E53_IA1_Data.MotorMode);
cJSON_AddNumberToObject(root, "light",E53_IA1_Data.LightMode);
cJSON_AddNumberToObject(root, "temperature",math_keep_ndot((double)E53_IA1_Data.Temperature,2));
cJSON_AddNumberToObject(root, "humidity",math_keep_ndot((double)E53_IA1_Data.Humidity,2));
cJSON_AddNumberToObject(root, "light_intensity",math_keep_ndot((double)E53_IA1_Data.Lux,2));
/* formatted print */
//data = cJSON_Print(root);
data=cJSON_PrintUnformatted(root);
pub_opt.topic = MQTT_PUBLISH_TOPIC;
pub_opt.payload =(unsigned char *)data;
pub_opt.payload_len = strlen(data);
printf("\r\nreport--->topic:%s\r\ndata(%d):%s", pub_opt.topic,pub_opt.payload_len,pub_opt.payload);
if (tos_mqtt_publish(sock_id, &pub_opt) != 0) {
printf("publish failed!!!\n");
}
tos_mmheap_free(data);
cJSON_Delete(root);
return 0;
}
int parse_dev_cmd(char *data)
{
//{"motor":0,"light":1}
//JSON字符串到cJSON格式
cJSON* cjson = cJSON_Parse(data);
cJSON *cjsonret=NULL;
int motor;
int light;
char *str;
printf("parse_dev_cmd...\n");
//判断cJSON_Parse函数返回值确定是否打包成<E58C85>??
if(cjson == NULL){
printf("json pack into cjson error...");
return -1;
}
else{//打包成功调用cJSON_Print打印输出
cJSON_Print(cjson);
}
cjsonret = NULL;
cjsonret = cJSON_GetObjectItem(cjson,"motor");
if(cjsonret!=NULL)
{
//打印输出
motor=cjsonret->valueint;
printf("motor=%d\n",motor);
if(motor==1)
{//power on relay
motor_control(1);
}
else if(motor==0)
{//power off relay
motor_control(0);
}
}
cjsonret = NULL;
cjsonret = cJSON_GetObjectItem(cjson,"light");
if(cjsonret!=NULL)
{
//打印输出
light=cjsonret->valueint;
//打印输出
printf("light=%d\n",light);
if(light==1)
{//power on relay
light_control(1);
}
else if(light==0)
{//power off relay
light_control(0);
}
}
cjsonret = cJSON_GetObjectItem(cjson,"speaker");
if(cjsonret!=NULL)
{
//打印输出
printf("parse speaker:%s\n",cjsonret->valuestring);
str=tos_mmheap_alloc(strlen(cjsonret->valuestring));
if(str!=NULL)
{
memset(str,0x00,strlen(cjsonret->valuestring));
str_to_hex(cjsonret->valuestring,strlen(cjsonret->valuestring),str);
extern void speaker(char *str);
speaker(str);
tos_mmheap_free(str);
}
}
//delete cjson
cJSON_Delete(cjson);
return 0;
}
int mq_dev_receiv(void){
static int count = 1;
uint8_t read_data[100];
int read_len;
char topic[50];
mqtt_sub_opt_t sub_opt;
sub_opt.count = 1;
sub_opt.dup = 0;
sub_opt.id = 1;
sub_opt.req_qos = 0;
sub_opt.topic = MQTT_SUBSCRIBE_TOPIC;
printf("MQTT count: %d\r\n",count);
printf("read buf1,\r\n");
read_len = tos_mqtt_receive(sub_opt.topic, strlen(sub_opt.topic), read_data, sizeof(read_data));
if (read_len >= 0) {
printf("---------->topic: %s, payload: %s, payload_len: %d\n", sub_opt.topic, read_data, read_len);
parse_dev_cmd(read_data);
}
count++;
}
int mq_dev_subscribe(void){
char topic[50];
mqtt_sub_opt_t sub_opt;
sub_opt.count = 1;
sub_opt.dup = 0;
sub_opt.id = 1;
sub_opt.req_qos = 0;
sub_opt.topic = MQTT_SUBSCRIBE_TOPIC;
printf("subscribe topic1:%s",sub_opt.topic);
if (tos_mqtt_subscribe(sock_id, &sub_opt) != 0) {
printf("subscribe failed!!!\n");
}
}
void ai_demo(void)
{
mqtt_con_opt_t con_opt;
#ifdef USE_ESP8266
extern int esp8266_sal_init(hal_uart_port_t uart_port);
extern int esp8266_join_ap(const char *ssid, const char *pwd);
esp8266_sal_init(HAL_UART_PORT_0);
esp8266_join_ap("test", "12345678");
#endif
#ifdef USE_M26
int m26_sal_init(hal_uart_port_t uart_port);
m26_power_on();
m26_sal_init(HAL_UART_PORT_0);
#endif
#ifdef USE_NB_BC35
int bc35_28_95_sal_init(hal_uart_port_t uart_port);
bc35_28_95_sal_init(HAL_UART_PORT_0);
#endif
con_opt.keep_alive_interval = 2000;
con_opt.cleansession = 1;
con_opt.username = MQTT_USR_NAME;
con_opt.password = MQTT_PASSWORD;
con_opt.client_id = MQTT_CLIENT_ID;
sock_id = tos_mqtt_connect(MQTT_SERVER_IP, MQTT_SERVER_PORT, &con_opt);
printf("socke id id %d \r\n",sock_id);
mq_dev_subscribe();
while (1)
{
mq_dev_report();
mq_dev_receiv();
osDelay(1000);
}
}
void sensor_read(void){
while(1){
E53_IA1_Read_Data();
osDelay(100);
}
}
#define welcomspeak "<22><>ӭTOS"
//#define welcomspeak "<22><>ӭ"
//FD 00 06 01 01 BB B6 D3 AD
void speaker(char *str){
char data[100];
int16_t len=0;
char code=0;
char times=10;
int ret;
len=2+strlen(str);
printf("speaker(%s)\n",str);
data[0]=0xFD;
data[1]=len>>16;
data[2]=len&0x00FF;
data[3]=0x01;
data[4]=0x01;
memcpy(&data[5],str,len-2);
HAL_UART_Transmit(&huart3,data,len+3,1000);
}
#define SENSOR_READ_TASK_STK_SIZE 2048
extern void sensor_read(void);
osThreadDef(sensor_read, osPriorityNormal, 1, SENSOR_READ_TASK_STK_SIZE);
void application_entry(void *arg)
{
printf("mqtt demo run!\r\n");
Init_E53_IA1();
speaker(welcomspeak);
osThreadCreate(osThread(sensor_read), NULL);
ai_demo();
while (1) {
printf("This is a mqtt demo!\r\n");
tos_task_delay(1000);
}
}

15
examples/farm_ai_demo/farm_ai_demo.h Normal file
View File

@@ -0,0 +1,15 @@
#ifndef __MQTT_DEMO_H__
#define __MQTT_DEMO_H__
#include "mcu_init.h"
#include "tos_at.h"
#include "string.h"
#include "cmsis_os.h"
#include "sal_module_wrapper.h"
#include "mqtt_wrapper.h"
void application_entry(void *arg);
#endif /* __APP_DEMO_H__ */

15
examples/farm_ai_demo/tos_farm_ai_config.h Normal file
View File

@@ -0,0 +1,15 @@
#ifndef _H_TOS_FARM_AI_CONFIG_H
#define _H_TOS_FARM_AI_CONFIG_H
#define MQTT_SERVER_IP "iotcloud-mqtt.gz.tencentdevices.com"
#define MQTT_SERVER_PORT "1883"
#define MQTT_PRODUCT_ID "LOLCIH8A14"
#define MQTT_DEV_NAME "AiDev1"
#define MQTT_CLIENT_ID "LOLCIH8A14AiDev1"
#define MQTT_USR_NAME "LOLCIH8A14AiDev1;12010126;12345;4294967295"
#define MQTT_PASSWORD "f96ded50ae2f98718a094d8fc0a20558e6b4ad3197a95128a3d4b0b70734ce17;hmacsha256"
#define MQTT_SUBSCRIBE_TOPIC "LOLCIH8A14/AiDev1/control"
#define MQTT_PUBLISH_TOPIC "LOLCIH8A14/AiDev1/data"
#endif

57
examples/fatfs/fatfs_sample.c Normal file
View File

@@ -0,0 +1,57 @@
#include "tos.h"
#include "tos_hal.h"
#include "ff.h"
char workbuf[4096];
void application_entry(void *arg)
{
FRESULT res;
uint32_t length;
FIL file;
FATFS sd_fatfs;
res = f_mount(&sd_fatfs, "1:", 1);
if (res != FR_OK) {
printf("unknown fs. res = %d\ndo disk format....\n", res);
res = f_mkfs("1:", FM_ANY, 0, workbuf, sizeof(workbuf));
if (res == FR_OK) {
f_setlabel("0:sample");
res = f_mount(&sd_fatfs, "1:", 1);
} else {
printf("format error %d\n\r", res);
}
}
res = f_open(&file, "1://test_file.txt", FA_CREATE_ALWAYS | FA_WRITE);
if (res != FR_OK) {
printf("open file error:%d\n\r",res);
}
res = f_write(&file, "fatfs sample content", strlen("fatfs sample content"), &length);
if (res == FR_OK) {
printf("write ok: %d\n", length);
printf("write data:\n%s\n", "fatfs sample content");
} else {
printf("write error: %d\n", res);
}
f_close(&file);
res = f_open(&file, "1://test_file.txt", FA_OPEN_EXISTING | FA_READ);
if (res != FR_OK) {
printf("open file error: %d\n", res);
}
memset(workbuf, 0, sizeof(workbuf));
res = f_read(&file, workbuf, sizeof(workbuf), &length);
if (res == FR_OK) {
printf("read ok: %d\n",length);
printf("read data:\n%s\n", workbuf);
} else {
printf("read error: %d\n", res);
}
f_close(&file);
f_sync(&file);
}

76
examples/fatfs_through_vfs/fatfs_through_vfs_sample.c Normal file
View File

@@ -0,0 +1,76 @@
#include "tos.h"
#include "tos_hal.h"
#include "ff.h"
#include "tos_vfs.h"
#include "tos_fatfs_drv.h"
#include "tos_fatfs_vfs.h"
char buf[512];
void application_entry(void *arg)
{
int fd, ret;
extern vfs_blkdev_ops_t sd_dev;
extern vfs_fs_ops_t fatfs_ops;
tos_vfs_block_device_register("/dev/sd", &sd_dev);
tos_vfs_fs_register("fatfs_sd", &fatfs_ops);
if (tos_vfs_fs_mkfs("/dev/sd", "fatfs_sd", FM_ANY, 0) != 0) {
printf("mkfs failed!\n");
}
if (tos_vfs_fs_mount("/dev/sd", "/fs/fatfs_sd", "fatfs_sd") != 0) {
printf("mount failed!\n");
}
fd = tos_vfs_open("/fs/fatfs_sd/test_file.txt", VFS_OFLAG_CREATE_ALWAYS | VFS_OFLAG_WRITE);
if (fd < 0) {
printf("open failed!\n");
}
ret = tos_vfs_write(fd, "fatfs sample content", strlen("fatfs sample content"));
if (ret >= 0) {
printf("write ok\n");
printf("write data:\n%s\n", "fatfs sample content");
} else {
printf("write error: %d\n", ret);
}
ret = tos_vfs_close(fd);
if (ret < 0) {
printf("close failed!\n");
}
fd = tos_vfs_open("/fs/fatfs_sd/test_file.txt", VFS_OFLAG_EXISTING | VFS_OFLAG_READ);
if (fd < 0) {
printf("open file error: %d\n", ret);
}
memset(buf, 0, sizeof(buf));
ret = tos_vfs_read(fd, buf, sizeof(buf));
if (ret >= 0) {
printf("read ok: %d\n", ret);
printf("read data:\n%s\n", buf);
} else {
printf("read error: %d\n", ret);
}
////////////////////////////////////////////////
ret = tos_vfs_lseek(fd, 2, VFS_SEEK_CUR);
if (ret < 0) {
printf("lseek error\n");
}
memset(buf, 0, sizeof(buf));
ret = tos_vfs_read(fd, buf, sizeof(buf));
if (ret >= 0) {
printf("read ok: %d\n", ret);
printf("read data:\n%s\n", buf);
} else {
printf("read error: %d\n", ret);
}
/////////////////////////////////////////////////
tos_vfs_close(fd);
}

42
examples/hello_world/hello_world.c Normal file
View File

@@ -0,0 +1,42 @@
#include "cmsis_os.h"
#define TASK1_STK_SIZE 512
void task1(void *arg);
osThreadDef(task1, osPriorityNormal, 1, TASK1_STK_SIZE);
#define TASK2_STK_SIZE 512
void task2(void *arg);
osThreadDef(task2, osPriorityNormal, 1, TASK2_STK_SIZE);
void task1(void *arg)
{
int count = 1;
while (1) {
printf("###This is task1, %d\r\n", count++);
osDelay(2000);
}
}
void task2(void *arg)
{
int count = 1;
while (1) {
#if TOS_CFG_TASK_STACK_DRAUGHT_DEPTH_DETACT_EN > 0u
k_err_t rc;
int depth;
rc = tos_task_stack_draught_depth(K_NULL, &depth);
printf("%d %d\n", rc, depth);
#endif
printf("***This is task2, %d\r\n", count++);
osDelay(1000);
}
}
void application_entry(void *arg)
{
osThreadCreate(osThread(task1), NULL); // Create task1
osThreadCreate(osThread(task2), NULL); // Create task2
}

62
examples/sensor/sensor_demo.c Normal file
View File

@@ -0,0 +1,62 @@
#include "sensor_demo.h"
#include "E53_IA1.h"
void e53_ia1_demo(void)
{
Init_E53_IA1();
while (1)
{
E53_IA1_Read_Data();
printf("\r\n******************************BH1750 Value is %d\r\n", (int)E53_IA1_Data.Lux);
printf("\r\n******************************Humidity is %d\r\n",(int)E53_IA1_Data.Humidity);
printf("\r\n******************************Temperature is %d\r\n", (int)E53_IA1_Data.Temperature);
HAL_GPIO_TogglePin(IA1_Motor_GPIO_Port, IA1_Motor_Pin);
HAL_GPIO_TogglePin(IA1_Light_GPIO_Port, IA1_Light_Pin);
osDelay(3000);
}
}
void e53_st1_demo(void)
{
Init_E53_ST1();
while (1)
{
E53_ST1_Read_Data();
printf("\r\n******************************Longitude Value is %.6f\r\n", E53_ST1_Data.Longitude);
printf("\r\n******************************Latitude is %.6f\r\n", E53_ST1_Data.Latitude);
E53_ST1_Beep(ST1_ON);
E53_ST1_LED_StatusSet(ST1_ON);
osDelay(2000);
E53_ST1_Beep(ST1_OFF);
E53_ST1_LED_StatusSet(ST1_OFF);
osDelay(2000);
}
}
void e53_sf1_demo(void)
{
Init_E53_SF1();
while (1)
{
E53_SF1_Read_Data();
printf("\r\n******************************Smoke Value is %d\r\n", E53_SF1_Data.Smoke_Value);
E53SF1_Beep(ON);
osDelay(2000);
E53SF1_Beep(OFF);
osDelay(2000);
}
}
void application_entry(void *arg)
{
e53_ia1_demo();
//e53_st1_demo();
//e53_sf1_demo();
while (1) {
printf("This is a sensor demo!\r\n");
tos_task_delay(1000);
}
}

21
examples/sensor/sensor_demo.h Normal file
View File

@@ -0,0 +1,21 @@
#ifndef __SENSOR_DEMO_H__
#define __SENSOR_DEMO_H__
#include "mcu_init.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct
{
char data[32];
}ReportData_TypeDef;
void application_entry(void *arg);
#ifdef __cplusplus
}
#endif
#endif /* __APP_DEMO_H__ */

94
examples/tcp_through_module/tcp_through_module.c Normal file
View File

@@ -0,0 +1,94 @@
#include "esp8266.h"
#include "mcu_init.h"
#include "sal_module_wrapper.h"
#include "cmsis_os.h"
#define TCP_TEST_TASK0_STK_SIZE 4096
void tcp_test0(void);
osThreadDef(tcp_test0, osPriorityNormal, 1, TCP_TEST_TASK0_STK_SIZE);
#define TCP_TEST_TASK1_STK_SIZE 4096
void tcp_test1(void);
osThreadDef(tcp_test1, osPriorityNormal, 1, TCP_TEST_TASK1_STK_SIZE);
int socket_id_0 = -1;
int socket_id_1 = -1;
#define RECV_LEN 1024
uint8_t recv_data_0[RECV_LEN];
uint8_t recv_data_1[RECV_LEN];
void tcp_test0(void)
{
int recv_len = -1;
while (1) {
tos_sal_module_send(socket_id_0, (const void*)"This is TCP Test!\r\n", strlen("This is TCP Test!\r\n"));
recv_len = tos_sal_module_recv_timeout(socket_id_0, recv_data_0, sizeof(recv_data_0), 8000);
if (recv_len < 0) {
printf("task0 receive error\n");
} else if (recv_len == 0) {
printf("task0 receive none\n");
} else {
recv_data_0[recv_len] = 0;
printf("task0: receive len: %d\nmsg from remote: %s\n", recv_len, recv_data_0);
}
tos_sleep_ms(2000);
}
}
void tcp_test1(void)
{
int recv_len = -1;
while (1) {
tos_sal_module_send(socket_id_1, (const void *)"Hello Tencent!\r\n", strlen("Hello Tencent!\r\n"));
recv_len = tos_sal_module_recv_timeout(socket_id_1, recv_data_1, sizeof(recv_data_1), 8000);
if (recv_len < 0) {
printf("task1 receive error\n\r");
} else if (recv_len == 0) {
printf("task1 receive none\n");
} else {
recv_data_1[recv_len] = 0;
printf("task1: receive len: %d\nmsg from remote: %s\n", recv_len, recv_data_1);
}
tos_sleep_ms(2000);
}
}
#define USE_ESP8266
void application_entry(void *arg)
{
#ifdef USE_ESP8266
esp8266_sal_init(HAL_UART_PORT_0);
esp8266_join_ap("SheldonDai", "srnr6x9xbhmb0");
#endif
#ifdef USE_SIM800A
sim800a_power_on();
sim800a_sal_init(HAL_UART_PORT_2);
#endif
socket_id_0 = tos_sal_module_connect("39.108.190.129", "8080", TOS_SAL_PROTO_TCP);
if (socket_id_0 == -1) {
printf("TCP0 connect failed\r\n");
} else {
printf("TCP0 connect success! fd: %d\n", socket_id_0);
}
socket_id_1 = tos_sal_module_connect("39.108.190.129", "8001", TOS_SAL_PROTO_TCP);
if (socket_id_1 == -1) {
printf("TCP1 connect failed\r\n");
} else {
printf("TCP1 connect success! fd: %d\n", socket_id_1);
}
osThreadCreate(osThread(tcp_test0), NULL);
osThreadCreate(osThread(tcp_test1), NULL);
}

60
examples/tcp_udp_base_lwip/tcp_client/tcp_client.c Normal file
View File

@@ -0,0 +1,60 @@
#include "tcp_client.h"
#include <stdio.h>
#include <string.h>
#include "lwip/api.h"
#include <lwip/sockets.h>
#include <lwip/err.h>
#include <lwip/sys.h>
#include <errno.h>
char recvline[512];
const char *str = "Welcome to TencentOS Tiny!";
const char *server_ip = "182.254.196.11";
const unsigned short server_port = 8087;
void application_entry(void *arg)
{
int socketfd, len;
static int cnt=0;
struct sockaddr_in sockaddr;
struct timeval tv = {10, 0};
MX_LWIP_Init();
while (1) {
socketfd = socket(AF_INET, SOCK_STREAM, 0);
setsockopt(socketfd, SOL_SOCKET, SO_RCVTIMEO, (char*)&tv, sizeof(struct timeval));
memset(&sockaddr, 0, sizeof(sockaddr));
sockaddr.sin_addr.s_addr = inet_addr(server_ip);
sockaddr.sin_family = AF_INET;
sockaddr.sin_port = htons(server_port);
if ((connect(socketfd, (struct sockaddr*)&sockaddr, sizeof(sockaddr))) < 0) {
printf("connect error %s errno: %d\n", strerror(errno), errno);
goto tcp_client_exit;
}
printf("send(%d): %s:%d :%s\n", ++cnt, server_ip, server_port, str);
if ((send(socketfd, str, strlen(str), 0)) < 0) {
printf("send mes error: %s errno : %d\n", strerror(errno), errno);
goto tcp_client_exit;
}
len = recv(socketfd, recvline, sizeof(recvline), 0);
if (len > 0) {
recvline[len] = '\0';
printf("recv msg from server: %s\n", recvline);
} else {
printf("recv err(%d)\n", len);
}
close(socketfd);
tos_task_delay(1000);
}
tcp_client_exit:
printf("exit\n");
}

11
examples/tcp_udp_base_lwip/tcp_client/tcp_client.h Normal file
View File

@@ -0,0 +1,11 @@
#ifndef _TCP_CLIENT_H
#define _TCP_CLIENT_H
#include "sys.h"
#include "lwip/debug.h"
#include "lwip/stats.h"
#include "lwip/tcp.h"
#include "ethernetif.h"
#endif

62
examples/tcp_udp_base_lwip/tcp_server/tcp_server.c Normal file
View File

@@ -0,0 +1,62 @@
#include "tcp_server.h"
#include "stdio.h"
#include "string.h"
#include "ethernetif.h"
#include "lwip/api.h"
#include <lwip/sockets.h>
#include <lwip/err.h>
#include <lwip/sys.h>
#include <errno.h>
char buff[512];
void application_entry(void *arg)
{
int n;
int listenfd,connfd;
struct sockaddr_in sockaddr;
static int cnt=0;
MX_LWIP_Init();
memset(&sockaddr,0,sizeof(sockaddr));
sockaddr.sin_family = AF_INET;
sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);
sockaddr.sin_port = htons(8087);
if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
return;
}
if ((bind(listenfd, (struct sockaddr *)&sockaddr, sizeof(sockaddr))) == -1){
printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
return;
}
if ((listen(listenfd, 1024)) == -1) {
printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
return;
}
printf("listen the port(8087)\n");
for (;;) {
if ((connfd = accept(listenfd, (struct sockaddr*)NULL, NULL)) == -1) {
printf("accpet socket error: %s errno :%d\n",strerror(errno),errno);
continue;
}
n = recv(connfd, buff, sizeof(buff), 0);
buff[n] = '\0';
printf("recv(%d) msg from client:%s\n", ++cnt, buff);
if ((send(connfd, buff, strlen(buff), 0)) < 0) {
printf("send mes error: %s errno : %d\n", strerror(errno), errno);
break;
}
close(connfd);
}
close(listenfd);
}

12
examples/tcp_udp_base_lwip/tcp_server/tcp_server.h Normal file
View File

@@ -0,0 +1,12 @@
#ifndef __TCP_SERVER_DEMO_H
#define __TCP_SERVER_DEMO_H
#include "lwip/debug.h"
#include "lwip/stats.h"
#include "lwip/tcp.h"
#include "lwip/memp.h"
#include "lwip/mem.h"
#include "ethernetif.h"
#endif

46
examples/tcp_udp_base_lwip/udp_client/udp_client.c Normal file
View File

@@ -0,0 +1,46 @@
#include "udp_client.h"
#include "lwip/api.h"
#include <lwip/sockets.h>
#include <lwip/err.h>
#include <lwip/sys.h>
char buff[512];
const char *str = "Welcome to TencentOS Tiny!";
const char *server_ip = "182.254.196.11";
const unsigned short server_port = 8000;
void application_entry(void *arg)
{
int confd;
ssize_t reclen;
struct timeval tv = {10, 0};
struct sockaddr_in serveraddr;
MX_LWIP_Init();
// 1. <20><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>socket
confd = socket(AF_INET, SOCK_DGRAM, 0);
setsockopt(confd, SOL_SOCKET, SO_RCVTIMEO, (char*)&tv, sizeof(struct timeval));
// 2. <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ
memset(&serveraddr, 0, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
inet_pton(AF_INET, server_ip, &serveraddr.sin_addr.s_addr);
serveraddr.sin_port = htons(server_port);
printf("sendto: %s:%d :%s\n", server_ip, server_port, str);
// 3. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
sendto(confd, str, strlen(str), 0, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
reclen = recvfrom(confd, buff, sizeof(buff), 0, NULL, 0);
if (reclen > 0){
buff[reclen] = '\0';
printf("rec(%d):%s\n", reclen, buff);
} else {
printf("rec err(%d)", reclen);
}
// 5. <20>ر<EFBFBD>socket
close(confd);
}

7
examples/tcp_udp_base_lwip/udp_client/udp_client.h Normal file
View File

@@ -0,0 +1,7 @@
#ifndef __UDP_DEMO_H
#define __UDP_DEMO_H
#include "mcu_init.h"
#endif

47
examples/tcp_udp_base_lwip/udp_server/udp_server.c Normal file
View File

@@ -0,0 +1,47 @@
#include "udp_server.h"
#include "lwip/api.h"
#include <lwip/sockets.h>
#include <lwip/err.h>
#include <lwip/sys.h>
char buff[512]; // UDP<44><50><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݻ<EFBFBD><DDBB><EFBFBD><EFBFBD><EFBFBD>
const unsigned short server_port = 8000;
void application_entry(void *arg)
{
int sockfd, i;
ssize_t err, len;
struct sockaddr_in serveraddr, clientaddr;
char ipstr[INET_ADDRSTRLEN]; // 16 Bytes
socklen_t clientlen;
MX_LWIP_Init();
/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>UDP<44><50><EFBFBD>׽<EFBFBD><D7BD><EFBFBD> */
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
memset(&serveraddr, 0, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr = htonl(INADDR_ANY); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>IP
serveraddr.sin_port = htons(server_port);
while (1) {
bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
printf("udp blind ip:ANY,port:%d\n", server_port);
clientlen = sizeof(clientaddr);
len = recvfrom(sockfd, buff, sizeof(buff), 0, (struct sockaddr *)&clientaddr, &clientlen);
printf("client IP %s\tPORT %d\nrec:%s\n", inet_ntop(AF_INET, &clientaddr.sin_addr.s_addr, ipstr, sizeof(ipstr)), ntohs(clientaddr.sin_port), buff);
i = 0;
while (i < len) {
buff[i] = toupper(buff[i]);
i++;
}
buff[i] = '\0';
printf("send: %s\n", buff);
err = sendto(sockfd, buff, strlen(buff), 0, (struct sockaddr *)&clientaddr, sizeof(clientaddr));
if (err < 0){
break;
}
}
close(sockfd);
}

7
examples/tcp_udp_base_lwip/udp_server/udp_server.h Normal file
View File

@@ -0,0 +1,7 @@
#ifndef __UDP_DEMO_H
#define __UDP_DEMO_H
#include "mcu_init.h"
#endif

151
examples/tencent_cloud_sdk_coap/coap_sample.c Normal file
View File

@@ -0,0 +1,151 @@
/*
* Tencent is pleased to support the open source community by making IoT Hub available.
* Copyright (C) 2016 THL A29 Limited, a Tencent company. All rights reserved.
* Licensed under the MIT License (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://opensource.org/licenses/MIT
* Unless required by applicable law or agreed to in writing, software distributed under the License is
* distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include "tos.h"
#include "qcloud.h"
static void response_message_callback(void *msg, void *context)
{
int ret = -1;
char* payload = NULL;
int payload_len = 0;
coap_event_type_t event_type;
coap_message_t *message = NULL;
message = msg;
event_type = qcloud_coap_event_type_get(message);
switch (event_type) {
case COAP_EVENT_TYPE_RECEIVE_ACK:
QCLOUD_LOG_I("message received ACK, msgid: %d", qcloud_coap_msg_id_get(message));
break;
case COAP_EVENT_TYPE_RECEIVE_RESPCONTENT:
ret = qcloud_coap_msg_payload_get(message, &payload, &payload_len);
if (ret == QCLOUD_ERR_SUCCESS) {
QCLOUD_LOG_I("message received response, len: %d content: %s", payload_len, payload);
} else {
QCLOUD_LOG_E("message received response, content error.");
}
break;
case COAP_EVENT_TYPE_UNAUTHORIZED:
QCLOUD_LOG_I("coap client auth token expired or invalid, msgid: %d", qcloud_coap_msg_id_get(message));
break;
case COAP_EVENT_TYPE_FORBIDDEN:
QCLOUD_LOG_I("coap URI is invalid for this device, msgid: %d", qcloud_coap_msg_id_get(message));
break;
case COAP_EVENT_TYPE_INTERNAL_SERVER_ERROR:
QCLOUD_LOG_I("coap server internal error, msgid: %d", qcloud_coap_msg_id_get(message));
break;
case COAP_EVENT_TYPE_ACK_TIMEOUT:
QCLOUD_LOG_I("message receive ACK timeout, msgid: %d", qcloud_coap_msg_id_get(message));
break;
case COAP_EVENT_TYPE_SEPRESP_TIMEOUT:
QCLOUD_LOG_I("message received ACK but receive response timeout, msgid: %d", qcloud_coap_msg_id_get(message));
break;
default:
break;
}
}
static void event_handler(void *context, coap_event_t *event)
{
switch (event->type) {
case COAP_EVENT_TYPE_RECEIVE_ACK:
QCLOUD_LOG_I("message received ACK, msgid: %d", *(uint16_t *)event->message);
break;
case COAP_EVENT_TYPE_RECEIVE_RESPCONTENT:
QCLOUD_LOG_I("message received response, content: %s", qcloud_coap_msg_id_get(event->message));
break;
case COAP_EVENT_TYPE_UNAUTHORIZED:
QCLOUD_LOG_I("coap client auth token expired or invalid, msgid: %d", *(uint16_t *)event->message);
break;
case COAP_EVENT_TYPE_FORBIDDEN:
QCLOUD_LOG_I("coap URI is invalid for this device, msgid: %d", *(uint16_t *)event->message);
break;
case COAP_EVENT_TYPE_INTERNAL_SERVER_ERROR:
QCLOUD_LOG_I("coap server internal error, msgid: %d", *(uint16_t *)event->message);
break;
case COAP_EVENT_TYPE_ACK_TIMEOUT:
QCLOUD_LOG_I("message receive ACK timeout, msgid: %d", *(uint16_t *)event->message);
break;
case COAP_EVENT_TYPE_SEPRESP_TIMEOUT:
QCLOUD_LOG_I("message received ACK but receive response timeout, msgid: %d", *(uint16_t *)event->message);
break;
default:
QCLOUD_LOG_E("unrecogonized event type: %d", event->type);
break;
}
}
qcloud_device_t device;
qcloud_coap_client_t client;
int coap_thread(void)
{
char topic[128];
qcloud_err_t rc;
coap_send_opt_t send_opt;
qcloud_device_create(&device, "ABU45A5KT8", "dev001", "RPpqUxL03frSDSufVhjuLw==");
qcloud_coap_client_create(&client, &device, event_handler);
qcloud_coap_client_connect(&client);
do {
memset(&send_opt, 0, sizeof(coap_send_opt_t));
send_opt.payload = "{\"name\":\"hello world\"}";
send_opt.payload_len = strlen("{\"name\":\"hello world\"}");
send_opt.resp_cb = response_message_callback;
sprintf(topic, "%s/%s/data", device.product_id, device.device_name);
QCLOUD_LOG_I("topic: %s", topic);
rc = qcloud_coap_client_msg_send(&client, topic, &send_opt);
if (rc != QCLOUD_ERR_SUCCESS) {
QCLOUD_LOG_E("client publish topic failed :%d.", rc);
} else {
QCLOUD_LOG_D("client topic has been sent, msg_id: %d", rc);
}
rc = qcloud_coap_client_yield(&client, 200);
if (rc != QCLOUD_ERR_SUCCESS){
QCLOUD_LOG_E("exit with error: %d", rc);
break;
}
osal_sleep_ms(4000);
} while (1);
qcloud_coap_client_destroy(&client);
return 1;
}

42
examples/tencent_cloud_sdk_coap/tencent_cloud_sdk_coap.c Normal file
View File

@@ -0,0 +1,42 @@
#include "tos.h"
#define USE_ESP8266
#ifdef USE_LWIP
#include "lwip/api.h"
#include "lwip/sockets.h"
#include "lwip/err.h"
#include "lwip/sys.h"
#endif
#ifdef USE_ESP8266
#include "esp8266.h"
#endif
void application_entry(void *arg)
{
#ifdef USE_LWIP
dns_init();
MX_LWIP_Init();
#endif
#ifdef USE_ESP8266
extern int esp8266_sal_init(hal_uart_port_t uart_port);
extern int esp8266_join_ap(const char *ssid, const char *pwd);
esp8266_sal_init(HAL_UART_PORT_0);
esp8266_join_ap("SheldonDai", "srnr6x9xbhmb0");
#endif
#ifdef USE_NB_BC35
extern int bc35_28_95_sal_init(hal_uart_port_t uart_port);
bc35_28_95_sal_init(HAL_UART_PORT_0);
#endif
coap_thread();
while (1) {
printf("This is a mqtt demo!\r\n");
tos_task_delay(1000);
}
}

662
examples/tencent_cloud_sdk_data_template/light_data_template_sample.c Normal file
View File

@@ -0,0 +1,662 @@
/*
* Tencent is pleased to support the open source community by making IoT Hub available.
* Copyright (C) 2016 THL A29 Limited, a Tencent company. All rights reserved.
* Licensed under the MIT License (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://opensource.org/licenses/MIT
* Unless required by applicable law or agreed to in writing, software distributed under the License is
* distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include "qcloud.h"
#include "tos.h"
#if (QCLOUD_CFG_EVENT_EN > 0u)
#define EVENT_MESSAGE_MAX (64)
#define EVENT_NAME_MAX (64)
typedef enum event_status_en {
EVENT_STATUS_LIGHT_OFF,
EVENT_STATUS_LIGHT_ON,
} event_status_t;
static template_bool_t event_status;
static template_string_t event_message[EVENT_MESSAGE_MAX + 1];
static template_float_t event_voltage;
static template_string_t event_name[EVENT_NAME_MAX + 1];
static template_int_t event_error_code;
static shadow_dev_property_t event_property_status[] = {
{ .key = "status", .data = &event_status, .type = JSON_DATA_TYPE_BOOL },
{ .key = "message", .data = event_message, .type = JSON_DATA_TYPE_STRING },
};
static shadow_dev_property_t event_property_low_voltage[] = {
{ .key = "voltage", .data = &event_voltage, .type = JSON_DATA_TYPE_FLOAT },
};
static shadow_dev_property_t event_property_hardware_fault[] = {
{ .key = "name", .data = event_name, .type = JSON_DATA_TYPE_STRING },
{ .key = "error_code", .data = &event_error_code, .type = JSON_DATA_TYPE_INT32},
};
static qcloud_event_t events[] = {
{
.event_name = "status_report",
.type = "info",
.timestamp = 0,
.event_payload_count = sizeof(event_property_status) / sizeof(event_property_status[0]),
.event_payload = event_property_status,
},
{
.event_name = "low_voltage",
.type = "alert",
.timestamp = 0,
.event_payload_count = sizeof(event_property_low_voltage) / sizeof(event_property_low_voltage[0]),
.event_payload = event_property_low_voltage,
},
{
.event_name = "hardware_fault",
.type = "fault",
.timestamp = 0,
.event_payload_count = sizeof(event_property_hardware_fault) / sizeof(event_property_hardware_fault[0]),
.event_payload = event_property_hardware_fault,
},
};
#define EVENT_COUNTS (sizeof(events) / sizeof(events[0]))
#define EVENT_FLAG_STATUS (1u << 0)
#define EVENT_FLAG_LOW_VOLTAGE (1u << 1)
#define EVENT_FLAG_HARDWARE_FAULT (1u << 2)
static uint32_t event_flags = 0;
void event_flag_set(uint32_t flag)
{
event_flags |= flag & 0xffffffff;
}
void event_flag_unset(uint32_t flag)
{
event_flags &= (~flag) & 0xffffffff;
}
uint32_t event_flag_get(void)
{
return event_flags;
}
void event_flag_clear(void)
{
event_flags = 0;
}
/*-----------------event config end -------------------*/
static void update_event_timestamp(qcloud_event_t *event)
{
#ifdef EVENT_TIMESTAMP_USED
event->timestamp = (uint32_t)tos_systick_get(); //should be UTC and accurate
#else
event->timestamp = 0;
#endif
}
static void on_event_post_handler(void *client, mqtt_incoming_msg_t *msg)
{
QCLOUD_LOG_D("reply:%.*s", msg->payload_len, msg->payload);
}
#endif
/////////////////////////////////////////////////////////////////////////////////////
// dealing with product property template
#define LIGHT_NAME_MAX 64
typedef enum light_color_en {
LIGHT_COLOR_RED = 0,
LIGHT_COLOR_GREEN = 1,
LIGHT_COLOR_BLUE = 2,
} light_color_t; // a enum to describe the color of a light
typedef enum light_switch_state_en {
LIGHT_SWTICH_STATE_OFF = 0,
LIGHT_SWTICH_STATE_ON = 1,
} light_switch_state_t; // a enum to describe the switch state of a light
typedef enum property_state_en {
PROPERTY_STATE_NOCHANGE,
PROPERTY_STATE_CHANGED,
} property_state_t; // a enum to describe whether the property state has changed
typedef struct property_wrapper_st {
shadow_dev_property_t property;
property_state_t state;
} property_wrapper_t; // a wrapper of one property(contains the property and change state)
/* describe a light property */
typedef struct light_property_st {
property_wrapper_t switch_state;
property_wrapper_t color;
property_wrapper_t brightness;
property_wrapper_t name;
} light_property_t; // all the properties of a light
// how many properties of a light?
#define LIGHT_PROPERTY_COUNT (sizeof(light_property_t) / sizeof(property_wrapper_t))
typedef union light_property_handler_un {
property_wrapper_t property_wrappers[LIGHT_PROPERTY_COUNT];
light_property_t property_wrappers_of;
} light_property_handler_t; // a handler, user to iterate through all the properties
typedef struct light_profile_st {
template_bool_t switch_state;
template_int_t color;
template_float_t brightness;
template_string_t name[LIGHT_NAME_MAX + 1];
} light_profile_t; // just a data container
static int is_light_property_changed = QCLOUD_FALSE;
static int is_new_property_reported = QCLOUD_FALSE;
static light_profile_t light_profile;
static light_property_handler_t light_property_handler;
static void data_template_init(qcloud_device_t *device)
{
memset((void *)&light_profile, 0, sizeof(light_profile_t));
light_profile.switch_state = LIGHT_SWTICH_STATE_OFF;
light_profile.color = LIGHT_COLOR_RED;
light_profile.brightness = 0.0;
strncpy(light_profile.name, device->device_name, LIGHT_NAME_MAX);
light_profile.name[LIGHT_NAME_MAX] = '\0';
light_property_handler.property_wrappers_of.switch_state.property.key = "power_switch";
light_property_handler.property_wrappers_of.switch_state.property.data = &light_profile.switch_state;
light_property_handler.property_wrappers_of.switch_state.property.type = JSON_DATA_TYPE_BOOL;
light_property_handler.property_wrappers_of.color.property.key = "color";
light_property_handler.property_wrappers_of.color.property.data = &light_profile.color;
light_property_handler.property_wrappers_of.color.property.type = JSON_DATA_TYPE_INT32;
light_property_handler.property_wrappers_of.brightness.property.key = "brightness";
light_property_handler.property_wrappers_of.brightness.property.data = &light_profile.brightness;
light_property_handler.property_wrappers_of.brightness.property.type = JSON_DATA_TYPE_FLOAT;
light_property_handler.property_wrappers_of.name.property.key = "name";
light_property_handler.property_wrappers_of.name.property.data = &light_profile.name;
light_property_handler.property_wrappers_of.name.property.type = JSON_DATA_TYPE_STRING;
};
static int is_self_property(json_data_type_t property_type)
{
return property_type == JSON_DATA_TYPE_BOOL || // power switch
property_type == JSON_DATA_TYPE_INT32|| // color
property_type == JSON_DATA_TYPE_FLOAT || // brightness
property_type == JSON_DATA_TYPE_STRING; // device name
}
static void property_do_update(shadow_dev_property_t *property)
{
switch (property->type) {
case JSON_DATA_TYPE_BOOL: // power switch
light_profile.switch_state = *(template_bool_t *)property->data;
break;
case JSON_DATA_TYPE_INT32: // color
light_profile.color = *(template_int_t *)property->data;
break;
case JSON_DATA_TYPE_FLOAT: // brightness
light_profile.brightness = *(template_float_t *)property->data;
break;
case JSON_DATA_TYPE_STRING: // device name
/* 如果多个字符串属性,根据pProperty->key值匹配，处理字符串 */
if (strcmp("name", property->key) != 0) {
break;
}
memset(light_profile.name, 0, sizeof(light_profile.name));
strncpy(light_profile.name, property->data, LIGHT_NAME_MAX);
light_profile.name[LIGHT_NAME_MAX] = '\0';
break;
}
}
/* Èç¹ûÓÐ×Ô¶¨ÒåµÄ×Ö·û´®»òÕßjson£¬ÐèÒªÔÚÕâÀï½âÎö */
static qcloud_err_t property_update(const char *json_doc, shadow_dev_property_t *property)
{
QCLOUD_POINTER_SANITY_CHECK(json_doc, QCLOUD_ERR_INVAL);
QCLOUD_POINTER_SANITY_CHECK(property, QCLOUD_ERR_INVAL);
char *json_doc_mutable = NULL, *property_data = NULL;
/* convert const char * to char * */
json_doc_mutable = osal_malloc(strlen(json_doc));
QCLOUD_FUNC_EXIT_RC_IF(json_doc_mutable, NULL, QCLOUD_ERR_FAILURE);
strcpy(json_doc_mutable, json_doc);
property_data = LITE_json_value_of((char *)property->key, json_doc_mutable);
if (!property_data) {
QCLOUD_LOG_D("property:%s no matched", property->key);
osal_free(json_doc_mutable);
return QCLOUD_ERR_FAILURE;
}
property_do_update(property);
osal_free(property_data);
osal_free(json_doc_mutable);
return QCLOUD_ERR_SUCCESS;
}
/* 服务端有控制消息下发，会触发这里的delta回调 */
static void on_property_delta_handler(void *client, const char *json_doc, uint32_t json_doc_len, shadow_dev_property_t *property)
{
int i = 0;
for (i = 0; i < LIGHT_PROPERTY_COUNT; ++i) {
/* ÆäËûÊý¾ÝÀàÐÍÒѾ­ÔÚ_handle_deltaÁ÷³Ìͳһ´¦ÀíÁË£¬×Ö·û´®ºÍjson´®ÐèÒªÔÚÕâÀï´¦Àí£¬ÒòΪֻÓвúÆ·×Ô¼º²ÅÖªµÀstring/jsonµÄ×Ô¶¨Òå½âÎö */
if (strcmp(light_property_handler.property_wrappers[i].property.key, property->key) != 0) {
continue;
}
light_property_handler.property_wrappers[i].state = PROPERTY_STATE_CHANGED;
if (is_self_property(light_property_handler.property_wrappers[i].property.type)) {
property_update(json_doc, &(light_property_handler.property_wrappers[i].property));
}
QCLOUD_LOG_I("property=%s changed", property->key);
is_light_property_changed = QCLOUD_TRUE;
return;
}
QCLOUD_LOG_E("property=%s changed no match", property->key);
}
/* ×¢²áÊý¾ÝÄ£°åÊôÐÔ */
static qcloud_err_t data_template_property_register(qcloud_shadow_client_t *client)
{
int i = 0;
qcloud_err_t rc;
for (i = 0; i < LIGHT_PROPERTY_COUNT; ++i) {
rc = qcloud_shadow_device_property_register(client, &light_property_handler.property_wrappers[i].property, on_property_delta_handler);
if (rc != QCLOUD_ERR_SUCCESS) {
rc = qcloud_shadow_client_destroy(client);
QCLOUD_LOG_E("device template property register failed, err: %d", rc);
return rc;
}
QCLOUD_LOG_I("data template property=%s registered.", light_property_handler.property_wrappers[i].property.key);
}
return QCLOUD_ERR_SUCCESS;
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
__weak void OLED_Clear(void)
{
printf("OLED Clear\n");
}
__weak void OLED_ShowString(int x, int y, uint8_t *str, int bold)
{
printf("OLED ShowString: %s\n", (char *)str);
}
// handle the light(simulated)
static void light_change_color(const char *color)
{
// 作为demo，这里用oled屏字符显示来模拟灯颜色的切换
// 这里应该由用户实现硬件操作代码，来改变智能灯的颜色
// 此处demo，在开发板显示屏上显示具体的颜色
OLED_ShowString(0, 0, (uint8_t *)color, 8);
}
static void light_change_brightness(template_float_t brightness)
{
// 作为demo，这里用oled屏字符显示来模拟灯亮度的切换
// 这里应该由用户实现硬件操作代码，来改变智能灯的亮度
// 此处demo，在开发板显示屏上显示具体的亮度
char brightness_str[12];
snprintf(brightness_str, sizeof(brightness_str), "%f", brightness);
brightness_str[sizeof(brightness_str) - 1] = '\0';
OLED_ShowString(0, 2, (uint8_t *)brightness_str, 8);
}
static void light_power_on(void)
{
// 作为demo，这里用oled屏字符显示来模拟灯开关状态的切换
OLED_Clear();
}
static void light_power_off(void)
{
// 作为demo，这里用oled屏字符显示来模拟灯开关状态的切换
char *info = "light off";
OLED_Clear();
OLED_ShowString(0, 0, (uint8_t *)info, 16);
}
/////////////////////////////////////////////////////////////////////////////////////
static void incoming_messsage_handler(void *client, void *context, mqtt_event_t *event)
{
uint16_t packet_id = *(uint16_t *)event->message;
switch (event->type) {
case MQTT_EVENT_UNDEF:
QCLOUD_LOG_I("undefined event occur.");
break;
case MQTT_EVENT_DISCONNECT:
QCLOUD_LOG_I("MQTT disconnect.");
break;
case MQTT_EVENT_RECONNECT:
QCLOUD_LOG_I("MQTT reconnect.");
break;
case MQTT_EVENT_SUBCRIBE_SUCCESS:
QCLOUD_LOG_I("subscribe success, packet-id=%u", (uint32_t)packet_id);
break;
case MQTT_EVENT_SUBCRIBE_TIMEOUT:
QCLOUD_LOG_I("subscribe wait ack timeout, packet-id=%u", (uint32_t)packet_id);
break;
case MQTT_EVENT_SUBCRIBE_NACK:
QCLOUD_LOG_I("subscribe nack, packet-id=%u", (uint32_t)packet_id);
break;
case MQTT_EVENT_PUBLISH_SUCCESS:
QCLOUD_LOG_I("publish success, packet-id=%u", (uint32_t)packet_id);
break;
case MQTT_EVENT_PUBLISH_TIMEOUT:
QCLOUD_LOG_I("publish timeout, packet-id=%u", (uint32_t)packet_id);
break;
case MQTT_EVENT_PUBLISH_NACK:
QCLOUD_LOG_I("publish nack, packet-id=%u", (uint32_t)packet_id);
break;
default:
QCLOUD_LOG_I("Should NOT arrive here.");
break;
}
}
/* ʾÀýµÆ¹â¿ØÖÆ´¦ÀíÂß¼­ */
static void deal_down_stream_user_logic(void)
{
char *color_name;
switch (light_profile.color) {
case LIGHT_COLOR_RED:
color_name = " RED ";
break;
case LIGHT_COLOR_GREEN:
color_name = "GREEN";
break;
case LIGHT_COLOR_BLUE:
color_name = "BLUE";
break;
}
if (light_profile.switch_state == LIGHT_SWTICH_STATE_ON) {
light_power_on();
light_change_color(color_name);
light_change_brightness(light_profile.brightness);
} else {
light_power_off();
}
#if (QCLOUD_CFG_EVENT_EN > 0u)
if (light_property_handler.property_wrappers_of.switch_state.state == PROPERTY_STATE_CHANGED) {
if (light_profile.switch_state == LIGHT_SWTICH_STATE_ON) {
strcpy(event_message, "light on");
event_status = EVENT_STATUS_LIGHT_ON;
} else {
strcpy(event_message, "light off");
event_status = EVENT_STATUS_LIGHT_OFF;
}
event_flag_set(EVENT_FLAG_STATUS);
}
#endif
}
/* Óû§ÐèҪʵÏÖµÄÉÏÐÐÊý¾ÝµÄÒµÎñÂß¼­,´Ë´¦½ö¹©Ê¾Àý */
static void deal_up_stream_user_logic(shadow_dev_property_t *properties_report[], int *count)
{
int i, j;
*count = 0;
/* ÌáÈ¡³ö·¢Éú±ä¸üÁ˵ÄÊôÐÔ£¬Éϱ¨µ½ÔÆ */
for (i = 0, j = 0; i < LIGHT_PROPERTY_COUNT; ++i) {
if (light_property_handler.property_wrappers[i].state == PROPERTY_STATE_CHANGED) {
properties_report[j++] = &(light_property_handler.property_wrappers[i].property);
light_property_handler.property_wrappers[i].state = PROPERTY_STATE_NOCHANGE;
}
}
*count = j;
}
static void on_shadow_update_handler(void *client,
qcloud_shadow_req_method_t method,
qcloud_shadow_req_state_t req_state,
const char *json_doc,
void *context)
{
QCLOUD_LOG_I("recv shadow update response, request state: %d", req_state);
}
/* 5s¶¨Ê±Éϱ¨ÊôÐÔ״̬,¿É¸ù¾ÝÒµÎñ²Ã¼ô£¬´Ë´¦½ö¹©Ê¾Àý */
qcloud_err_t timely_reporting(shadow_dev_property_t *properties_report[], osal_timer_t *report_timer)
{
int i;
if (osal_timer_is_expired(report_timer)){
for (i = 0; i < LIGHT_PROPERTY_COUNT; ++i) {
properties_report[i] = &(light_property_handler.property_wrappers[i].property);
osal_timer_countdown_ms(report_timer, 5000);
}
return QCLOUD_ERR_SUCCESS;
}
return QCLOUD_ERR_INVAL;
}
static qcloud_device_t device;
static qcloud_shadow_client_t shadow_client;
static char shadow_update_buffer[2048];
static shadow_dev_property_t *properties_report[LIGHT_PROPERTY_COUNT];
#if (QCLOUD_CFG_EVENT_EN > 0u)
static qcloud_event_client_t event_client;
#endif
int data_template_light_thread(void)
{
qcloud_err_t rc;
int properties_report_count = 0;
osal_timer_t report_timer;
#if (QCLOUD_CFG_EVENT_EN > 0u)
uint32_t event_flag;
int event_count;
qcloud_event_t *events2report[EVENT_COUNTS];
#endif
QCLOUD_LOG_I("data template sample start");
qcloud_device_create(&device, "XC31USKYPL", "dev001", "Pz1wK0fVJHxSojqxDuuvmg==");
qcloud_shadow_client_create(&shadow_client, &device, incoming_messsage_handler, SHADOW_TYPE_TEMPLATE);
light_power_off();
data_template_init(&device);
#if (QCLOUD_CFG_EVENT_EN > 0u)
rc = qcloud_event_client_create(&event_client, &shadow_client, &device);
if (rc != QCLOUD_ERR_SUCCESS) {
QCLOUD_LOG_E("event init failed: %d", rc);
return rc;
}
#endif
rc = data_template_property_register(&shadow_client);
if (rc == QCLOUD_ERR_SUCCESS) {
QCLOUD_LOG_I("data template propertys register success");
} else {
QCLOUD_LOG_E("data template propertys register failed: %d", rc);
return rc;
}
#define SHADOW_REQUEST_TIMEOUT (10) // in seconds
rc = qcloud_shadow_client_get_sync(&shadow_client, SHADOW_REQUEST_TIMEOUT);
if (rc != QCLOUD_ERR_SUCCESS) {
QCLOUD_LOG_E("device shadow get failed, err: %d", rc);
return rc;
}
// 属性定时上报timer，可以根据业务需要裁剪。
osal_timer_init(&report_timer);
while (qcloud_shadow_client_is_connected(&shadow_client) ||
rc == QCLOUD_ERR_MQTT_ATTEMPTING_RECONNECT ||
rc == QCLOUD_ERR_MQTT_RECONNECTED ||
rc == QCLOUD_ERR_SUCCESS) {
rc = qcloud_shadow_client_yield(&shadow_client, 200);
if (rc == QCLOUD_ERR_MQTT_ATTEMPTING_RECONNECT) {
osal_sleep_ms(1000);
continue;
} else if (rc != QCLOUD_ERR_SUCCESS && rc != QCLOUD_ERR_MQTT_RECONNECTED) {
QCLOUD_LOG_E("exit with error: %d", rc);
break;
}
/* ·þÎñ¶ËÏÂÐÐÏûÏ¢£¬ÒµÎñ´¦ÀíÂß¼­1Èë¿Ú */
if (is_light_property_changed) {
// 服务器下发了控制指令，更改了设备的状态
deal_down_stream_user_logic();
/* ÒµÎñÂß¼­´¦ÀíÍêºóÐèҪͬ²½Í¨Öª·þÎñ¶Ë:É豸Êý¾ÝÒѸüУ¬É¾³ýdseireÊý¾Ý */
rc = qcloud_shadow_client_desire_null_construct(&shadow_client, shadow_update_buffer, sizeof(shadow_update_buffer));
if (rc == QCLOUD_ERR_SUCCESS) {
rc = qcloud_shadow_client_update_sync(&shadow_client, shadow_update_buffer, sizeof(shadow_update_buffer), 5);
if (rc == QCLOUD_ERR_SUCCESS) {
is_light_property_changed = QCLOUD_FALSE;
// Óû§ÐèÒª¸ù¾ÝÒµÎñÇé¿öÐÞ¸ÄÉϱ¨flagµÄ¸³ÖµÎ»ÖÃ,´Ë´¦½öΪʾÀý¡£
is_new_property_reported = QCLOUD_TRUE;
QCLOUD_LOG_I("shadow update(desired) success");
} else {
QCLOUD_LOG_E("shadow update(desired) failed, err: %d", rc);
}
} else {
QCLOUD_LOG_E("construct desire failed, err: %d", rc);
}
}
/* É豸ÉÏÐÐÏûÏ¢,ÒµÎñÂß¼­2Èë¿Ú */
if (is_new_property_reported) {
/* deltaÏûÏ¢ÊÇÊôÐÔµÄdesireºÍÊôÐÔµÄreportµÄ²îÒ켯£¬ÊÕµ½deseireÏûÏ¢´¦Àíºó£¬ÒªreportÊôÐÔµÄ״̬ */
deal_up_stream_user_logic(properties_report, &properties_report_count);
if (properties_report_count > 0) {
rc = qcloud_shadow_client_report_construct_array(&shadow_client, shadow_update_buffer, sizeof(shadow_update_buffer),
properties_report_count, properties_report);
if (rc == QCLOUD_ERR_SUCCESS) {
QCLOUD_LOG_D("report: %s", shadow_update_buffer);
rc = qcloud_shadow_client_update_async(&shadow_client, shadow_update_buffer, sizeof(shadow_update_buffer),
on_shadow_update_handler, NULL, 5);
if (rc == QCLOUD_ERR_SUCCESS) {
is_new_property_reported = QCLOUD_FALSE;
QCLOUD_LOG_I("shadow update(reported) success");
} else {
QCLOUD_LOG_E("shadow update(reported) failed, err: %d", rc);
}
} else {
QCLOUD_LOG_E("construct reported failed, err: %d", rc);
}
} else {
QCLOUD_LOG_D("no data need to be reported or someting goes wrong");
}
}
if (QCLOUD_ERR_SUCCESS == timely_reporting(properties_report, &report_timer)){
rc = qcloud_shadow_client_report_construct_array(&shadow_client, shadow_update_buffer, sizeof(shadow_update_buffer),
LIGHT_PROPERTY_COUNT, properties_report);
if (rc == QCLOUD_ERR_SUCCESS) {
QCLOUD_LOG_D("cycle report:%s", shadow_update_buffer);
rc = qcloud_shadow_client_update_async(&shadow_client, shadow_update_buffer, sizeof(shadow_update_buffer),
on_shadow_update_handler, NULL, 5);
if (rc == QCLOUD_ERR_SUCCESS) {
is_new_property_reported = QCLOUD_FALSE;
QCLOUD_LOG_I("shadow update(reported) success");
} else {
QCLOUD_LOG_E("shadow update(reported) failed, err: %d", rc);
}
} else {
QCLOUD_LOG_E("construct reported failed, err: %d", rc);
}
}
#if (QCLOUD_CFG_EVENT_EN > 0u)
// ʼþÉϱ¨
event_count = 0;
event_flag = event_flag_get();
if (EVENT_COUNTS > 0 && event_flag > 0) {
int i = 0;
for (i = 0; i < EVENT_COUNTS; ++i) {
if (event_flag & (1 << i)) { // i-th event is set
events2report[event_count++] = &events[i];
update_event_timestamp(&events[i]);
}
}
rc = qcloud_event_client_post(&event_client, shadow_update_buffer, sizeof(shadow_update_buffer), \
event_count, events2report, on_event_post_handler);
if (rc != QCLOUD_ERR_SUCCESS) {
QCLOUD_LOG_E("event post failed: %d", rc);
}
event_flag_clear();
}
#endif
osal_sleep_ms(3000);
}
qcloud_shadow_client_destroy(&shadow_client);
#if (QCLOUD_CFG_EVENT_EN > 0u)
qcloud_event_client_destroy(&event_client);
#endif
return -1;
}

42
examples/tencent_cloud_sdk_data_template/tencent_cloud_sdk_explorer.c Normal file
View File

@@ -0,0 +1,42 @@
#include "tos.h"
#define USE_LWIP
#ifdef USE_LWIP
#include "lwip/api.h"
#include "lwip/sockets.h"
#include "lwip/err.h"
#include "lwip/sys.h"
#endif
#ifdef USE_ESP8266
#include "esp8266.h"
#endif
void application_entry(void *arg)
{
#ifdef USE_LWIP
dns_init();
MX_LWIP_Init();
#endif
#ifdef USE_ESP8266
extern int esp8266_sal_init(hal_uart_port_t uart_port);
extern int esp8266_join_ap(const char *ssid, const char *pwd);
esp8266_sal_init(HAL_UART_PORT_0);
esp8266_join_ap("SheldonDai", "srnr6x9xbhmb0");
#endif
#ifdef USE_NB_BC35
extern int bc35_28_95_sal_init(hal_uart_port_t uart_port);
bc35_28_95_sal_init(HAL_UART_PORT_0);
#endif
data_template_light_thread();
while (1) {
printf("This is a tencent cloud sdk data template demo!\r\n");
tos_task_delay(1000);
}
}

189
examples/tencent_cloud_sdk_mqtt/mqtt_sample.c Normal file
View File

@@ -0,0 +1,189 @@
/*
* Tencent is pleased to support the open source community by making IoT Hub available.
* Copyright (C) 2016 THL A29 Limited, a Tencent company. All rights reserved.
* Licensed under the MIT License (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://opensource.org/licenses/MIT
* Unless required by applicable law or agreed to in writing, software distributed under the License is
* distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
#include <string.h>
#include <signal.h>
#include "tos.h"
#include "qcloud.h"
static int sg_count = 0;
static int sg_sub_packet_id = -1;
void event_handler(void *client, void *context, mqtt_event_t *event) {
mqtt_incoming_msg_t* mqtt_messge = NULL;
uint16_t packet_id = *(uint16_t *)event->message;
switch(event->type) {
case MQTT_EVENT_UNDEF:
QCLOUD_LOG_I("undefined event occur.");
break;
case MQTT_EVENT_DISCONNECT:
QCLOUD_LOG_I("MQTT disconnect.");
break;
case MQTT_EVENT_RECONNECT:
QCLOUD_LOG_I("MQTT reconnect.");
break;
case MQTT_EVENT_PUBLISH_RECVEIVED:
mqtt_messge = (mqtt_incoming_msg_t*)event->message;
QCLOUD_LOG_I("topic message arrived but without any related handle: topic=%.*s, topic_msg=%.*s",
mqtt_messge->topic_len,
mqtt_messge->topic,
mqtt_messge->payload_len,
mqtt_messge->payload);
break;
case MQTT_EVENT_SUBCRIBE_SUCCESS:
QCLOUD_LOG_I("subscribe success, packet-id=%u", (unsigned int)packet_id);
sg_sub_packet_id = packet_id;
break;
case MQTT_EVENT_SUBCRIBE_TIMEOUT:
QCLOUD_LOG_I("subscribe wait ack timeout, packet-id=%u", (unsigned int)packet_id);
sg_sub_packet_id = packet_id;
break;
case MQTT_EVENT_SUBCRIBE_NACK:
QCLOUD_LOG_I("subscribe nack, packet-id=%u", (unsigned int)packet_id);
sg_sub_packet_id = packet_id;
break;
case MQTT_EVENT_UNSUBCRIBE_SUCCESS:
QCLOUD_LOG_I("unsubscribe success, packet-id=%u", (unsigned int)packet_id);
break;
case MQTT_EVENT_UNSUBCRIBE_TIMEOUT:
QCLOUD_LOG_I("unsubscribe timeout, packet-id=%u", (unsigned int)packet_id);
break;
case MQTT_EVENT_UNSUBCRIBE_NACK:
QCLOUD_LOG_I("unsubscribe nack, packet-id=%u", (unsigned int)packet_id);
break;
case MQTT_EVENT_PUBLISH_SUCCESS:
QCLOUD_LOG_I("publish success, packet-id=%u", (unsigned int)packet_id);
break;
case MQTT_EVENT_PUBLISH_TIMEOUT:
QCLOUD_LOG_I("publish timeout, packet-id=%u", (unsigned int)packet_id);
break;
case MQTT_EVENT_PUBLISH_NACK:
QCLOUD_LOG_I("publish nack, packet-id=%u", (unsigned int)packet_id);
break;
default:
QCLOUD_LOG_I("Should NOT arrive here.");
break;
}
}
/**
* MQTT<54><54>Ϣ<EFBFBD><CFA2><EFBFBD>մ<EFBFBD><D5B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
*
* @param topicName topic<69><63><EFBFBD><EFBFBD>
* @param topicNameLen topic<69><63><EFBFBD><EFBFBD>
* @param message <20>Ѷ<EFBFBD><D1B6><EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD>Ľṹ
* @param userData <20><>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD>
*/
static void on_message_callback(void *client, mqtt_incoming_msg_t *message, void *private_data)
{
if (!message) {
return;
}
QCLOUD_LOG_I("Receive Message With topicName:%.*s, payload:%.*s",
(int) message->topic_len, message->topic, (int) message->payload_len, (char *)message->payload);
}
static qcloud_device_t device;
static mqtt_connect_opt_t connect_opt;
static qcloud_mqtt_client_t client;
static char topic_filter[128] = {0};
#define MAX_SIZE_OF_TOPIC_CONTENT 100
static char topic_payload[MAX_SIZE_OF_TOPIC_CONTENT + 1] = {0};
void mqtt_basic_thread(void)
{
qcloud_err_t rc;
mqtt_publish_opt_t publish_opt;
mqtt_subscribe_opt_t subscribe_opt;
QCLOUD_LOG_I("mqtt_sample start");
qcloud_device_create(&device, "XC31USKYPL", "dev001", "Pz1wK0fVJHxSojqxDuuvmg==");
qcloud_mqtt_connect_opt_create(&connect_opt, &device, MQTT_VERSION_3_1_1, 240, MQTT_CLEAN_SESSION_STATE_ENABLED);
qcloud_mqtt_client_create(&client, &device, event_handler, NULL, QCLOUD_AUTO_CONN_STATE_ENABLED);
qcloud_mqtt_client_connect(&client, &connect_opt);
osal_snprintf(topic_filter, sizeof(topic_filter), "%s/%s/%s", device.product_id, device.device_name, "data");
subscribe_opt.message_handler = on_message_callback;
subscribe_opt.private_data = NULL;
subscribe_opt.qos = MQTT_QOS0;
rc = qcloud_mqtt_client_subscribe(&client, topic_filter, &subscribe_opt);
if (rc != QCLOUD_ERR_SUCCESS) {
QCLOUD_LOG_E("Subscribe Failed: %d", rc);
} else {
QCLOUD_LOG_D("Subscribe success");
}
do {
rc = qcloud_mqtt_client_yield(&client, &connect_opt, 3000);
if (rc == QCLOUD_ERR_MQTT_ATTEMPTING_RECONNECT) {
osal_sleep_ms(1000);
continue;
} else if (rc != QCLOUD_ERR_SUCCESS && rc != QCLOUD_ERR_MQTT_RECONNECTED) {
QCLOUD_LOG_E("exit with error: %d", rc);
break;
}
// <20>ȴ<EFBFBD><C8B4><EFBFBD><EFBFBD>Ľ<EFBFBD><C4BD><EFBFBD>
if (sg_sub_packet_id > 0) {
sprintf(topic_filter, "%s/%s/%s", device.product_id, device.device_name, "data");
osal_snprintf(topic_payload, sizeof(topic_payload), "{\"action\": \"publish_test\", \"count\": \"%d\"}", sg_count++);
memset(&publish_opt, 0, sizeof(mqtt_publish_opt_t));
publish_opt.qos = MQTT_QOS1;
publish_opt.payload = topic_payload;
publish_opt.payload_len = strlen(topic_payload);
rc = qcloud_mqtt_client_publish(&client, topic_filter, &publish_opt);
if (rc != QCLOUD_ERR_SUCCESS) {
QCLOUD_LOG_E("client publish topic failed :%d.", rc);
}
}
osal_sleep_ms(1000);
} while (1);
qcloud_mqtt_client_destroy(&client);
return;
}

44
examples/tencent_cloud_sdk_mqtt/tencent_cloud_sdk_mqtt.c Normal file
View File

@@ -0,0 +1,44 @@
#include "tos.h"
#define USE_ESP8266
#ifdef USE_LWIP
#include "lwip/api.h"
#include "lwip/sockets.h"
#include "lwip/err.h"
#include "lwip/sys.h"
#endif
#ifdef USE_ESP8266
#include "esp8266.h"
#endif
void application_entry(void *arg)
{
extern void mqtt_basic_thread(void);
#ifdef USE_LWIP
dns_init();
MX_LWIP_Init();
#endif
#ifdef USE_ESP8266
extern int esp8266_sal_init(hal_uart_port_t uart_port);
extern int esp8266_join_ap(const char *ssid, const char *pwd);
esp8266_sal_init(HAL_UART_PORT_0);
esp8266_join_ap("SheldonDai", "srnr6x9xbhmb0");
#endif
#ifdef USE_NB_BC35
extern int bc35_28_95_sal_init(hal_uart_port_t uart_port);
bc35_28_95_sal_init(HAL_UART_PORT_0);
#endif
mqtt_basic_thread();
while (1) {
printf("This is a mqtt demo!\r\n");
tos_task_delay(1000);
}
}

86
examples/tencent_firmware_mqtt/tencent_firmware_mqtt.c Normal file
View File

@@ -0,0 +1,86 @@
#include "tos.h"
#include "esp8266_tencent_firmware.h"
#include "tencent_firmware_module_wrapper.h"
void mqtt_demo_task(void)
{
char payload[256];
mqtt_state_t state;
char *product_id = "03UKNYBUZG";
char *device_name = "at_dev";
char *key = "ttOARy0PjYgzd9OSs4Z3RA==";
device_info_t dev_info;
esp8266_tencent_firmware_sal_init(HAL_UART_PORT_3);
esp8266_tencent_firmware_join_ap("SheldonDai", "srnr6x9xbhmb0");
strncpy(dev_info.product_id, product_id, PRODUCT_ID_MAX_SIZE);
strncpy(dev_info.device_name, device_name, DEVICE_NAME_MAX_SIZE);
strncpy(dev_info.device_serc, key, DEVICE_SERC_MAX_SIZE);
tos_tf_module_info_set(&dev_info, TLS_MODE_PSK);
mqtt_param_t init_params = DEFAULT_MQTT_PARAMS;
if (tos_tf_module_mqtt_conn(init_params) != 0) {
printf("module mqtt conn fail\n");
} else {
printf("module mqtt conn success\n");
}
if (tos_tf_module_mqtt_state_get(&state) != -1) {
printf("MQTT: %s\n", state == MQTT_STATE_CONNECTED ? "CONNECTED" : "DISCONNECTED");
}
static char topic_name[TOPIC_MAX_SIZE] = {0};
int size = snprintf(topic_name, TOPIC_MAX_SIZE, "%s/%s/data", product_id, device_name);
if (size < 0 || size > sizeof(topic_name) - 1) {
printf("topic content length not enough! content size:%d buf size:%d", size, (int)sizeof(topic_name));
}
if (tos_tf_module_mqtt_sub(topic_name, QOS0) != 0) {
printf("module mqtt sub fail\n");
} else {
printf("module mqtt sub success\n");
}
while (1) {
HAL_Delay(1000);
memset(payload, 0, 256);
//*ע<><D7A2>ת<EFBFBD><D7AA><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬģ<CDAC><C4A3><EFBFBD><EFBFBD>json<6F><6E>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA>ת<EFBFBD>崦<EFBFBD><E5B4A6><EFBFBD><EFBFBD>Щ<EFBFBD><D0A9><EFBFBD><EFBFBD>*//
#if 0
#ifdef TRANSFER_LABEL_NEED
snprintf(payload, 256, "{\\\"action\\\": \\\"publish_test\\\"\\, \\\"count\\\": \\\"%d\\\"}", count++);
#else
snprintf(payload, 256, "{\"action\": \"publish_test\"\, \"count\": \"%d\"}", count++);
#endif
#else
strncpy(payload, "{\\\"type\\\":\\\"get\\\"\\, \\\"clientToken\\\":\\\"03UKNYBUZG-0\\\"}", sizeof(payload));
#endif
printf("message publish: %s\n", payload);
if (tos_tf_module_mqtt_pub(topic_name, QOS0, payload) != 0) {
printf("module mqtt pub fail\n");
break;
} else {
printf("module mqtt pub success\n");
}
if (tos_tf_module_mqtt_publ(topic_name, QOS0, payload) != 0) {
printf("module mqtt publ fail\n");
break;
} else {
printf("module mqtt publ success\n");
}
}
}
void application_entry(void *arg)
{
mqtt_demo_task();
while (1) {
printf("This is a mqtt demo!\r\n");
tos_task_delay(1000);
}
}

15
examples/tencent_os_mqtt/mqtt_config.h Normal file
View File

@@ -0,0 +1,15 @@
#ifndef _TOS_MQTT_CONFIG_H_
#define _TOS_MQTT_CONFIG_H_
#define MQTT_SERVER_IP "111.230.189.156"
#define MQTT_SERVER_PORT "1883"
#define MQTT_PRODUCT_ID "RUAP1R610V"
#define MQTT_DEV_NAME "supowang"
#define MQTT_CLIENT_ID "RUAP1R610Vsupowang"
#define MQTT_USR_NAME "RUAP1R610Vsupowang;21010406;12365;4294967295"
#define MQTT_PASSWORD "1371ae55cd1036f088bd7e39d230712bc3c32c40;hmacsha1"
#define MQTT_SUBSCRIBE_TOPIC "RUAP1R610V/supowang/data"
#define MQTT_PUBLISH_TOPIC "RUAP1R610V/supowang/data"
#endif

88
examples/tencent_os_mqtt/mqtt_example.c Normal file
View File

@@ -0,0 +1,88 @@
#include "esp8266.h"
#include "mqtt_wrapper.h"
#include "mqtt_config.h"
#define USE_ESP8266
void mqtt_demo(void)
{
int count = 1;
int sock_id = 0;
uint8_t read_data[40];
int read_len;
char topic[30];
char buffer[32];
mqtt_con_opt_t con_opt;
con_opt.keep_alive_interval = 2000;
con_opt.cleansession = 1;
con_opt.username = MQTT_USR_NAME;
con_opt.password = MQTT_PASSWORD;
con_opt.client_id = MQTT_CLIENT_ID;
mqtt_pub_opt_t pub_opt;
pub_opt.dup = 0;
pub_opt.qos = 0;
pub_opt.retained = 0;
pub_opt.id = 0;
pub_opt.topic = MQTT_PUBLISH_TOPIC;
mqtt_sub_opt_t sub_opt;
sub_opt.count = 1;
sub_opt.dup = 0;
sub_opt.id = 1;
sub_opt.req_qos = 0;
sub_opt.topic = MQTT_SUBSCRIBE_TOPIC;
#ifdef USE_ESP8266
esp8266_sal_init(HAL_UART_PORT_0);
esp8266_join_ap("SheldonDai", "srnr6x9xbhmb0");
#endif
#ifdef USE_NB_BC35
int bc35_28_95_sal_init(hal_uart_port_t uart_port);
bc35_28_95_sal_init(HAL_UART_PORT_0);
#endif
sock_id = tos_mqtt_connect(MQTT_SERVER_IP, MQTT_SERVER_PORT, &con_opt);
printf("socket id: %d\r\n",sock_id);
if (tos_mqtt_subscribe(sock_id, &sub_opt) != 0) {
printf("subscribe failed!!!\n");
}
while (1) {
memset(buffer, 0, sizeof(buffer));
snprintf(buffer, sizeof(buffer), "@%3.1f@%3.1f@%.1f", 25.8,80.6, 90.1);
printf("publish topic\r\n");
pub_opt.topic = MQTT_PUBLISH_TOPIC;
pub_opt.payload = (unsigned char *)buffer;
pub_opt.payload_len = sizeof(buffer);
if (tos_mqtt_publish(sock_id, &pub_opt) != 0) {
printf("publish failed!!!\n");
}
printf("MQTT count: %d\r\n",count);
printf("read buf\r\n");
read_len = tos_mqtt_receive(topic, sizeof(topic), read_data, sizeof(read_data));
if (read_len >= 0) {
printf("---------->topic: %s, payload: %s, payload_len: %d\n", topic, read_data, read_len);
}
count++;
osDelay(1000);
}
}
void application_entry(void *arg)
{
mqtt_demo();
while (1) {
printf("This is a mqtt demo!\r\n");
tos_task_delay(1000);
}
}

35
examples/tickless/tickless_sample.c Normal file
View File

@@ -0,0 +1,35 @@
#include "cmsis_os.h"
/*
tos_bsp_tickless_setup函数是板级的tickless设置接口
此sample中:
tos_tickless_wkup_alarm_install(TOS_LOW_POWER_MODE_SLEEP, &tickless_wkup_alarm_tim);
tos_tickless_wkup_alarm_init(TOS_LOW_POWER_MODE_SLEEP);
tos_pm_cpu_lpwr_mode_set(TOS_LOW_POWER_MODE_SLEEP);
我们通过tos_tickless_wkup_alarm_install注册了sleep模式下的唤醒闹钟（使用定时器6作为
sleep模式下的唤醒闹钟，具体实现可以参考bsp_tickless_alarm.c）
通过tos_pm_cpu_lpwr_mode_set我们设置tickless模式为sleep模式（如果用户选定tickless
只进入一种模式，那么可以只实现、注册此模式下的唤醒闹钟，其他模式可以不理）
验证：用户可以在idle任务入口knl_idle_entry中加入打印log，在tickless模式下，idle任务
不会一直唤醒，因而idle中的日志打印不会频繁出现（正常模式下idle在系统中没有就绪任务时
就会被唤醒，打印log会频繁出现）
注意：板子烧录tickless使能的镜像后，会导致通过keil烧录新的镜像出现问题（低功耗模式下
debug会有问题）
- 如果是TencentOS tiny定制的开发板，可以在按下板子上的RESET键后立马点击keil上的烧录按钮
- 如果是阿波罗的开发板，可以拔掉板子的串口USB线，脱离stlink（或jlink）的USB口与
PC主机的接触，再重新将stlink（或jlink）的USB插上PC主机后，大概0.5S后再点击keil上的烧录按钮。
*/
void application_entry(void *arg)
{
int count = 1;
while (1) {
printf("###This is task1, %d\r\n", count++);
osDelay(3000);
}
}

96
examples/udp_through_module/udp_through_module.c Normal file
View File

@@ -0,0 +1,96 @@
#include "esp8266.h"
#include "mcu_init.h"
#include "sal_module_wrapper.h"
#include "cmsis_os.h"
#define UDP_TEST_TASK0_STK_SIZE 4096
void udp_test0(void);
osThreadDef(udp_test0, osPriorityNormal, 1, UDP_TEST_TASK0_STK_SIZE);
#define UDP_TEST_TASK1_STK_SIZE 4096
void udp_test1(void);
osThreadDef(udp_test1, osPriorityNormal, 1, UDP_TEST_TASK1_STK_SIZE);
int socket_id_0 = -1;
int socket_id_1 = -1;
#define RECV_LEN 1024
uint8_t recv_data_0[RECV_LEN];
uint8_t recv_data_1[RECV_LEN];
void udp_test0(void)
{
int recv_len = -1;
while (1) {
tos_sal_module_sendto(socket_id_0, "47.107.78.107", "1234",
(const void*)"This is TCP Test!\r\n", strlen("This is UDP Test!\r\n"));
recv_len = tos_sal_module_recvfrom(socket_id_0, recv_data_0, sizeof(recv_data_0));
if (recv_len < 0) {
printf("task0 receive error\n");
} else if (recv_len == 0) {
printf("task0 receive none\n");
} else {
recv_data_0[recv_len] = 0;
printf("task0: receive len: %d\nmsg from remote: %s\n", recv_len, recv_data_0);
}
tos_sleep_ms(2000);
}
}
void udp_test1(void)
{
int recv_len = -1;
while (1) {
tos_sal_module_sendto(socket_id_1, "47.107.78.107", "4321",
(const void *)"Hello Tencent!\r\n", strlen("Hello Tencent!\r\n"));
recv_len = tos_sal_module_recvfrom(socket_id_1, recv_data_1, sizeof(recv_data_1));
if (recv_len < 0) {
printf("task1 receive error\n\r");
} else if (recv_len == 0) {
printf("task1 receive none\n");
} else {
recv_data_1[recv_len] = 0;
printf("task1: receive len: %d\nmsg from remote: %s\n", recv_len, recv_data_1);
}
tos_sleep_ms(2000);
}
}
#define USE_ESP8266
void application_entry(void *arg)
{
#ifdef USE_ESP8266
esp8266_sal_init(HAL_UART_PORT_0);
esp8266_join_ap("SheldonDai", "srnr6x9xbhmb0");
#endif
#ifdef USE_SIM800A
sim800a_power_on();
sim800a_sal_init(HAL_UART_PORT_2);
#endif
socket_id_0 = tos_sal_module_connect("47.107.78.107", "1234", TOS_SAL_PROTO_UDP);
if (socket_id_0 == -1) {
printf("TCP0 connect failed\r\n");
} else {
printf("TCP0 connect success! fd: %d\n", socket_id_0);
}
socket_id_1 = tos_sal_module_connect("47.107.78.107", "4321", TOS_SAL_PROTO_UDP);
if (socket_id_1 == -1) {
printf("TCP1 connect failed\r\n");
} else {
printf("TCP1 connect success! fd: %d\n", socket_id_1);
}
osThreadCreate(osThread(udp_test0), NULL);
osThreadCreate(osThread(udp_test1), NULL);
}