2164 lines
64 KiB
C
Executable File
2164 lines
64 KiB
C
Executable File
/****************************************************************************
|
|
|
|
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 "iot_task_api.h"
|
|
#include "iot_module_api.h"
|
|
#include "os_lock_api.h"
|
|
#include "iot_plc_cco_api.h"
|
|
#include "iot_plc_sta_api.h"
|
|
#include "iot_plc_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_adc_api.h"
|
|
#include "iot_eth_api.h"
|
|
#include "iot_plc_led_api.h"
|
|
#include "iot_app_pib_api.h"
|
|
#include "iot_bitmap_api.h"
|
|
|
|
#include "demo.h"
|
|
|
|
#include "iot_plc_sync_api.h"
|
|
#include "demo_function_display.h"
|
|
#include "iot_app_meta_api.h"
|
|
|
|
#if IOT_DEMO_APP_UDP_SERVER_ENABLE || IOT_DEMO_APP_TCP_SERVER_ENABLE
|
|
#include "lwip/udp.h"
|
|
#include "lwip/ip_addr.h"
|
|
#include "lwip/sockets.h"
|
|
#include "lwip/inet.h"
|
|
#include "lwip/tcpip.h"
|
|
|
|
#include "netif/netif_plc.h"
|
|
#endif
|
|
|
|
#if (IOT_DEMO_SUB_FUN == IOT_DEMO_SEL_FUNC_DISPL)
|
|
|
|
#define IOT_ADC_DEMO_ENABLE 0
|
|
|
|
#if IOT_ADC_DEMO_ENABLE
|
|
|
|
typedef struct adc_info_t
|
|
{
|
|
uint8_t power_3v_channel_1;
|
|
uint8_t power_3v_channel_2;
|
|
} adc_info;
|
|
|
|
adc_info *g_adc_info = NULL;
|
|
#endif
|
|
|
|
#define DEMO_LED_TM_FOREVER (-1)
|
|
|
|
#define DEMO_LED_RX_CONTINUE_TM 2000
|
|
#define DEMO_LED_TX_CONTINUE_TM DEMO_LED_TM_FOREVER
|
|
|
|
typedef struct iot_app_demo_msg_task
|
|
{
|
|
iot_task_h handle; /* Task handle. */
|
|
iot_task_config_t cfg; /* Keep the task configuration. */
|
|
}demo_msg_task_h;
|
|
|
|
typedef struct iot_app_demo_msg
|
|
{
|
|
iot_task_msg_t msg; /* The main entity of message. */
|
|
void *data; /* The user data inside this message. */
|
|
}demo_msg_t;
|
|
|
|
typedef struct demo_led_struct
|
|
{
|
|
uint32_t blink_time;
|
|
uint16_t load_perio;
|
|
uint16_t cur_perio;
|
|
uint16_t status;
|
|
uint8_t pin;
|
|
}dm_led_s;
|
|
|
|
typedef struct demo_led_entity
|
|
{
|
|
timer_id_t tmr_id; /* To triger repeatedly works. */
|
|
os_mutex_h sem_h;
|
|
dm_led_s tx; /* Designed to blinking all the time. */
|
|
dm_led_s rx; /* Designed to blinking when there are packets from
|
|
PLC-layer. */
|
|
}dm_led_e;
|
|
|
|
typedef struct demo_device
|
|
{
|
|
uint8_t rmt_valid; /* Indicates if the remote device is ready. */
|
|
uint8_t link_id;
|
|
uint8_t dev_ready; /* Indicates if this local device is ready. */
|
|
uint8_t dev_role; /* This local device role, CCO or STA ... */
|
|
uint32_t dev_type; /* device type */
|
|
uint8_t mac_addr[IOT_MAC_ADDR_LEN];/* MAC of this local device. */
|
|
uint8_t cco_addr[IOT_MAC_ADDR_LEN];/* MAC of CCO in this topo. */
|
|
uint8_t rmt_addr[IOT_MAC_ADDR_LEN];/* MAC of remote device we
|
|
communicate with. */
|
|
uint32_t nid; /* The network ID of this topo. */
|
|
}dm_dev_info;
|
|
|
|
#if IOT_LWIP_SUPPORT && PLC_SUPPORT_STA_ROLE
|
|
#if IOT_DEMO_APP_UDP_SERVER_ENABLE
|
|
typedef struct iot_app_demo_udp_server
|
|
{
|
|
/* ipv4 */
|
|
int32_t sock_id; /* socket id for ipv4 */
|
|
struct sockaddr_in ser_addr; /* local addr for bind */
|
|
struct sockaddr_in src_addr; /* src_addr that udp data comes from */
|
|
socklen_t src_addr_len; /* length of src_addr */
|
|
uint8_t data_buf[DEMO_APP_UDP_DATA_BUF_LEN];
|
|
/* buf used for udp recv */
|
|
os_task_h ipv4_task; /* ipv4 recv task */
|
|
#if LWIP_IPV6
|
|
/* ipv6 */
|
|
int32_t sock_id6; /* socket id for ipv6 */
|
|
struct sockaddr_in6 ser_addr6; /* local addr for bind */
|
|
struct sockaddr_in6 src_addr6; /* src_addr that udp data comes from */
|
|
socklen_t src_addr_len6; /* length of src_addr */
|
|
uint8_t data_buf6[DEMO_APP_UDP6_DATA_BUF_LEN];
|
|
/* buf used for udp recv */
|
|
os_task_h ipv6_task; /* ipv6 recv task */
|
|
#endif
|
|
}dm_udp_server;
|
|
#endif
|
|
|
|
#if IOT_DEMO_APP_TCP_SERVER_ENABLE
|
|
typedef struct iot_app_demo_tcp_server
|
|
{
|
|
/* ipv4 */
|
|
int32_t sock_id; /* socket id for ipv4 */
|
|
int32_t conn_sock_id; /* conn socket id for ipv4 */
|
|
struct sockaddr_in ser_addr; /* local addr for bind */
|
|
struct sockaddr_in src_addr; /* src_addr that tcp data comes from */
|
|
socklen_t src_addr_len; /* length of src_addr */
|
|
uint8_t data_buf[DEMO_APP_TCP_DATA_BUF_LEN];
|
|
/* buf used for tcp recv */
|
|
os_task_h ipv4_task; /* ipv4 recv task */
|
|
#if LWIP_IPV6
|
|
/* ipv6 */
|
|
int32_t sock_id6; /* socket id for ipv6 */
|
|
int32_t conn_sock_id6; /* conn socket id for ipv6 */
|
|
struct sockaddr_in6 ser_addr6; /* local addr for bind */
|
|
struct sockaddr_in6 src_addr6; /* src_addr that tcp data comes from */
|
|
socklen_t src_addr_len6; /* length of src_addr */
|
|
uint8_t data_buf6[DEMO_APP_TCP6_DATA_BUF_LEN];
|
|
/* buf used for tcp recv */
|
|
os_task_h ipv6_task; /* ipv6 recv task */
|
|
#endif /* LWIP_IPV6 */
|
|
}dm_tcp_server;
|
|
|
|
#endif /* IOT_DEMO_APP_TCP_SERVER_ENABLE */
|
|
|
|
#endif /* IOT_LWIP_SUPPORT && PLC_SUPPORT_STA_ROLE */
|
|
|
|
typedef struct iot_app_demo_entity
|
|
{
|
|
iot_uart_h cmd_uart;
|
|
demo_msg_task_h msg_task; /* This task will process all messages and events
|
|
that from this very module. */
|
|
dm_led_e led;
|
|
iot_plc_app_h app_hdl; /* The handle of this DEMO APP. */
|
|
uint32_t app_reg; /* Indicates if this APP has registered
|
|
to PLC-layer. */
|
|
dm_dev_info dev; /* Device information. */
|
|
#if IOT_LWIP_SUPPORT && PLC_SUPPORT_STA_ROLE
|
|
#if IOT_DEMO_APP_UDP_SERVER_ENABLE
|
|
dm_udp_server udp_server; /* udp server info of DEMO APP */
|
|
#endif
|
|
#if IOT_DEMO_APP_TCP_SERVER_ENABLE
|
|
dm_tcp_server tcp_server; /* tcp server info of DEMO APP */
|
|
#endif
|
|
timer_id_t net_t_id; /* timer id for tcp/udp server start-up */
|
|
bool_t netif_ready; /* status indicating netif ready or not */
|
|
#endif
|
|
timer_id_t tmr_print_temp; /* timer id for print of core temperature */
|
|
timer_id_t tmr_assoc_check; /* timer id for associated sta check*/
|
|
uint8_t addr_bitmap[DEMO_APP_BIT_MAP_SIZE];
|
|
/* array used to mark associated sta */
|
|
uint32_t assoc_timeout_period; /* period of associated timeout */
|
|
uint32_t periods_count; /* count for tmr periods */
|
|
uint8_t assoc_done; /* label for all stas associated to network */
|
|
}demo_t;
|
|
|
|
demo_t app_demo;
|
|
|
|
#define DEMO_LED_LOCK() os_acquire_mutex(app_demo.led.sem_h)
|
|
#define DEMO_LED_UNLOCK() os_release_mutex(app_demo.led.sem_h)
|
|
|
|
enum
|
|
{
|
|
E_CMD_ID_START,
|
|
E_CMD_ID_RCV_FROM_PLC,
|
|
E_CMD_ID_RCV_FROM_UART,
|
|
E_CMD_ID_RCV_FROM_ETHERNET,
|
|
E_CMD_ID_RCV_FROM_PLC_CONNLESS,
|
|
E_CMD_ID_RCV_FROM_UDP_SOCKET,
|
|
E_CMD_ID_RCV_FROM_TCP_SOCKET,
|
|
E_CMD_ID_RCV_FROM_CLI,
|
|
E_CMD_ID_UART_TO_UDP4,
|
|
E_CMD_ID_UART_TO_UDP6,
|
|
E_CMD_ID_UART_TO_TCP4,
|
|
E_CMD_ID_UART_TO_TCP6,
|
|
E_CMD_ID_TMR_ASSOC_CHECK,
|
|
E_CMD_ID_END
|
|
};
|
|
|
|
|
|
#ifndef BIT
|
|
#define BIT(n) (1<<(n))
|
|
#endif
|
|
|
|
/* 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);
|
|
|
|
#if (DEMO_APP_DEBUG_EN == 1)
|
|
|
|
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, "%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\n", demo_app_log_buf);
|
|
}
|
|
|
|
#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 IOT_DEMO_APP_ETH_SUPPORT
|
|
|
|
|
|
uint32_t app_demo_eth_send(uint8_t * data, uint32_t len)
|
|
{
|
|
iot_pkt_ls lst;
|
|
iot_cus_printf("\n%s >>>\n", __FUNCTION__);
|
|
|
|
lst.pkt = iot_pkt_alloc(len, 0);
|
|
if (!lst.pkt)
|
|
return ERR_FAIL;
|
|
lst.next = NULL;
|
|
|
|
os_mem_cpy(lst.pkt->head, data, len);
|
|
iot_pkt_set_data(lst.pkt, lst.pkt->head);
|
|
iot_pkt_set_tail(lst.pkt, lst.pkt->data + len);
|
|
|
|
iot_eth_send_packet(&lst);
|
|
return ERR_OK;
|
|
}
|
|
|
|
void app_demo_eth_recv(uint8_t * data, uint32_t len)
|
|
{
|
|
iot_pkt_t *pkt;
|
|
iot_cus_printf("\n%s >>>\n", __FUNCTION__);
|
|
|
|
if(NULL == (pkt = iot_pkt_alloc(len, IOT_APP_DEMO_MID)))
|
|
{
|
|
DEMO_ERROR("PACKET ALLOC FAILED !!", 1,2,3,4,5,6);
|
|
return;
|
|
}
|
|
|
|
os_mem_cpy(iot_pkt_put(pkt, len), data, len);
|
|
|
|
if(ERR_OK != app_demo_post_msg
|
|
(E_DEMO_MSG_PROCESS, E_CMD_ID_RCV_FROM_ETHERNET, (void*)pkt))
|
|
{
|
|
DEMO_ERROR("POST MSG FAILED !!", 1,2,3,4,5,6);
|
|
iot_pkt_free(pkt);
|
|
return;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
uint32_t app_demo_set_local_mac(uint8_t *mac)
|
|
{
|
|
iot_plc_cfg_set_req_t cfg;
|
|
|
|
IOT_ASSERT(mac);
|
|
iot_cus_printf("%s: set_device_mac:"
|
|
"%02x,%02x,%02x,%02x,%02x,%02x\n", __FUNCTION__,
|
|
mac[0],mac[1],mac[2],mac[3],mac[4],mac[5]);
|
|
|
|
os_mem_set(&cfg, 0, sizeof(cfg));
|
|
cfg.addr_valid = 1;
|
|
cfg.addr_type = IOT_PLC_MAC_ADDR_TYPE_METER;
|
|
iot_mac_addr_cpy(cfg.addr, mac);
|
|
cfg.reset = 1;
|
|
cfg.dev_type_valid = 1;
|
|
cfg.dev_type = IOT_PLC_DEV_TYPE_METER_CONTROLLER;
|
|
iot_plc_set_cfg(app_demo.app_hdl, IOT_PLC_API_REQ_ID_DEFAULT, &cfg);
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
#endif /* IOT_DEMO_APP_ETH_SUPPORT */
|
|
|
|
uint32_t app_demo_set_band(uint8_t band_id)
|
|
{
|
|
|
|
iot_cus_printf("%s: set band to band %d\n", __FUNCTION__, band_id);
|
|
|
|
iot_plc_set_freq_band(app_demo.app_hdl,
|
|
IOT_PLC_API_REQ_ID_DEFAULT, band_id);
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
/* set sta scan band */
|
|
void app_demo_set_sta_scan_band(uint8_t band_id)
|
|
{
|
|
iot_cus_printf("%s: set scan band to band %d\n", __FUNCTION__, band_id);
|
|
uint8_t fb_bitmap[IOT_PLC_BAND_BITMAP_SIZE] = { 0 };
|
|
|
|
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);
|
|
}
|
|
|
|
#if IOT_LWIP_SUPPORT && PLC_SUPPORT_STA_ROLE
|
|
#if IOT_DEMO_APP_UDP_SERVER_ENABLE
|
|
|
|
void demo_app_udp2uart_send(uint8_t* buffer, uint32_t buffer_len)
|
|
{
|
|
iot_pkt_t *pkt;
|
|
|
|
if(NULL == (pkt = iot_pkt_alloc(buffer_len, IOT_APP_DEMO_MID)))
|
|
{
|
|
DEMO_ERROR("PACKET ALLOC FAILED !!", 1,2,3,4,5,6);
|
|
return;
|
|
}
|
|
|
|
os_mem_cpy(iot_pkt_put(pkt, buffer_len), buffer, buffer_len);
|
|
|
|
if(ERR_OK != app_demo_post_msg
|
|
(E_DEMO_MSG_PROCESS, E_CMD_ID_RCV_FROM_UDP_SOCKET, (void*)pkt))
|
|
{
|
|
DEMO_ERROR("POST MSG FAILED !!", 1,2,3,4,5,6);
|
|
iot_pkt_free(pkt);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void demo_app_uart2udp_send(const struct sockaddr *to, socklen_t tolen,
|
|
uint8_t* buffer, uint32_t buffer_len)
|
|
{
|
|
sendto(app_demo.udp_server.sock_id, (const void*)buffer, buffer_len, 0,
|
|
to, tolen);
|
|
}
|
|
|
|
void demo_app_socket_udp_server_task(void *arg)
|
|
{
|
|
(void)arg;
|
|
struct sockaddr src_addr;
|
|
socklen_t addr_len;
|
|
int recv_len = 0;
|
|
while (1) {
|
|
recv_len = recvfrom(app_demo.udp_server.sock_id,
|
|
app_demo.udp_server.data_buf, DEMO_APP_UDP_DATA_BUF_LEN, 0,
|
|
&src_addr, (socklen_t *)&addr_len);
|
|
app_demo.udp_server.src_addr_len = addr_len;
|
|
os_mem_cpy((void*)&(app_demo.udp_server.src_addr),
|
|
(void*)&src_addr, addr_len);
|
|
demo_app_data_print("udp src_addr",
|
|
(uint8_t*)&(app_demo.udp_server.src_addr),
|
|
sizeof(app_demo.udp_server.src_addr));
|
|
demo_app_data_print("udp recv", app_demo.udp_server.data_buf, recv_len);
|
|
demo_app_udp2uart_send(app_demo.udp_server.data_buf, recv_len);
|
|
}
|
|
}
|
|
|
|
void app_demo_udp_server_init_ipv4(void)
|
|
{
|
|
app_demo.udp_server.ser_addr.sin_family = AF_INET;
|
|
app_demo.udp_server.ser_addr.sin_port = htons(UDP_SERVER_PORT);
|
|
app_demo.udp_server.ser_addr.sin_addr.s_addr = INADDR_ANY;
|
|
|
|
/* create socket for udp server */
|
|
app_demo.udp_server.sock_id = socket(AF_INET, SOCK_DGRAM, 0);
|
|
if (app_demo.udp_server.sock_id < 0) {
|
|
iot_cus_printf("%s: create socket failed -- %d.\n",
|
|
__FUNCTION__, app_demo.udp_server.sock_id);
|
|
return;
|
|
}
|
|
|
|
/* bind socket */
|
|
if (bind(app_demo.udp_server.sock_id,
|
|
(const struct sockaddr*)&(app_demo.udp_server.ser_addr),
|
|
sizeof(app_demo.udp_server.ser_addr)) < 0) {
|
|
iot_cus_printf("%s: bind server socket failed.\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
|
|
app_demo.udp_server.ipv4_task =
|
|
os_create_task(demo_app_socket_udp_server_task, NULL,
|
|
DEMO_APP_UDP_SERVER_TASK_PRIO);
|
|
if (app_demo.udp_server.ipv4_task == NULL) {
|
|
iot_cus_printf("%s: create udp server task failed.\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
}
|
|
|
|
#if LWIP_IPV6
|
|
void demo_app_uart2udp_send_v6(const struct sockaddr *to,
|
|
socklen_t tolen, uint8_t* buffer, uint32_t buffer_len)
|
|
{
|
|
sendto(app_demo.udp_server.sock_id6, (const void*)buffer,
|
|
buffer_len, 0, to, tolen);
|
|
}
|
|
|
|
void demo_app_socket_udp6_server_task(void *arg)
|
|
{
|
|
(void)arg;
|
|
struct sockaddr src_addr;
|
|
socklen_t addr_len;
|
|
int recv_len = 0;
|
|
while (1) {
|
|
recv_len = recvfrom(app_demo.udp_server.sock_id6,
|
|
app_demo.udp_server.data_buf6, DEMO_APP_UDP6_DATA_BUF_LEN, 0,
|
|
&src_addr, (socklen_t *)&addr_len);
|
|
app_demo.udp_server.src_addr_len6 = addr_len;
|
|
os_mem_cpy((void*)&(app_demo.udp_server.src_addr6),
|
|
(void*)&src_addr, addr_len);
|
|
demo_app_data_print("udp src_addr6",
|
|
(uint8_t*)&(app_demo.udp_server.src_addr6),
|
|
sizeof(app_demo.udp_server.src_addr6));
|
|
demo_app_data_print("udp recv", app_demo.udp_server.data_buf, recv_len);
|
|
demo_app_udp2uart_send(app_demo.udp_server.data_buf6, recv_len);
|
|
}
|
|
}
|
|
|
|
void app_demo_udp_server_init_ipv6(void)
|
|
{
|
|
/* IPV6 */
|
|
app_demo.udp_server.ser_addr6.sin6_family= AF_INET6;
|
|
app_demo.udp_server.ser_addr6.sin6_port = htons(UDP6_SERVER_PORT);
|
|
app_demo.udp_server.ser_addr6.sin6_addr = in6addr_any;
|
|
|
|
/* create socket for udp server */
|
|
app_demo.udp_server.sock_id6 = socket(AF_INET6, SOCK_DGRAM, 0);
|
|
if (app_demo.udp_server.sock_id6 < 0) {
|
|
iot_cus_printf("%s: create socket failed -- %d.\n",
|
|
__FUNCTION__, app_demo.udp_server.sock_id6);
|
|
return;
|
|
}
|
|
|
|
/* bind socket */
|
|
if (bind(app_demo.udp_server.sock_id6,
|
|
(const struct sockaddr*)&(app_demo.udp_server.ser_addr6),
|
|
sizeof(app_demo.udp_server.ser_addr6)) < 0) {
|
|
iot_cus_printf("%s: bind server socket failed.\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
|
|
app_demo.udp_server.ipv6_task =
|
|
os_create_task(demo_app_socket_udp6_server_task,
|
|
NULL, DEMO_APP_UDP_SERVER_TASK_PRIO);
|
|
if (app_demo.udp_server.ipv6_task == NULL) {
|
|
iot_cus_printf("%s: create udp server task failed.\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
}
|
|
#endif /* LWIP_IPV6 */
|
|
|
|
uint32_t app_demo_udp_server_init(void)
|
|
{
|
|
app_demo_udp_server_init_ipv4();
|
|
#if LWIP_IPV6
|
|
app_demo_udp_server_init_ipv6();
|
|
#endif
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
#endif /* IOT_DEMO_APP_UDP_SERVER_ENABLE */
|
|
|
|
#if IOT_DEMO_APP_TCP_SERVER_ENABLE
|
|
|
|
void demo_app_uart2tcp_send( uint8_t* buffer, uint32_t buffer_len)
|
|
{
|
|
send(app_demo.tcp_server.conn_sock_id, (const void*)buffer, buffer_len, 0);
|
|
}
|
|
|
|
void demo_app_tcp2uart_send(uint8_t* buffer, uint32_t buffer_len)
|
|
{
|
|
iot_pkt_t *pkt;
|
|
|
|
if(NULL == (pkt = iot_pkt_alloc(buffer_len, IOT_APP_DEMO_MID)))
|
|
{
|
|
DEMO_ERROR("PACKET ALLOC FAILED !!", 1,2,3,4,5,6);
|
|
return;
|
|
}
|
|
|
|
os_mem_cpy(iot_pkt_put(pkt, buffer_len), buffer, buffer_len);
|
|
|
|
if(ERR_OK != app_demo_post_msg
|
|
(E_DEMO_MSG_PROCESS, E_CMD_ID_RCV_FROM_TCP_SOCKET, (void*)pkt))
|
|
{
|
|
DEMO_ERROR("POST MSG FAILED !!", 1,2,3,4,5,6);
|
|
iot_pkt_free(pkt);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void demo_app_socket_tcp_server_task(void* arg)
|
|
{
|
|
int recv_len = 0;
|
|
struct sockaddr src_addr;
|
|
socklen_t addr_len;
|
|
uint8_t cnt = 0;
|
|
|
|
while (1) {
|
|
/* accept */
|
|
app_demo.tcp_server.conn_sock_id = accept(app_demo.tcp_server.sock_id,
|
|
(struct sockaddr *)&src_addr, &addr_len);
|
|
if (app_demo.tcp_server.conn_sock_id <= 0) {
|
|
iot_cus_printf("%s: accept failed\n", __FUNCTION__);
|
|
continue;
|
|
}
|
|
iot_cus_printf("%s: conn_sock_id = %d, cnt = %d\n", __FUNCTION__,
|
|
app_demo.tcp_server.conn_sock_id, cnt);
|
|
|
|
os_mem_cpy((void*)&(app_demo.tcp_server.src_addr), (void*)&src_addr,
|
|
addr_len);
|
|
app_demo.tcp_server.src_addr_len = addr_len;
|
|
demo_app_data_print("tcp src_addr",
|
|
(uint8_t*)&(app_demo.tcp_server.src_addr),
|
|
sizeof(app_demo.tcp_server.src_addr));
|
|
cnt = 100;
|
|
while (1) {
|
|
recv_len = recv(app_demo.tcp_server.conn_sock_id,
|
|
app_demo.tcp_server.data_buf, DEMO_APP_TCP_DATA_BUF_LEN, 0);
|
|
if (recv_len <= 0) {
|
|
cnt--;
|
|
if (cnt > 100 || cnt == 0){
|
|
closesocket(app_demo.tcp_server.conn_sock_id);
|
|
app_demo.tcp_server.conn_sock_id =
|
|
DEMO_APP_INVALID_TCP_CONN_ID;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
demo_app_data_print("tcp recv", app_demo.tcp_server.data_buf,
|
|
recv_len);
|
|
demo_app_tcp2uart_send(app_demo.tcp_server.data_buf, recv_len);
|
|
}
|
|
}
|
|
}
|
|
|
|
void app_demo_tcp_server_init_ipv4(void)
|
|
{
|
|
app_demo.tcp_server.ser_addr.sin_family = AF_INET;
|
|
app_demo.tcp_server.ser_addr.sin_port = htons(TCP_SERVER_PORT);
|
|
app_demo.tcp_server.ser_addr.sin_addr.s_addr = INADDR_ANY;
|
|
|
|
/* create socket for udp server */
|
|
app_demo.tcp_server.sock_id = socket(AF_INET, SOCK_STREAM, 0);
|
|
if (app_demo.tcp_server.sock_id < 0) {
|
|
iot_cus_printf("%s: create socket failed -- %d.\n",
|
|
__FUNCTION__, app_demo.tcp_server.sock_id);
|
|
return;
|
|
}
|
|
|
|
/* bind socket */
|
|
if (bind(app_demo.tcp_server.sock_id,
|
|
(const struct sockaddr*)&(app_demo.tcp_server.ser_addr),
|
|
sizeof(app_demo.tcp_server.ser_addr)) < 0) {
|
|
iot_cus_printf("%s: bind server socket failed.\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
|
|
/* listen */
|
|
if (listen(app_demo.tcp_server.sock_id, 1) != 0) {
|
|
iot_cus_printf("%s: listen failed\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
|
|
app_demo.tcp_server.ipv4_task =
|
|
os_create_task(demo_app_socket_tcp_server_task,
|
|
NULL, DEMO_APP_TCP_SERVER_TASK_PRIO);
|
|
if (app_demo.tcp_server.ipv4_task == NULL) {
|
|
iot_cus_printf("%s: create tcp server task failed.\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
}
|
|
|
|
#if LWIP_IPV6
|
|
void demo_app_uart2tcp_send_v6( uint8_t* buffer, uint32_t buffer_len)
|
|
{
|
|
send(app_demo.tcp_server.conn_sock_id6, (const void*)buffer, buffer_len, 0);
|
|
}
|
|
|
|
void demo_app_socket_tcp6_server_task(void* arg)
|
|
{
|
|
int recv_len = 0;
|
|
struct sockaddr src_addr;
|
|
socklen_t addr_len;
|
|
uint8_t cnt = 0;
|
|
|
|
while (1) {
|
|
/* accept */
|
|
app_demo.tcp_server.conn_sock_id6 = accept(app_demo.tcp_server.sock_id6,
|
|
(struct sockaddr *)&src_addr, &addr_len);
|
|
if (app_demo.tcp_server.conn_sock_id6 <= 0) {
|
|
iot_cus_printf("%s: accept failed\n", __FUNCTION__);
|
|
continue;
|
|
}
|
|
iot_cus_printf("%s: conn_sock_id = %d, cnt = %d\n", __FUNCTION__,
|
|
app_demo.tcp_server.conn_sock_id6, cnt);
|
|
|
|
os_mem_cpy((void*)&(app_demo.tcp_server.src_addr6), (void*)&src_addr,
|
|
addr_len);
|
|
app_demo.tcp_server.src_addr_len6 = addr_len;
|
|
demo_app_data_print("tcp6 src_addr",
|
|
(uint8_t*)&(app_demo.tcp_server.src_addr6),
|
|
sizeof(app_demo.tcp_server.src_addr6));
|
|
cnt = 100;
|
|
while (1) {
|
|
recv_len = recv(app_demo.tcp_server.conn_sock_id6,
|
|
app_demo.tcp_server.data_buf6, DEMO_APP_TCP6_DATA_BUF_LEN, 0);
|
|
if (recv_len <= 0) {
|
|
cnt--;
|
|
if (cnt > 100 || cnt == 0){
|
|
closesocket(app_demo.tcp_server.conn_sock_id6);
|
|
app_demo.tcp_server.conn_sock_id6 =
|
|
DEMO_APP_INVALID_TCP_CONN_ID;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
demo_app_data_print("tcp6 recv", app_demo.tcp_server.data_buf6,
|
|
recv_len);
|
|
demo_app_tcp2uart_send(app_demo.tcp_server.data_buf6, recv_len);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void app_demo_tcp_server_init_ipv6(void)
|
|
{
|
|
app_demo.tcp_server.ser_addr6.sin6_family= AF_INET6;
|
|
app_demo.tcp_server.ser_addr6.sin6_port = htons(TCP6_SERVER_PORT);
|
|
app_demo.tcp_server.ser_addr6.sin6_addr = in6addr_any;
|
|
|
|
/* create socket for udp server */
|
|
app_demo.tcp_server.sock_id6 = socket(AF_INET6, SOCK_STREAM, 0);
|
|
if (app_demo.tcp_server.sock_id6 < 0) {
|
|
iot_cus_printf("%s: create socket failed -- %d.\n",
|
|
__FUNCTION__, app_demo.tcp_server.sock_id6);
|
|
return;
|
|
}
|
|
|
|
/* bind socket */
|
|
if (bind(app_demo.tcp_server.sock_id6,
|
|
(const struct sockaddr*)&(app_demo.tcp_server.ser_addr6),
|
|
sizeof(app_demo.tcp_server.ser_addr6)) < 0) {
|
|
iot_cus_printf("%s: bind server socket failed.\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
|
|
/* listen */
|
|
if (listen(app_demo.tcp_server.sock_id6, 1) != 0) {
|
|
iot_cus_printf("%s: listen failed\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
|
|
app_demo.tcp_server.ipv6_task =
|
|
os_create_task(demo_app_socket_tcp6_server_task,
|
|
NULL, DEMO_APP_TCP_SERVER_TASK_PRIO);
|
|
if (app_demo.tcp_server.ipv6_task == NULL) {
|
|
iot_cus_printf("%s: create tcp server task failed.\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
}
|
|
|
|
#endif /* LWIP_IPV6 */
|
|
|
|
uint32_t app_demo_tcp_server_init(void)
|
|
{
|
|
app_demo_tcp_server_init_ipv4();
|
|
#if LWIP_IPV6
|
|
app_demo_tcp_server_init_ipv6();
|
|
#endif /* LWIP_IPV6 */
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
#endif /* IOT_DEMO_APP_TCP_SERVER_ENABLE */
|
|
|
|
#if IOT_DEMO_APP_UDP_SERVER_ENABLE || IOT_DEMO_APP_TCP_SERVER_ENABLE
|
|
|
|
void app_demo_net_tmr_handle(timer_id_t tid, void *data)
|
|
{
|
|
(void)tid;
|
|
(void)data;
|
|
|
|
if (netif_is_ready()) {
|
|
app_demo.netif_ready = true;
|
|
os_stop_timer(app_demo.net_t_id);
|
|
|
|
#if IOT_DEMO_APP_UDP_SERVER_ENABLE
|
|
app_demo_udp_server_init();
|
|
#endif
|
|
#if IOT_DEMO_APP_TCP_SERVER_ENABLE
|
|
app_demo_tcp_server_init();
|
|
#endif
|
|
} else {
|
|
iot_cus_printf("%s: demo netif not ready\n", __FUNCTION__);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
#endif /* IOT_DEMO_APP_UDP_SERVER_ENABLE || IOT_DEMO_APP_TCP_SERVER_ENABLE */
|
|
|
|
#endif /* IOT_LWIP_SUPPORT && PLC_SUPPORT_STA_ROLE */
|
|
|
|
void app_demo_temp_print_handle(timer_id_t tid, void *data)
|
|
{
|
|
(void)tid;
|
|
(void)data;
|
|
iot_cus_printf("temp raw=%d,cal=%d\n",
|
|
(int32_t)iot_adc_get_core_temperature(0),
|
|
(int32_t)iot_adc_get_core_temperature(1));
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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_cus_printf("led_on_with_wl\n");
|
|
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_cus_printf("led_on_without_wl\n");
|
|
iot_plc_led_request(IOT_PLC_LED_ASSOCIATED);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#if IOT_ADC_DEMO_ENABLE
|
|
|
|
uint32_t app_demo_adc_sample_init(void)
|
|
{
|
|
|
|
g_adc_info = (adc_info*)os_mem_malloc(IOT_DRIVER_MID, sizeof(adc_info));
|
|
|
|
if(g_adc_info == NULL){
|
|
DEMO_ERROR("ADC INIT ALLOC MEM FAILED !!", 1,2,3,4,5,6);
|
|
return ERR_FAIL;
|
|
|
|
}
|
|
|
|
os_mem_set(g_adc_info, 0x0, sizeof(adc_info));
|
|
|
|
g_adc_info->power_3v_channel_1 = ADC_CHANNEL1;
|
|
g_adc_info->power_3v_channel_2 = ADC_CHANNEL2;
|
|
|
|
/* adc init */
|
|
iot_adc_init();
|
|
DEMO_INFO("INITIALIZE ADC DONE", 1,2,3,4,5,6);
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
void app_demo_adc_channel_sample( uint8_t channl)
|
|
{
|
|
uint8_t timeout = 0;
|
|
int32_t volt = 0;
|
|
|
|
volt = iot_adc_poll_done(channl, ADC_ACC16, ADC_GAIN_3V, &timeout);
|
|
|
|
if(timeout == 1){
|
|
iot_cus_printf("adc channel %d data is invaild!\n",channl);
|
|
} else {
|
|
iot_cus_printf("adc channel %d raw data: %d, volt:%d mv!\n",channl,
|
|
volt, 3200*volt/511);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void app_demo_adc_periodic_sample(void)
|
|
{
|
|
static uint16_t period_cnt = 0;
|
|
uint16_t period = 0;
|
|
|
|
period = DEMO_APP_SAMPL_TM / DEMO_LED_TMR_PERIO;
|
|
|
|
period_cnt++;
|
|
|
|
if (period_cnt >= period) {
|
|
period_cnt = 0;
|
|
app_demo_adc_channel_sample(g_adc_info->power_3v_channel_1);
|
|
app_demo_adc_channel_sample(g_adc_info->power_3v_channel_2);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Write the OS running time to flash. */
|
|
void app_demo_stamp_running_time(void)
|
|
{
|
|
static uint32_t cnt = 1;
|
|
int fd;
|
|
uint32_t tick;
|
|
|
|
if((cnt++)%(DEMO_RUN_STAMP_TM/DEMO_LED_TMR_PERIO))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(-1 == (fd = custom_dev_open()))
|
|
{
|
|
DEMO_ERROR("OPEN CUSTOMER FLASH FAILED !!", 1, 2,3,4,5,6);
|
|
return;
|
|
}
|
|
|
|
tick = os_boot_time32()/1000; /* MS to S */
|
|
|
|
DEMO_INFO("WRITE RUNNING TIME#%d.", tick, 2,3,4,5,6);
|
|
|
|
if(-1 == custom_dev_write(fd, &tick, sizeof(tick)))
|
|
{
|
|
DEMO_ERROR("WRITE CUSTOMER FLASH FAILED !!", 1, 2,3,4,5,6);
|
|
}
|
|
|
|
(void)custom_dev_close(fd);
|
|
|
|
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;
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
|
|
/* 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);
|
|
|
|
#if IOT_LWIP_SUPPORT && PLC_SUPPORT_STA_ROLE
|
|
#if IOT_DEMO_APP_UDP_SERVER_ENABLE
|
|
iot_pkt_t *udp_pkt_v4;
|
|
|
|
if(NULL == (udp_pkt_v4 = iot_pkt_alloc(buffer_len, IOT_APP_DEMO_MID))) {
|
|
DEMO_ERROR("PACKET ALLOC FAILED !!", 1,2,3,4,5,6);
|
|
return ERR_FAIL;
|
|
}
|
|
|
|
os_mem_cpy(iot_pkt_put(udp_pkt_v4, buffer_len), buffer, buffer_len);
|
|
|
|
if(ERR_OK != app_demo_post_msg
|
|
(E_DEMO_MSG_PROCESS, E_CMD_ID_UART_TO_UDP4, (void*)udp_pkt_v4))
|
|
{
|
|
DEMO_ERROR("POST MSG FAILED !!", 1,2,3,4,5,6);
|
|
iot_pkt_free(udp_pkt_v4);
|
|
return ERR_FAIL;
|
|
}
|
|
#if LWIP_IPV6
|
|
iot_pkt_t *udp_pkt_v6;
|
|
|
|
if(NULL == (udp_pkt_v6 = iot_pkt_alloc(buffer_len, IOT_APP_DEMO_MID))) {
|
|
DEMO_ERROR("PACKET ALLOC FAILED !!", 1,2,3,4,5,6);
|
|
return ERR_FAIL;
|
|
}
|
|
|
|
os_mem_cpy(iot_pkt_put(udp_pkt_v6, buffer_len), buffer, buffer_len);
|
|
|
|
if(ERR_OK != app_demo_post_msg
|
|
(E_DEMO_MSG_PROCESS, E_CMD_ID_UART_TO_UDP6, (void*)udp_pkt_v6))
|
|
{
|
|
DEMO_ERROR("POST MSG FAILED !!", 1,2,3,4,5,6);
|
|
iot_pkt_free(udp_pkt_v6);
|
|
return ERR_FAIL;
|
|
}
|
|
#endif /* LWIP_IPV6 */
|
|
#endif /* IOT_DEMO_APP_UDP_SERVER_ENABLE */
|
|
|
|
#if IOT_DEMO_APP_TCP_SERVER_ENABLE
|
|
if (app_demo.tcp_server.conn_sock_id > 0) {
|
|
iot_pkt_t *tcp_pkt_v4;
|
|
|
|
if(NULL == (tcp_pkt_v4 = iot_pkt_alloc(buffer_len, IOT_APP_DEMO_MID))) {
|
|
DEMO_ERROR("PACKET ALLOC FAILED !!", 1,2,3,4,5,6);
|
|
return ERR_FAIL;
|
|
}
|
|
|
|
os_mem_cpy(iot_pkt_put(tcp_pkt_v4, buffer_len), buffer, buffer_len);
|
|
|
|
if(ERR_OK != app_demo_post_msg
|
|
(E_DEMO_MSG_PROCESS, E_CMD_ID_UART_TO_TCP4, (void*)tcp_pkt_v4))
|
|
{
|
|
DEMO_ERROR("POST MSG FAILED !!", 1,2,3,4,5,6);
|
|
iot_pkt_free(tcp_pkt_v4);
|
|
return ERR_FAIL;
|
|
}
|
|
}
|
|
#if LWIP_IPV6
|
|
if (app_demo.tcp_server.conn_sock_id6 > 0) {
|
|
iot_pkt_t *tcp_pkt_v6;
|
|
|
|
if(NULL == (tcp_pkt_v6 = iot_pkt_alloc(buffer_len, IOT_APP_DEMO_MID))) {
|
|
DEMO_ERROR("PACKET ALLOC FAILED !!", 1,2,3,4,5,6);
|
|
return ERR_FAIL;
|
|
}
|
|
|
|
os_mem_cpy(iot_pkt_put(tcp_pkt_v6, buffer_len), buffer, buffer_len);
|
|
|
|
if(ERR_OK != app_demo_post_msg
|
|
(E_DEMO_MSG_PROCESS, E_CMD_ID_UART_TO_TCP6, (void*)tcp_pkt_v6))
|
|
{
|
|
DEMO_ERROR("POST MSG FAILED !!", 1,2,3,4,5,6);
|
|
iot_pkt_free(tcp_pkt_v6);
|
|
return ERR_FAIL;
|
|
}
|
|
}
|
|
#endif /* LWIP_IPV6 */
|
|
#endif /* IOT_DEMO_APP_TCP_SERVER_ENABLE */
|
|
|
|
#endif /* IOT_LWIP_SUPPORT && PLC_SUPPORT_STA_ROLE */
|
|
|
|
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;
|
|
}
|
|
|
|
os_mem_cpy(iot_pkt_put(pkt, buffer_len), buffer, buffer_len);
|
|
|
|
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);
|
|
iot_pkt_free(pkt);
|
|
return ERR_FAIL;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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, DEMO_UART_BAUND, 0, 8, 1);
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
/* Rough control for led. */
|
|
void app_demo_led_ctrl(dm_led_s *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;
|
|
}
|
|
|
|
#if IOT_APPCTRL_LED
|
|
/* use app control led */
|
|
void app_demo_led_blink(void)
|
|
{
|
|
dm_led_s *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;
|
|
}
|
|
|
|
#else
|
|
|
|
void app_demo_led_blink(void)
|
|
{
|
|
return;
|
|
}
|
|
|
|
#endif /* end IOT_APPCTRL_LED */
|
|
|
|
/* 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_DEMO_EV_TIMR);
|
|
|
|
return;
|
|
}
|
|
|
|
#if IOT_APPCTRL_LED
|
|
/* use app control led */
|
|
uint32_t inline app_demo_led_set_blink_time(dm_led_s *led, int time)
|
|
{
|
|
DEMO_LED_LOCK();
|
|
|
|
led->blink_time = time;
|
|
|
|
DEMO_LED_UNLOCK();
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
#else
|
|
|
|
uint32_t inline app_demo_led_set_blink_time(dm_led_s *led, int time)
|
|
{
|
|
(void)led;
|
|
(void)time;
|
|
return ERR_OK;
|
|
}
|
|
|
|
#endif /* end IOT_APPCTRL_LED */
|
|
|
|
uint32_t app_demo_led_init(void)
|
|
{
|
|
dm_led_s *led = NULL;
|
|
|
|
led = &(app_demo.led.rx);
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/* Register an APP to PLC-layer,so we can transmit/receive packet from it. */
|
|
uint32_t app_demo_app_reg(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);
|
|
|
|
iot_cus_printf("%s len=%d msdu_len=%d meta_len=%d\n", __FUNCTION__, len, msdu_len, meta_len);
|
|
|
|
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;
|
|
}
|
|
msdu = (iot_plc_msdu_send_t*)(iot_pkt_data(msdu_pkt) + sizeof(iot_plc_msg_header_t));
|
|
iot_cus_printf("app_demo_send_plc_data msdu_len:%d\n", msdu->len);
|
|
|
|
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);
|
|
|
|
app_demo_main_bin_dmp(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);
|
|
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));
|
|
|
|
/* Blink RX-led. */
|
|
app_demo_led_set_blink_time
|
|
(&(app_demo.led.rx), DEMO_LED_RX_CONTINUE_TM);
|
|
|
|
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));
|
|
|
|
/* 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);
|
|
}
|
|
#if IOT_DEMO_APP_ETH_SUPPORT
|
|
else if (E_CMD_ID_RCV_FROM_PLC_CONNLESS == id)
|
|
{
|
|
iot_plc_msdu_recv_t *msdu;
|
|
iot_pkt_t *eth_pkt;
|
|
|
|
msdu = (iot_plc_msdu_recv_t*)
|
|
(iot_pkt_data(pkt) + sizeof(iot_plc_msg_header_t));
|
|
|
|
/* Blink RX-led. */
|
|
app_demo_led_set_blink_time
|
|
(&(app_demo.led.rx), DEMO_LED_RX_CONTINUE_TM);
|
|
|
|
if(NULL == (eth_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(eth_pkt, msdu->len), msdu->data, msdu->len);
|
|
|
|
DEMO_INFO("BINARY DATA FORWORD TO ETH:",1,2,3,4,5,6);
|
|
|
|
app_demo_main_bin_dmp(iot_pkt_data(eth_pkt), iot_pkt_data_len(eth_pkt));
|
|
|
|
/* Forward to eth intf */
|
|
if (app_demo_eth_send(iot_pkt_data(eth_pkt),
|
|
iot_pkt_data_len(eth_pkt))) {
|
|
iot_cus_printf("\n%s: failed to forword to ETH\n", __FUNCTION__);
|
|
}
|
|
|
|
iot_pkt_free(eth_pkt);
|
|
iot_pkt_free(pkt);
|
|
}
|
|
#endif
|
|
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);
|
|
}
|
|
#if IOT_DEMO_APP_ETH_SUPPORT
|
|
else if(E_CMD_ID_RCV_FROM_ETHERNET == id)
|
|
{
|
|
app_demo_send_plc_data(iot_pkt_data(pkt), iot_pkt_data_len(pkt), 1);
|
|
|
|
iot_pkt_free(pkt);
|
|
}
|
|
#endif
|
|
#if IOT_LWIP_SUPPORT && PLC_SUPPORT_STA_ROLE
|
|
#if IOT_DEMO_APP_UDP_SERVER_ENABLE
|
|
else if (E_CMD_ID_RCV_FROM_UDP_SOCKET == id)
|
|
{
|
|
iot_pkt_t *uart_pkt;
|
|
if(NULL == (uart_pkt = iot_pkt_alloc(iot_pkt_data_len(pkt),
|
|
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, iot_pkt_data_len(pkt)),
|
|
iot_pkt_data(pkt), iot_pkt_data_len(pkt));
|
|
iot_pkt_free(pkt);
|
|
|
|
DEMO_INFO("BINARY UDP 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));
|
|
|
|
/* Forword to uart port. */
|
|
iot_uart_send(app_demo.cmd_uart, uart_pkt, NULL);
|
|
}
|
|
else if (E_CMD_ID_UART_TO_UDP4 == id)
|
|
{
|
|
struct sockaddr to_addr4 = { 0 };
|
|
if (app_demo.udp_server.src_addr_len != 0) {
|
|
os_mem_cpy((void*)&to_addr4, (void*)&(app_demo.udp_server.src_addr),
|
|
app_demo.udp_server.src_addr_len);
|
|
demo_app_uart2udp_send(&to_addr4, app_demo.udp_server.src_addr_len,
|
|
iot_pkt_data(pkt), iot_pkt_data_len(pkt));
|
|
}
|
|
iot_pkt_free(pkt);
|
|
}
|
|
#if LWIP_IPV6
|
|
else if (E_CMD_ID_UART_TO_UDP6 == id)
|
|
{
|
|
struct sockaddr to_addr6 = { 0 };
|
|
if (app_demo.udp_server.src_addr_len6 != 0) {
|
|
os_mem_cpy((void*)&to_addr6,
|
|
(void*)&(app_demo.udp_server.src_addr6),
|
|
app_demo.udp_server.src_addr_len6);
|
|
demo_app_uart2udp_send_v6(&to_addr6,
|
|
app_demo.udp_server.src_addr_len6,
|
|
iot_pkt_data(pkt), iot_pkt_data_len(pkt));
|
|
}
|
|
iot_pkt_free(pkt);
|
|
}
|
|
#endif /* LWIP_IPV6 */
|
|
#endif /* IOT_DEMO_APP_UDP_SERVER_ENABLE */
|
|
#if IOT_DEMO_APP_TCP_SERVER_ENABLE
|
|
else if (E_CMD_ID_RCV_FROM_TCP_SOCKET == id)
|
|
{
|
|
iot_pkt_t *uart_pkt;
|
|
if(NULL == (uart_pkt = iot_pkt_alloc(iot_pkt_data_len(pkt),
|
|
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, iot_pkt_data_len(pkt)),
|
|
iot_pkt_data(pkt), iot_pkt_data_len(pkt));
|
|
iot_pkt_free(pkt);
|
|
|
|
DEMO_INFO("BINARY TCP 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));
|
|
|
|
/* Forword to uart port. */
|
|
iot_uart_send(app_demo.cmd_uart, uart_pkt, NULL);
|
|
}
|
|
else if (E_CMD_ID_UART_TO_TCP4 == id)
|
|
{
|
|
if (app_demo.tcp_server.src_addr_len != 0) {
|
|
demo_app_uart2tcp_send(iot_pkt_data(pkt), iot_pkt_data_len(pkt));
|
|
}
|
|
iot_pkt_free(pkt);
|
|
}
|
|
#if LWIP_IPV6
|
|
else if (E_CMD_ID_UART_TO_TCP6 == id)
|
|
{
|
|
if (app_demo.tcp_server.src_addr_len6 != 0) {
|
|
demo_app_uart2tcp_send_v6(iot_pkt_data(pkt), iot_pkt_data_len(pkt));
|
|
}
|
|
iot_pkt_free(pkt);
|
|
}
|
|
#endif /* LWIP_IPV6 */
|
|
#endif /* IOT_DEMO_APP_TCP_SERVER_ENABLE */
|
|
#endif /* IOT_LWIP_SUPPORT && PLC_SUPPORT_STA_ROLE */
|
|
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;
|
|
demo_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 = (demo_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_EV_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), BIT(event_type));
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
void app_demo_device_query()
|
|
{
|
|
static uint32_t cnt = 1;
|
|
|
|
if((cnt++)%(DEMO_APP_QUERY_TM/DEMO_LED_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;
|
|
}
|
|
|
|
void app_demo_event_handle(iot_task_h task_h, uint32_t event)
|
|
{
|
|
(void)task_h;
|
|
|
|
if(BIT(E_DEMO_EV_TIMR) & event)
|
|
{
|
|
app_demo_led_blink();
|
|
|
|
app_demo_stamp_running_time();
|
|
|
|
app_demo_device_query();
|
|
#if IOT_ADC_DEMO_ENABLE
|
|
if(g_adc_info)
|
|
{
|
|
app_demo_adc_periodic_sample();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
#if IOT_DEMO_APP_ETH_SUPPORT
|
|
if (!app_demo.dev.dev_ready) {
|
|
iot_eth_register_recv_callback(app_demo_eth_recv);
|
|
iot_eth_set_mac_addr(rpt->local_mac);
|
|
iot_eth_restart();
|
|
iot_cus_printf("\n%s: RESTART ETHERNET\n", __FUNCTION__);
|
|
}
|
|
#endif
|
|
|
|
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]);
|
|
|
|
#if IOT_DEMO_APP_ETH_SUPPORT
|
|
if (!app_demo.dev.dev_ready) {
|
|
iot_eth_register_recv_callback(app_demo_eth_recv);
|
|
iot_eth_set_mac_addr(rpt->local_mac);
|
|
iot_eth_restart();
|
|
iot_cus_printf("\n%s: RESTART ETHERNET\n", __FUNCTION__);
|
|
}
|
|
#endif
|
|
|
|
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 :
|
|
{
|
|
int16_t addr_index;
|
|
uint32_t cnt;
|
|
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;
|
|
}
|
|
#if IOT_DEMO_APP_ETH_SUPPORT
|
|
case IOT_PLC_MSG_CONN_LESS_RECV :
|
|
{
|
|
DEMO_INFO("IOT_PLC_MSG_CONN_LESS_RECV.", 1,2,3,4,5,6);
|
|
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]);
|
|
|
|
if(!app_demo.dev.dev_ready)
|
|
{
|
|
DEMO_INFO("DEVICE NOT READY.PACKET DROPPED.", 1,2,3,4,5,6);
|
|
break;
|
|
}
|
|
iot_check_meta_data(pkt);
|
|
#if PLC_SUPPORT_STA_ROLE
|
|
iot_meta_rcd_app_msdu_info(msdu, 0);
|
|
#endif
|
|
app_demo_post_msg
|
|
(E_DEMO_MSG_PROCESS, E_CMD_ID_RCV_FROM_PLC_CONNLESS, (void*)pkt);
|
|
/* Packet will not be freed here. */
|
|
pkt = NULL;
|
|
|
|
break;
|
|
}
|
|
#endif
|
|
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;
|
|
}
|
|
|
|
void app_demo_msg_timer_handle(demo_msg_t *dm_msg)
|
|
{
|
|
switch (dm_msg->msg.id)
|
|
{
|
|
case E_CMD_ID_TMR_ASSOC_CHECK:
|
|
{
|
|
app_demo_assoc_check_func();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void app_demo_msg_handle(iot_task_h task_h, iot_task_msg_t *msg)
|
|
{
|
|
demo_msg_t *dm_msg = (demo_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);
|
|
}
|
|
|
|
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)
|
|
{
|
|
demo_msg_t *dm_msg = (demo_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;
|
|
}
|
|
|
|
uint32_t app_demo_msg_task_init(void)
|
|
{
|
|
demo_msg_task_h *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(demo_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;
|
|
t_cfg->msg_exe_func = app_demo_msg_handle;
|
|
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;
|
|
}
|
|
|
|
extern void iot_print_config(bool_t enable);
|
|
|
|
uint32_t app_demo_module_init(void)
|
|
{
|
|
int ret = ERR_FAIL;
|
|
dm_dev_info *dev;
|
|
|
|
os_mem_set(&app_demo, 0x0, sizeof(app_demo));
|
|
|
|
/* Enable the customer-printf(). */
|
|
iot_cus_print_config(true);
|
|
iot_print_config(true);
|
|
|
|
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;
|
|
|
|
#if IOT_ADC_DEMO_ENABLE
|
|
DEMO_INFO(" ADC CHANNEL INITIALIZING...", 1,2,3,4,5,6);
|
|
if(ERR_OK !=(ret = app_demo_adc_sample_init()))
|
|
{
|
|
DEMO_ERROR("ADC INIT FAILED !!", 1,2,3,4,5,6);
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
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;
|
|
}
|
|
#if IOT_APPCTRL_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_INFO(" DEMO APP REGISTERING...", 1,2,3,4,5,6);
|
|
if(ERR_OK != (ret = app_demo_app_reg()))
|
|
{
|
|
DEMO_ERROR("APP REGISTER FAILED !!", 1,2,3,4,5,6);
|
|
break;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
DEMO_INFO(" SET BAND ID...", 1,2,3,4,5,6);
|
|
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;
|
|
}
|
|
|
|
#if PLC_SUPPORT_STA_ROLE && \
|
|
(IOT_DEMO_APP_UDP_SERVER_ENABLE || IOT_DEMO_APP_TCP_SERVER_ENABLE)
|
|
/* Create a timer for repeatedly works. */
|
|
if((timer_id_t)NULL == (app_demo.net_t_id = os_create_timer
|
|
(IOT_APP_DEMO_MID, 1, (os_timer_func_t)app_demo_net_tmr_handle,
|
|
(void *)DEMO_APP_NET_TMR_PERIOD)))
|
|
{
|
|
DEMO_ERROR("CREATE TMR FAILED !!", 1, 2,3,4,5,6);
|
|
return ERR_FAIL;
|
|
}
|
|
os_start_timer(app_demo.net_t_id, DEMO_APP_NET_TMR_PERIOD);
|
|
#endif
|
|
/* Create a timer for print of core temperature. */
|
|
app_demo.tmr_print_temp = os_create_timer(IOT_APP_DEMO_MID, 1,
|
|
(os_timer_func_t)app_demo_temp_print_handle, NULL);
|
|
|
|
if (0 == app_demo.tmr_print_temp) {
|
|
DEMO_ERROR("CREATE TMR FAILED !!", 1, 2,3,4,5,6);
|
|
return ERR_FAIL;
|
|
}
|
|
os_start_timer(app_demo.tmr_print_temp, DEMO_APP_TEMP_PRINT_TMR_PERIOD);
|
|
|
|
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;
|
|
}
|
|
|
|
#endif
|