1084 lines
32 KiB
C
1084 lines
32 KiB
C
/****************************************************************************
|
||
|
||
Copyright(c) 2019 by Aerospace C.Power (Chongqing) Microelectronics. ALL RIGHTS RESERVED.
|
||
|
||
This Information is proprietary to Aerospace C.Power (Chongqing) Microelectronics and MAY NOT
|
||
be copied by any method or incorporated into another program without
|
||
the express written consent of Aerospace C.Power. This Information or any portion
|
||
thereof remains the property of Aerospace C.Power. The Information contained herein
|
||
is believed to be accurate and Aerospace C.Power assumes no responsibility or
|
||
liability for its use in any way and conveys no license or title under
|
||
any patent or copyright and makes no representation or warranty that this
|
||
Information is free from patent or copyright infringement.
|
||
|
||
****************************************************************************/
|
||
|
||
#include "os_task_api.h"
|
||
#include "os_event_api.h"
|
||
#include "os_timer_api.h"
|
||
#include "os_utils_api.h"
|
||
#include "os_lock_api.h"
|
||
|
||
#include "iot_task_api.h"
|
||
#include "iot_module_api.h"
|
||
#include "iot_plc_sta_api.h"
|
||
#include "iot_plc_cco_api.h"
|
||
#include "iot_config_api.h"
|
||
#include "iot_app_api.h"
|
||
#include "iot_errno_api.h"
|
||
#include "iot_io_api.h"
|
||
#include "iot_flash_api.h"
|
||
#include "iot_uart_api.h"
|
||
#include "iot_utils_api.h"
|
||
#include "iot_oem_api.h"
|
||
#include "iot_board_api.h"
|
||
#include "iot_gpio_api.h"
|
||
#include "iot_plc_led_api.h"
|
||
#include "iot_app_pib_api.h"
|
||
#include "iot_bitmap_api.h"
|
||
#include "iot_plc_sync_api.h"
|
||
#include "iot_app_meta_api.h"
|
||
|
||
#include "iot_plc_demo.h"
|
||
|
||
#if IOT_PLCUART_APP_ENABLE
|
||
|
||
/* demo app entity */
|
||
static app_dm_entity_t app_demo;
|
||
|
||
/* demo app broadcast mac address for downlink proxy broadcast */
|
||
uint8_t app_demo_bcast_mac[IOT_MAC_ADDR_LEN] = { 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF };
|
||
|
||
uint32_t app_demo_post_msg( uint16_t msg_type, uint16_t msg_id, void *data);
|
||
uint32_t app_demo_post_event(uint32_t event_type);
|
||
uint32_t app_demo_post_msg_cli(void *data);
|
||
void app_demo_tmr_handle(timer_id_t tid, void *data);
|
||
|
||
#if DEMO_APP_DEBUG_EN
|
||
|
||
static char demo_app_log_buf[DEMO_APP_LOG_BUF_LEN] = { 0 };
|
||
|
||
void demo_app_data_print(const char* str, uint8_t* buf, uint16_t len)
|
||
{
|
||
uint32_t offset = 0;
|
||
|
||
offset = iot_sprintf(demo_app_log_buf, "\r\n%s [len:%d]: ", str, len);
|
||
for (uint32_t i = 0; i < len; ++i) {
|
||
offset += iot_sprintf(demo_app_log_buf + offset, "%02X ", buf[i]);
|
||
if (DEMO_APP_LOG_BUF_LEN <= offset + 4) {
|
||
break;
|
||
}
|
||
}
|
||
demo_app_log_buf[offset] = 0;
|
||
iot_cus_printf("%s\r\n", demo_app_log_buf);
|
||
|
||
return;
|
||
}
|
||
|
||
#else /* DEMO_APP_DEBUG_EN */
|
||
|
||
void demo_app_data_print(const char* str, uint8_t* buf, uint16_t len)
|
||
{
|
||
(void)str;
|
||
(void)buf;
|
||
(void)len;
|
||
|
||
return;
|
||
}
|
||
|
||
#endif /* DEMO_APP_DEBUG_EN */
|
||
|
||
#if DEMO_APP_CTRL_LED
|
||
|
||
#define DEMO_LED_LOCK() os_acquire_mutex(app_demo.led.sem_h)
|
||
#define DEMO_LED_UNLOCK() os_release_mutex(app_demo.led.sem_h)
|
||
|
||
/* Set the blinking time of led. */
|
||
static uint32_t inline app_demo_led_set_blink_time(dm_led_t *led, int time)
|
||
{
|
||
DEMO_LED_LOCK();
|
||
|
||
led->blink_time = time;
|
||
|
||
DEMO_LED_UNLOCK();
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
/* Rough control for led. */
|
||
void app_demo_led_ctrl(dm_led_t *led)
|
||
{
|
||
if(led->blink_time) {
|
||
led->cur_perio -= ((led->cur_perio > DEMO_LED_TMR_PERIO)
|
||
? DEMO_LED_TMR_PERIO : led->cur_perio);
|
||
|
||
if(0 == led->cur_perio) {
|
||
led->status = (DEMO_LED_LIGHT_UP_FLAG == led->status)
|
||
? DEMO_LED_LIGHT_DOWN_FLAG : DEMO_LED_LIGHT_UP_FLAG;
|
||
|
||
iot_gpio_value_set(((int)led->pin) & 0xFFFF, led->status);
|
||
|
||
led->cur_perio = led->load_perio;
|
||
|
||
if(DEMO_LED_TM_FOREVER != led->blink_time) {
|
||
led->blink_time -= ((led->blink_time > led->load_perio)
|
||
? led->load_perio : led->blink_time);
|
||
}
|
||
}
|
||
} else if(DEMO_LED_LIGHT_UP_FLAG == led->status) {
|
||
led->status = DEMO_LED_LIGHT_DOWN_FLAG;
|
||
|
||
iot_gpio_value_set(((int)led->pin) & 0xFFFF, led->status);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
/* use app control led */
|
||
static void app_demo_led_blink(void)
|
||
{
|
||
dm_led_t *led = NULL;
|
||
|
||
DEMO_LED_LOCK();
|
||
|
||
led = &(app_demo.led.rx);
|
||
app_demo_led_ctrl(led);
|
||
|
||
led = &(app_demo.led.tx);
|
||
app_demo_led_ctrl(led);
|
||
|
||
DEMO_LED_UNLOCK();
|
||
|
||
return;
|
||
}
|
||
|
||
/* Initialize led. */
|
||
uint32_t app_demo_led_init(void)
|
||
{
|
||
dm_led_t *led = NULL;
|
||
|
||
led = &(app_demo.led.rx);
|
||
|
||
/* Configure rx led. */
|
||
led->load_perio = DEMO_LED_BLINK_RX_TM;
|
||
led->cur_perio = 0;
|
||
led->pin = iot_board_get_gpio(GPIO_RX_LED);
|
||
led->status = DEMO_LED_LIGHT_UP_FLAG;
|
||
led->blink_time = 0;
|
||
|
||
if((ERR_OK != iot_gpio_open_as_output(led->pin))
|
||
||(ERR_OK != iot_gpio_set_pull_mode(led->pin, GPIO_PULL_UP))) {
|
||
DEMO_ERROR("OPEN GPIO#%d FAILED !!", led->pin, 2,3,4,5,6);
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
/* Configure tx led. */
|
||
led = &(app_demo.led.tx);
|
||
led->load_perio = DEMO_LED_BLINK_TX_TM;
|
||
led->cur_perio = 0;
|
||
led->pin = iot_board_get_gpio(GPIO_TX_LED);
|
||
led->status = DEMO_LED_LIGHT_UP_FLAG;
|
||
led->blink_time = 0;
|
||
|
||
if((ERR_OK != iot_gpio_open_as_output(led->pin))
|
||
||(ERR_OK != iot_gpio_set_pull_mode(led->pin, GPIO_PULL_UP))) {
|
||
DEMO_ERROR("OPEN GPIO#%d FAILED !!", led->pin, 2,3,4,5,6);
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
/* Create led mutex */
|
||
if(NULL == (app_demo.led.sem_h = os_create_mutex(IOT_APP_DEMO_MID))) {
|
||
DEMO_ERROR("CREATE SEMAPHORE FAILED !!", 1, 2,3,4,5,6);
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
/* Tx led is always blinking. */
|
||
if(ERR_OK != app_demo_led_set_blink_time
|
||
(&(app_demo.led.tx), DEMO_LED_TX_CONTINUE_TM)) {
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
/* Create a timer for repeatedly works. */
|
||
if((timer_id_t)NULL == (app_demo.led.tmr_id = os_create_timer
|
||
(IOT_APP_DEMO_MID, 1, (os_timer_func_t)app_demo_tmr_handle,
|
||
(void *)DEMO_LED_TMR_PERIO))) {
|
||
DEMO_ERROR("CREATE TMR FAILED !!", 1, 2,3,4,5,6);
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
/* Start the timer. */
|
||
os_start_timer(app_demo.led.tmr_id, DEMO_LED_TMR_PERIO);
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
#endif /* DEMO_APP_CTRL_LED */
|
||
|
||
/* Set carrier communication frequency band. */
|
||
uint32_t app_demo_set_band(uint8_t band_id)
|
||
{
|
||
DEMO_INFO("SET BAND TO BAND %d", band_id, 2,3,4,5,6);
|
||
iot_plc_set_freq_band(app_demo.app_hdl, IOT_PLC_API_REQ_ID_DEFAULT, band_id);
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
/* plc set band bitmap */
|
||
void app_demo_set_sta_scan_band(uint8_t band_id)
|
||
{
|
||
uint8_t fb_bitmap[IOT_PLC_BAND_BITMAP_SIZE] = { 0 };
|
||
|
||
DEMO_INFO("SET SCAN BAND TO BAND %d", band_id, 2,3,4,5,6);
|
||
fb_bitmap[band_id / 8] |= 1 << (band_id % 8);
|
||
iot_plc_set_scan_band_bitmap(app_demo.app_hdl,
|
||
IOT_PLC_API_REQ_ID_DEFAULT, fb_bitmap, IOT_PLC_BAND_BITMAP_SIZE);
|
||
|
||
return;
|
||
}
|
||
|
||
/* Get the OS running time. */
|
||
uint32_t app_demo_get_runing_time(void)
|
||
{
|
||
int fd;
|
||
uint32_t tick;
|
||
|
||
if(-1 == (fd = custom_dev_open())) {
|
||
DEMO_ERROR("OPEN CUSTOMER FLASH FAILED !!", 1, 2,3,4,5,6);
|
||
return 0;
|
||
}
|
||
|
||
if(-1 == custom_dev_read(fd, &tick, sizeof(tick))) {
|
||
DEMO_ERROR("READ CUSTOMER FLASH FAILED !!", 1, 2,3,4,5,6);
|
||
tick = 0;
|
||
}
|
||
|
||
(void)custom_dev_close(fd);
|
||
|
||
return tick;
|
||
}
|
||
|
||
/* post the data from uart port to the message queue. */
|
||
uint32_t app_demo_uart_recv(uint8_t* buffer, uint32_t buffer_len,
|
||
bool_t is_full_frame, uint32_t invalid_data_len)
|
||
{
|
||
iot_pkt_t *pkt;
|
||
|
||
demo_app_data_print("uart recv", buffer, buffer_len);
|
||
|
||
/* Apply for a pkt to store the data received by the serial port.
|
||
Note: If you use the pak applied by iot_pkt_alloc,
|
||
the last user will be responsible for free. */
|
||
if(NULL == (pkt = iot_pkt_alloc(buffer_len, IOT_APP_DEMO_MID))) {
|
||
DEMO_ERROR("PACKET ALLOC FAILED !!", 1,2,3,4,5,6);
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
/* Put serial port data into pak. */
|
||
os_mem_cpy(iot_pkt_put(pkt, buffer_len), buffer, buffer_len);
|
||
|
||
/* Publish data from uart port to message queue. */
|
||
if(ERR_OK != app_demo_post_msg
|
||
(E_DEMO_MSG_PROCESS, E_CMD_ID_RCV_FROM_UART, (void*)pkt)) {
|
||
DEMO_ERROR("POST MSG FAILED !!", 1,2,3,4,5,6);
|
||
/* Failed to publish to message queue, release pkt. */
|
||
iot_pkt_free(pkt);
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
/* Initialize serial port. */
|
||
uint32_t app_demo_uart_init(void)
|
||
{
|
||
uint8_t port;
|
||
uint8_t port_name = UART_CUS_PORT_0;
|
||
|
||
/* Get uart port for tranceiving data, not for printf() used. */
|
||
if((port = iot_board_get_uart(port_name)) >= iot_uart_get_max_port_num()) {
|
||
DEMO_ERROR("INVALID UART %d !!", port, 2,3,4,5,6);
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
if(NULL == (app_demo.cmd_uart = iot_uart_open
|
||
(port, (iot_uart_recv_func_t)app_demo_uart_recv,
|
||
DEMO_UART_RCV_BUF_LEN, NULL))) {
|
||
DEMO_ERROR("OPEN UART #%d FAILED !!", port, 2,3,4,5,6);
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
iot_uart_set_config(app_demo.cmd_uart, IOT_UART_BANDRATE_DEFAULT,
|
||
IOT_UART_PARITY_NONE, IOT_UART_DLEN_8_BITS, IOT_UART_STOP_1_BITS);
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
/* Post the packet from plc-layer to message queue. */
|
||
void app_demo_plc_rcv(void *param, iot_pkt_t *pkt)
|
||
{
|
||
(void)param;
|
||
|
||
if (false == sync_api_msg_from_mac_handle(pkt)) {
|
||
app_demo_post_msg(E_DEMO_MSG_FROM_MAC, E_CMD_ID_RCV_FROM_PLC, (void*)pkt);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
/* Complex logic will not be handled in the timer-handle.So,just post out. */
|
||
void app_demo_tmr_handle(timer_id_t tid, void *data)
|
||
{
|
||
(void)tid;
|
||
(void)data;
|
||
|
||
app_demo_post_event(E_EVENT_TIMR);
|
||
|
||
return;
|
||
}
|
||
|
||
/* Register an APP to PLC-layer,so we can transmit/receive packet from it. */
|
||
uint32_t app_demo_app_reg_init(void)
|
||
{
|
||
iot_plc_app_t app;
|
||
|
||
app.app_id = IOT_PLC_APP_DEMO_ID;
|
||
app.param = NULL;
|
||
app.prio = DEMO_PLC_CMD_PRIO;
|
||
app.recv = app_demo_plc_rcv;
|
||
|
||
app_demo.app_hdl = iot_plc_register_app(&app);
|
||
|
||
if(NULL == app_demo.app_hdl) {
|
||
DEMO_ERROR("REGISTER APP FAILED !!", 1, 2,3,4,5,6);
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
iot_sync_api_init_app_hdl(app_demo.app_hdl, IOT_APP_DEMO_MID, app_demo_post_msg_cli);
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
uint8_t app_demo_send_plc_data(uint8_t *data, uint16_t len, uint8_t is_connless)
|
||
{
|
||
iot_pkt_t *msdu_pkt = NULL;
|
||
uint8_t *ptr;
|
||
uint16_t msdu_len;
|
||
uint16_t meta_len = 0;
|
||
//iot_plc_msdu_send_t *msdu;
|
||
|
||
if (data == NULL || len == 0) {
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
msdu_len = iot_plc_calc_msdu_len_with_pad_info(len, is_connless,
|
||
&meta_len);
|
||
|
||
DEMO_INFO("%s: len %d, msdu_len %d, meta_len %d",
|
||
__FUNCTION__, len, msdu_len, meta_len, 5,6);
|
||
|
||
if (is_connless) {
|
||
msdu_pkt = iot_plc_alloc_conn_less_msdu(app_demo.app_hdl,
|
||
IOT_PLC_MSG_TYPE_CONN_LESS_DATA,
|
||
app_demo_bcast_mac,
|
||
app_demo.dev.mac_addr,
|
||
app_demo.dev.link_id, msdu_len, DEMO_APP_CONNLESS_RETRY_CNT);
|
||
} else {
|
||
msdu_pkt = iot_plc_alloc_msdu(app_demo.app_hdl,
|
||
IOT_PLC_MSG_TYPE_UNICAST, IOT_PLC_ACK_TYPE_NONE,
|
||
app_demo.dev.rmt_addr,
|
||
app_demo.dev.mac_addr,
|
||
app_demo.dev.link_id, msdu_len, 0);
|
||
}
|
||
|
||
if (NULL == msdu_pkt) {
|
||
DEMO_ERROR("ALLOC PACKET FAILED !!", 1,2,3,4,5,6);
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
ptr = iot_pkt_block_ptr(msdu_pkt, IOT_PKT_BLOCK_TAIL);
|
||
|
||
os_mem_cpy(ptr, data, len);
|
||
|
||
iot_pkt_put(msdu_pkt, len);
|
||
|
||
iot_plc_add_meta_info(msdu_pkt, meta_len);
|
||
|
||
DEMO_INFO("BINARY DATA FORWORD TO PLC:",1,2,3,4,5,6);
|
||
|
||
demo_app_data_print("plc send", iot_pkt_data(msdu_pkt), iot_pkt_data_len(msdu_pkt));
|
||
|
||
/* Forword to PLC. */
|
||
iot_plc_send_msdu(app_demo.app_hdl, msdu_pkt);
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
/* This is the handle for messages from this module. */
|
||
void app_demo_msg_process_handle(uint16_t id, void *data)
|
||
{
|
||
iot_pkt_t *pkt = (iot_pkt_t*)data;
|
||
|
||
if(NULL == pkt) {
|
||
DEMO_ERROR("COMMOND HANDLE A 'NULL' PKT !!", 1, 2,3,4,5,6);
|
||
return;
|
||
}
|
||
|
||
//iot_cus_printf("\n%s: id = %d\n", __FUNCTION__, id);
|
||
DEMO_INFO("%s: id = %d", __FUNCTION__, id,3,4,5,6);
|
||
|
||
if(E_CMD_ID_RCV_FROM_PLC == id) {
|
||
iot_plc_msdu_recv_t *msdu;
|
||
iot_pkt_t *uart_pkt;
|
||
|
||
msdu = (iot_plc_msdu_recv_t*)
|
||
(iot_pkt_data(pkt) + sizeof(iot_plc_msg_header_t));
|
||
|
||
#if DEMO_APP_CTRL_LED
|
||
/* Blink RX-led. */
|
||
app_demo_led_set_blink_time (&(app_demo.led.rx), DEMO_LED_RX_CONTINUE_TM);
|
||
#endif /* DEMO_APP_CTRL_LED */
|
||
|
||
if(NULL == (uart_pkt = iot_pkt_alloc(msdu->len, IOT_APP_DEMO_MID))) {
|
||
DEMO_ERROR("PACKET ALLOC FAILED !!", 1,2,3,4,5,6);
|
||
iot_pkt_free(pkt);
|
||
return;
|
||
}
|
||
|
||
os_mem_cpy(iot_pkt_put(uart_pkt, msdu->len), msdu->data, msdu->len);
|
||
|
||
iot_pkt_free(pkt);
|
||
|
||
DEMO_INFO("BINARY DATA FORWORD TO UART:",1,2,3,4,5,6);
|
||
|
||
//app_demo_main_bin_dmp(iot_pkt_data(uart_pkt), iot_pkt_data_len(uart_pkt));
|
||
demo_app_data_print("plc recv", iot_pkt_data(uart_pkt), iot_pkt_data_len(uart_pkt));
|
||
|
||
/* Forword to uart port. */
|
||
iot_uart_send(app_demo.cmd_uart, uart_pkt, NULL);
|
||
} else if (E_CMD_ID_RCV_FROM_CLI == id) {
|
||
iot_app_handle_cli_msg(pkt);
|
||
} else if(E_CMD_ID_RCV_FROM_UART == id) {
|
||
if ((!app_demo.dev.rmt_valid) || (!app_demo.dev.dev_ready)) {
|
||
DEMO_INFO("REMOTE IS NOT READY, UART DATA DROPPED !!", 1,2,3,4,5,6);
|
||
iot_pkt_free(pkt);
|
||
return;
|
||
}
|
||
|
||
app_demo_send_plc_data(iot_pkt_data(pkt), iot_pkt_data_len(pkt), 0);
|
||
|
||
iot_pkt_free(pkt);
|
||
} else {
|
||
iot_pkt_free(pkt);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
/* As all message data is a packet, so just free() it. */
|
||
void app_demo_msg_common_cancel(uint16_t id, void *data)
|
||
{
|
||
iot_pkt_t *pkt = (iot_pkt_t*)data;
|
||
|
||
if(pkt) {
|
||
iot_pkt_free(pkt);
|
||
}
|
||
|
||
(void)id;
|
||
|
||
return;
|
||
}
|
||
|
||
/* Post messages for MSG queue. */
|
||
uint32_t app_demo_post_msg( uint16_t msg_type, uint16_t msg_id, void *data)
|
||
{
|
||
iot_task_msg_t *msg;
|
||
dm_msg_t *task_msg;
|
||
|
||
msg = iot_task_alloc_msg_with_reserved(app_demo.msg_task.handle, 0);
|
||
|
||
if (NULL == msg) {
|
||
DEMO_ERROR("ALLOC MSG-BUFFER FAILED !!", 1, 2,3,4,5,6);
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
task_msg = (dm_msg_t*)msg;
|
||
|
||
task_msg->msg.type = msg_type;
|
||
task_msg->msg.id = msg_id;
|
||
task_msg->data = data;
|
||
|
||
iot_task_queue_msg(app_demo.msg_task.handle,
|
||
&task_msg->msg, DEMO_TASK_MSG_PRIO);
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
uint32_t app_demo_post_msg_cli(void *data)
|
||
{
|
||
return app_demo_post_msg(E_DEMO_MSG_PROCESS, E_CMD_ID_RCV_FROM_CLI, data);
|
||
}
|
||
|
||
/* If we donot need that kind of pending message anymore, just clean it. */
|
||
void app_demo_clean_msg(uint16_t msg_type, uint16_t msg_id)
|
||
{
|
||
DEMO_INFO("CLEAR MSG TYPE %d, ID %d.", msg_type, msg_id,3,4,5,6);
|
||
iot_task_clean_msg(app_demo.msg_task.handle, msg_type, msg_id);
|
||
|
||
return;
|
||
}
|
||
|
||
/* This posts the event to the task. */
|
||
uint32_t app_demo_post_event(uint32_t event_type)
|
||
{
|
||
if(!DEMO_EVENT_VALID(event_type)) {
|
||
DEMO_ERROR("POST AN INVALID EVENT TYPE#%d !!", event_type,2,3,4,5,6);
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
os_set_task_event_with_v
|
||
(iot_task_get_os_task_h(app_demo.msg_task.handle), EVENT_BIT(event_type));
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
void app_demo_msg_from_mac_handle(iot_pkt_t *pkt)
|
||
{
|
||
iot_plc_msg_header_t *hdr =
|
||
(iot_plc_msg_header_t*)iot_pkt_data(pkt);
|
||
|
||
/* Check if this packet belongs to me. */
|
||
if ((IOT_PLC_APP_ID_BCAST != hdr->app_id) &&
|
||
(IOT_PLC_APP_DEMO_ID != hdr->app_id)) {
|
||
DEMO_ERROR("INVALID PACKET FROM MAC,APP ID#%d.", hdr->app_id,2,3,4,5,6);
|
||
iot_pkt_free(pkt);
|
||
return;
|
||
}
|
||
|
||
/* Check if I'm registerd before handling msg. */
|
||
if ((!app_demo.app_reg) &&
|
||
(IOT_PLC_MSG_APP_REG_CONF != hdr->msg_id)) {
|
||
DEMO_ERROR("INVALID PACKET FROM MAC,MSG ID#%d.", hdr->msg_id,2,3,4,5,6);
|
||
iot_pkt_free(pkt);
|
||
return;
|
||
}
|
||
|
||
switch (hdr->msg_id)
|
||
{
|
||
case IOT_PLC_MSG_APP_REG_CONF :
|
||
{
|
||
iot_plc_app_reg_conf_t* rpt = (iot_plc_app_reg_conf_t*)(hdr + 1);
|
||
|
||
if ((IOT_PLC_SUCCESS == rpt->result) ||
|
||
(IOT_PLC_SUCCESS_MODIFIED == rpt->result)) {
|
||
app_demo.app_reg = true;
|
||
DEMO_INFO("APP REGISTERED SUCCESSFULLY.",1,2,3,4,5,6);
|
||
if (MODULE_TYPE_STA_TEST == app_demo.dev.dev_type) {
|
||
iot_plc_cfg_set_req_t cfg;
|
||
os_mem_set(&cfg, 0, sizeof(cfg));
|
||
cfg.dev_type_valid = 1;
|
||
cfg.dev_type = IOT_PLC_DEV_TYPE_REPEATER;
|
||
cfg.reset = 1;
|
||
iot_plc_set_cfg(app_demo.app_hdl, IOT_PLC_API_REQ_ID_DEFAULT, &cfg);
|
||
}
|
||
}
|
||
|
||
break;
|
||
}
|
||
case IOT_PLC_MSG_DEV_STATE_CHANGE_RPT :
|
||
{
|
||
iot_plc_dev_state_change_rpt_t* rpt =
|
||
(iot_plc_dev_state_change_rpt_t*)(hdr + 1);
|
||
|
||
if(rpt->is_ready) {
|
||
DEMO_INFO("STATE CHANGE REPORT MAC GET READY, MY ROLE TYPE#%d.",
|
||
rpt->dev_role,2,3,4,5,6);
|
||
|
||
DEMO_INFO("CCO MAC : %02x-%02x-%02x-%02x-%02x-%02x.",
|
||
rpt->cco_mac[0], rpt->cco_mac[1], rpt->cco_mac[2],
|
||
rpt->cco_mac[3], rpt->cco_mac[4], rpt->cco_mac[5]);
|
||
|
||
DEMO_INFO("LOCAL MAC : %02x-%02x-%02x-%02x-%02x-%02x.",
|
||
rpt->local_mac[0], rpt->local_mac[1], rpt->local_mac[2],
|
||
rpt->local_mac[3], rpt->local_mac[4], rpt->local_mac[5]);
|
||
|
||
if(IOT_PLC_DEV_ROLE_STA == rpt->dev_role) {
|
||
iot_mac_addr_cpy(app_demo.dev.rmt_addr, rpt->cco_mac);
|
||
app_demo.dev.rmt_valid = true;
|
||
}
|
||
|
||
app_demo.dev.dev_ready = true;
|
||
app_demo.dev.dev_role = rpt->dev_role;
|
||
app_demo.dev.nid = rpt->nid;
|
||
|
||
iot_mac_addr_cpy(app_demo.dev.mac_addr, rpt->local_mac);
|
||
iot_mac_addr_cpy(app_demo.dev.cco_addr, rpt->cco_mac);
|
||
} else {
|
||
DEMO_INFO("MAC IS NOT READY.",1,2,3,4,5,6);
|
||
app_demo.dev.dev_ready = false;
|
||
}
|
||
break;
|
||
}
|
||
case IOT_PLC_MSG_DEV_INFO_RPT :
|
||
{
|
||
iot_plc_dev_info_rpt_t* rpt =
|
||
(iot_plc_dev_info_rpt_t*)(hdr + 1);
|
||
if(rpt->is_ready) {
|
||
DEMO_INFO("DEVICE INFO REPORT MAC GET READY, MY ROLE TYPE#%d.",
|
||
rpt->dev_role,2,3,4,5,6);
|
||
|
||
DEMO_INFO("CCO MAC : %02x-%02x-%02x-%02x-%02x-%02x.",
|
||
rpt->cco_mac[0], rpt->cco_mac[1], rpt->cco_mac[2],
|
||
rpt->cco_mac[3], rpt->cco_mac[4], rpt->cco_mac[5]);
|
||
|
||
DEMO_INFO("LOCAL MAC : %02x-%02x-%02x-%02x-%02x-%02x.",
|
||
rpt->local_mac[0], rpt->local_mac[1], rpt->local_mac[2],
|
||
rpt->local_mac[3], rpt->local_mac[4], rpt->local_mac[5]);
|
||
|
||
app_demo.dev.dev_ready = true;
|
||
app_demo.dev.dev_role = rpt->dev_role;
|
||
|
||
if(IOT_PLC_DEV_ROLE_STA == rpt->dev_role) {
|
||
iot_mac_addr_cpy(app_demo.dev.rmt_addr, rpt->cco_mac);
|
||
app_demo.dev.rmt_valid = true;
|
||
}
|
||
|
||
iot_mac_addr_cpy(app_demo.dev.mac_addr, rpt->local_mac);
|
||
iot_mac_addr_cpy(app_demo.dev.cco_addr, rpt->cco_mac);
|
||
} else {
|
||
DEMO_INFO("MAC IS NOT READY.",1,2,3,4,5,6);
|
||
app_demo.dev.dev_ready = false;
|
||
}
|
||
break;
|
||
}
|
||
case IOT_PLC_MSG_STA_JOIN_INFO :
|
||
{
|
||
int16_t addr_index;
|
||
iot_plc_sta_join_info_t* rpt = (iot_plc_sta_join_info_t*)(hdr + 1);
|
||
|
||
DEMO_INFO("STA JOINED : MAC#%02x-%02x-%02x-%02x-%02x-%02x.",
|
||
rpt->sta_info.addr[0], rpt->sta_info.addr[1],
|
||
rpt->sta_info.addr[2], rpt->sta_info.addr[3],
|
||
rpt->sta_info.addr[4], rpt->sta_info.addr[5]);
|
||
|
||
if (IOT_PLC_DEV_ROLE_CCO == app_demo.dev.dev_role) {
|
||
/* Keep the remote device as the last one we got. */
|
||
iot_mac_addr_cpy(app_demo.dev.rmt_addr, rpt->sta_info.addr);
|
||
app_demo.dev.rmt_valid = true;
|
||
|
||
addr_index = iot_app_get_addrs_index_in_wl(rpt->sta_info.addr);
|
||
|
||
if (addr_index >= 0) {
|
||
iot_bitmap_set(app_demo.addr_bitmap, DEMO_APP_BIT_MAP_SIZE,
|
||
(uint16_t)addr_index);
|
||
}
|
||
if (0xFFFF != app_demo.periods_count) {
|
||
if (app_demo.periods_count >= DEMO_APP_MED_ASSOC_PERIODS/2) {
|
||
app_demo.assoc_timeout_period = DEMO_APP_MAX_ASSOC_PERIODS;
|
||
} else if (app_demo.periods_count
|
||
>= DEMO_APP_MIN_ASSOC_PERIODS/2) {
|
||
app_demo.assoc_timeout_period = DEMO_APP_MED_ASSOC_PERIODS;
|
||
}
|
||
}
|
||
|
||
app_demo.periods_count = 0;
|
||
}
|
||
|
||
break;
|
||
}
|
||
case IOT_PLC_MSG_STA_LEAVE_INFO :
|
||
{
|
||
uint32_t cnt;
|
||
int16_t addr_index;
|
||
iot_plc_sta_leave_info_t* rpt = (iot_plc_sta_leave_info_t*)(hdr + 1);
|
||
|
||
for(cnt = 0; cnt < rpt->sta_count; cnt++) {
|
||
DEMO_INFO("STA LEAVED : MAC %02x-%02x-%02x-%02x-%02x-%02x.",
|
||
rpt->sta[cnt].mac_addr[0], rpt->sta[cnt].mac_addr[1],
|
||
rpt->sta[cnt].mac_addr[2], rpt->sta[cnt].mac_addr[3],
|
||
rpt->sta[cnt].mac_addr[4], rpt->sta[cnt].mac_addr[5]);
|
||
|
||
if ((IOT_PLC_DEV_ROLE_STA == app_demo.dev.dev_role)
|
||
&&(iot_mac_addr_cmp
|
||
(app_demo.dev.rmt_addr, rpt->sta[cnt].mac_addr))) {
|
||
app_demo.dev.rmt_valid = false;
|
||
} else if (IOT_PLC_DEV_ROLE_CCO == app_demo.dev.dev_role) {
|
||
addr_index = iot_app_get_addrs_index_in_wl
|
||
(rpt->sta[cnt].mac_addr);
|
||
|
||
if (addr_index >= 0) {
|
||
iot_bitmap_clear(app_demo.addr_bitmap,
|
||
DEMO_APP_BIT_MAP_SIZE, (uint16_t)addr_index);
|
||
}
|
||
}
|
||
}
|
||
|
||
break;
|
||
}
|
||
case IOT_PLC_MSG_MSDU_RECV :
|
||
{
|
||
iot_plc_msdu_recv_t *msdu = (iot_plc_msdu_recv_t*)(hdr + 1);
|
||
|
||
DEMO_INFO("MSDU RECEIVED FROM MAC %02x-%02x-%02x-%02x-%02x-%02x.",
|
||
msdu->src[0], msdu->src[1], msdu->src[2],
|
||
msdu->src[3], msdu->src[4], msdu->src[5]);
|
||
iot_check_meta_data(pkt);
|
||
#if PLC_SUPPORT_STA_ROLE
|
||
iot_meta_rcd_app_msdu_info(msdu, 1);
|
||
#endif
|
||
if(!app_demo.dev.dev_ready) {
|
||
DEMO_INFO("DEVICE NOT READY.PACKET DROPPED.", 1,2,3,4,5,6);
|
||
break;
|
||
}
|
||
|
||
app_demo_post_msg
|
||
(E_DEMO_MSG_PROCESS, E_CMD_ID_RCV_FROM_PLC, (void*)pkt);
|
||
/* Packet will not be freed here. */
|
||
pkt = NULL;
|
||
}
|
||
default :
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(pkt) {
|
||
iot_pkt_free(pkt);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
/* CCO timing trigger check STA connection status. */
|
||
void app_demo_assoc_check_tmr_handle(timer_id_t tid, void *data)
|
||
{
|
||
(void)tid;
|
||
(void)data;
|
||
|
||
app_demo_post_msg(E_DEMO_MSG_TIMER, E_CMD_ID_TMR_ASSOC_CHECK, NULL);
|
||
|
||
return;
|
||
}
|
||
|
||
/* Connection status check function. */
|
||
void app_demo_assoc_check_func(void)
|
||
{
|
||
uint16_t joined_cnt, wl_total_cnt;
|
||
|
||
if (1 == iot_plc_cco_get_whiltlist_state_func()) {
|
||
wl_total_cnt = iot_app_get_wl_cnt();
|
||
joined_cnt = iot_bitmap_cbs(app_demo.addr_bitmap, DEMO_APP_BIT_MAP_SIZE);
|
||
|
||
if (wl_total_cnt == joined_cnt && 0 != wl_total_cnt) {
|
||
if (!app_demo.assoc_done) {
|
||
app_demo.assoc_done = 1;
|
||
iot_plc_led_request(IOT_PLC_LED_ASSOCIATED);
|
||
}
|
||
} else {
|
||
if (app_demo.assoc_done) {
|
||
app_demo.assoc_done = 0;
|
||
iot_plc_led_request(IOT_PLC_LED_DIS_ASSOCIATED);
|
||
}
|
||
}
|
||
} else {
|
||
if (app_demo.periods_count < 0xFFFF) {
|
||
if (app_demo.periods_count < app_demo.assoc_timeout_period) {
|
||
app_demo.periods_count++;
|
||
if (app_demo.assoc_done) {
|
||
app_demo.assoc_done = 0;
|
||
iot_plc_led_request(IOT_PLC_LED_DIS_ASSOCIATED);
|
||
}
|
||
} else {
|
||
app_demo.periods_count = 0xFFFF;
|
||
app_demo.assoc_done = 1;
|
||
iot_plc_led_request(IOT_PLC_LED_ASSOCIATED);
|
||
}
|
||
}
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
/* Timed task processing function. */
|
||
void app_demo_msg_timer_handle(dm_msg_t *dm_msg)
|
||
{
|
||
switch (dm_msg->msg.id) {
|
||
case E_CMD_ID_TMR_ASSOC_CHECK:
|
||
{
|
||
app_demo_assoc_check_func();
|
||
break;
|
||
}
|
||
default:
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
void app_demo_device_query()
|
||
{
|
||
static uint32_t cnt = 1;
|
||
|
||
if((cnt++) % (DEMO_APP_QUERY_TM / DEMO_TMR_PERIO)) {
|
||
return;
|
||
}
|
||
|
||
if((!app_demo.dev.dev_ready)
|
||
|| (IOT_PLC_DEV_ROLE_INVALID != app_demo.dev.dev_role)) {
|
||
return;
|
||
}
|
||
|
||
iot_plc_query_dev_info(app_demo.app_hdl, IOT_PLC_API_REQ_ID_DEFAULT);
|
||
|
||
return;
|
||
}
|
||
|
||
/* Event handler
|
||
* he current DEMO supports the following types of event processing：
|
||
* E_EVENT_TIMR --Event from timer
|
||
*/
|
||
void app_demo_event_handle(iot_task_h task_h, uint32_t event)
|
||
{
|
||
(void)task_h;
|
||
|
||
if(EVENT_BIT(E_EVENT_TIMR) & event) {
|
||
#if DEMO_APP_CTRL_LED
|
||
app_demo_led_blink();
|
||
#endif /* DEMO_APP_CTRL_LED */
|
||
|
||
app_demo_device_query();
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
/* Message processing function.
|
||
* The current DEMO supports the following types of message processing:
|
||
* E_DEMO_MSG_PROCESS --Messages from this module
|
||
* E_DEMO_MSG_FROM_MAC --Messages from outside
|
||
* E_DEMO_MSG_TIMER --Message from timer
|
||
*/
|
||
void app_demo_msg_handle(iot_task_h task_h, iot_task_msg_t *msg)
|
||
{
|
||
dm_msg_t *dm_msg = (dm_msg_t *)msg;
|
||
|
||
(void)task_h;
|
||
|
||
if((NULL == dm_msg) || (!DEMO_MSG_VALID(dm_msg->msg.type))) {
|
||
/* Maybe this can cause memory overflow! */
|
||
DEMO_ERROR("HANDLE AN INVALID MSG !!", 1,2,3,4,5,6);
|
||
return;
|
||
}
|
||
|
||
if(E_DEMO_MSG_PROCESS == dm_msg->msg.type) {
|
||
app_demo_msg_process_handle(dm_msg->msg.id, dm_msg->data);
|
||
} else if(E_DEMO_MSG_FROM_MAC == dm_msg->msg.type) {
|
||
app_demo_msg_from_mac_handle((iot_pkt_t *)dm_msg->data);
|
||
} else if(E_DEMO_MSG_TIMER == dm_msg->msg.type) {
|
||
app_demo_msg_timer_handle(dm_msg);
|
||
}
|
||
|
||
/* need free task message */
|
||
iot_task_free_msg(task_h, &(dm_msg->msg));
|
||
|
||
return;
|
||
}
|
||
|
||
void app_demo_msg_cancel(iot_task_h task_h, iot_task_msg_t *msg)
|
||
{
|
||
dm_msg_t *dm_msg = (dm_msg_t *)msg;
|
||
|
||
(void)task_h;
|
||
|
||
if((NULL == dm_msg) ||(!DEMO_MSG_VALID(dm_msg->msg.type))) {
|
||
/* Maybe this can cause memory overflow! */
|
||
DEMO_ERROR("CANCEL AN INVALID MSG !!", 1,2,3,4,5,6);
|
||
return;
|
||
}
|
||
|
||
if((E_DEMO_MSG_PROCESS == dm_msg->msg.type) ||
|
||
(E_DEMO_MSG_FROM_MAC == dm_msg->msg.type)) {
|
||
app_demo_msg_common_cancel(dm_msg->msg.id, dm_msg->data);
|
||
}
|
||
|
||
iot_task_free_msg(task_h, &(dm_msg->msg));
|
||
|
||
return;
|
||
}
|
||
|
||
/* The initialization function of the message task, which is used to register
|
||
* functions for processing messages and events.
|
||
*/
|
||
uint32_t app_demo_msg_task_init(void)
|
||
{
|
||
dm_msg_task_t *msg_task = &(app_demo.msg_task);
|
||
iot_task_config_t *t_cfg = &(msg_task->cfg);
|
||
|
||
t_cfg->stack_size = 0;
|
||
t_cfg->task_prio = DEMO_MSG_HANDLE_TASK_PRIO;
|
||
t_cfg->msg_size = sizeof(dm_msg_t);
|
||
t_cfg->msg_cnt = DEMO_MSG_PENDING_LIMIT;
|
||
t_cfg->queue_cnt = DEMO_MSG_TASK_PRIO_QUE;
|
||
t_cfg->queue_cfg[0].quota = 0;
|
||
t_cfg->task_event_func = app_demo_event_handle; /* event handler */
|
||
t_cfg->msg_exe_func = app_demo_msg_handle; /* message handler */
|
||
t_cfg->msg_cancel_func = app_demo_msg_cancel;
|
||
msg_task->handle = iot_task_create(IOT_APP_DEMO_MID, t_cfg);
|
||
|
||
if(NULL == msg_task->handle) {
|
||
DEMO_ERROR("iot_task_create RETURNS NULL !!", 1,2,3,4,5,6);
|
||
return ERR_FAIL;
|
||
}
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
/* Report the basic information of this board. */
|
||
uint32_t app_demo_board_info_report(void)
|
||
{
|
||
uint32_t r_time, size;
|
||
iot_oem_base_cfg_t * oem_cfg;
|
||
|
||
size = custom_dev_query_rw_size();
|
||
|
||
(void)iot_oem_get_base_cfg(&oem_cfg);
|
||
|
||
r_time = app_demo_get_runing_time();
|
||
|
||
iot_cus_printf("\r\n************************** INFORMATION ***********************");
|
||
iot_cus_printf("\r\n* This demo-application is designed by Aerospace C.Power");
|
||
iot_cus_printf("\r\n* And it's a guide to show how to use PLC-communication module");
|
||
iot_cus_printf("\r\n* and periphera devices.");
|
||
|
||
iot_cus_printf("\r\n* MAC ADDRS : %02X-%02X-%02X-%02X-%02X-%02X.",
|
||
oem_cfg->module_mac[0], oem_cfg->module_mac[1], oem_cfg->module_mac[2],
|
||
oem_cfg->module_mac[3], oem_cfg->module_mac[4], oem_cfg->module_mac[5]);
|
||
|
||
iot_cus_printf("\r\n* MODULE TYPE : %d ", oem_cfg->module_type);
|
||
iot_cus_printf("\r\n* USER FLASH SIZE : %dbytes.(Size is optional.)", size);
|
||
|
||
iot_cus_printf("\r\n* LAST POWERUP RUNNING TIME : %dH,%dM,%dS.", r_time / 3600,
|
||
(r_time % 3600) / 60, ((r_time % 3600) % 60));
|
||
|
||
iot_cus_printf("\r\n**************************************************************");
|
||
app_demo.dev.dev_type = oem_cfg->module_type;
|
||
|
||
return ERR_OK;
|
||
}
|
||
|
||
/* App initialization, creating task, timer, etc */
|
||
uint32_t app_demo_uart_module_init(void)
|
||
{
|
||
int ret = ERR_FAIL;
|
||
dm_dev_t *dev;
|
||
|
||
os_mem_set(&app_demo, 0x0, sizeof(app_demo));
|
||
|
||
app_demo_board_info_report();
|
||
|
||
DEMO_INFO("MODULE INITIALIZING...", 1,2,3,4,5,6);
|
||
|
||
do
|
||
{
|
||
app_demo.app_hdl = NULL;
|
||
app_demo.app_reg = false;
|
||
|
||
dev = &(app_demo.dev);
|
||
|
||
dev->link_id = DEMO_APP_LINK_ID;
|
||
dev->nid = 1;
|
||
dev->rmt_valid = false;
|
||
dev->dev_role = IOT_PLC_DEV_ROLE_INVALID;
|
||
dev->dev_ready = false;
|
||
|
||
DEMO_INFO(" UART PORT INITIALIZING...", 1,2,3,4,5,6);
|
||
if(ERR_OK != (ret = app_demo_uart_init())) {
|
||
DEMO_ERROR("UART INIT FAILED !!", 1,2,3,4,5,6);
|
||
break;
|
||
}
|
||
DEMO_INFO(" MESSAGE TASK INITIALIZING...", 1,2,3,4,5,6);
|
||
if(ERR_OK != (ret = app_demo_msg_task_init())) {
|
||
DEMO_ERROR("MSG TASK INIT FAILED !!", 1,2,3,4,5,6);
|
||
break;
|
||
}
|
||
DEMO_INFO(" DEMO APP REGISTERING...", 1,2,3,4,5,6);
|
||
if(ERR_OK != (ret = app_demo_app_reg_init())) {
|
||
DEMO_ERROR("APP REGISTER FAILED !!", 1,2,3,4,5,6);
|
||
break;
|
||
}
|
||
|
||
#if DEMO_APP_CTRL_LED
|
||
DEMO_INFO(" LED & TIMER INITIALIZING...", 1,2,3,4,5,6);
|
||
if(ERR_OK != (ret = app_demo_led_init())) {
|
||
DEMO_ERROR("LED INIT FAILED !!", 1,2,3,4,5,6);
|
||
break;
|
||
}
|
||
#endif /* DEMO_APP_CTRL_LED */
|
||
|
||
/* Only the code executed by the client. */
|
||
if (iot_plc_is_client_mode()) {
|
||
/* default set sta only scan band 1, freq: 2.4M to 5.6M */
|
||
app_demo_set_sta_scan_band(PLC_LIB_FREQ_BAND_1);
|
||
|
||
/* close watchdog */
|
||
iot_plc_wdg_set(app_demo.app_hdl, 0, 0);
|
||
}
|
||
|
||
if(ERR_OK !=(ret = app_demo_set_band(PLC_LIB_FREQ_BAND_1))) {
|
||
DEMO_ERROR("SET BAND ID FAILED !!", 1,2,3,4,5,6);
|
||
break;
|
||
}
|
||
|
||
/* code executed by non-client */
|
||
if (!(iot_plc_is_client_mode())) {
|
||
/* Create a timer to check sta associated to network. */
|
||
app_demo.tmr_assoc_check = os_create_timer(IOT_APP_DEMO_MID, 1,
|
||
(os_timer_func_t)app_demo_assoc_check_tmr_handle, NULL);
|
||
if (0 == app_demo.tmr_assoc_check) {
|
||
DEMO_ERROR("CREATE TMR FAILED !!", 1, 2,3,4,5,6);
|
||
return ERR_FAIL;
|
||
}
|
||
os_start_timer(app_demo.tmr_assoc_check,
|
||
DEMO_APP_ASSOC_CHECK_TMR_PERIOD);
|
||
|
||
app_demo.assoc_timeout_period = DEMO_APP_MIN_ASSOC_PERIODS;
|
||
app_demo.periods_count = 0xFFFF;
|
||
app_demo.assoc_done = 0;
|
||
os_mem_set(app_demo.addr_bitmap, 0, DEMO_APP_BIT_MAP_SIZE);
|
||
}
|
||
#if PLC_SUPPORT_STA_ROLE
|
||
/* initialize meta information */
|
||
iot_meta_init(IOT_APP_DEF_3_DEMO, IOT_APP_DEMO_MID);
|
||
#endif
|
||
ret = ERR_OK;
|
||
}while(0);
|
||
|
||
DEMO_INFO("MODULE INITIALIZED %s.",
|
||
(ERR_OK == ret) ? "SUCCESSFULLY" : "WITH ERROR",2,3,4,5,6);
|
||
|
||
return ret;
|
||
}
|
||
|
||
extern void iot_print_config(bool_t enable);
|
||
|
||
uint32_t app_plcuart_entry(void)
|
||
{
|
||
uint32_t ret = ERR_FAIL;
|
||
|
||
/* turn on user printing function. */
|
||
iot_cus_print_config(true);
|
||
|
||
/* turn off iot plc printing function. */
|
||
iot_print_config(false);
|
||
|
||
DEMO_INFO("APP CUS TASK INIT...\n",1,2,3,4,5,6);
|
||
|
||
/* initialize demo module. */
|
||
ret = app_demo_uart_module_init();
|
||
|
||
return ret;
|
||
}
|
||
|
||
#endif /* IOT_PLCUART_APP_ENABLE */
|