andy/kunlun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2cb352f92c00476cf33fa8a2cbd2892ac89da9a4
kunlun/app/iot_cus_at_app/at/app_atcmd_handle.c
andy c756587541 初始提交
2024-09-28 14:24:04 +08:00

2817 lines
81 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/****************************************************************************
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 "app_main.h"
#include "app_uart.h"
#include "app_config.h"
#include "app_common.h"
#include "app_bypass_proc.h"
#include "app_atcmd_handle.h"
#include "iot_plc_sync_api.h"
#include "iot_app_pib_api.h"
#include "app_cus_task.h"
#include "iot_app_pib_cco_api.h"
#include "iot_app_pib_sta_api.h"
#include "iot_bitmap_api.h"
#include "iot_pkt_api.h"
#include "app_upg.h"
#if APP_IO_OPERATION_ENABLE
#include "app_gpio.h"
#endif /* end APP_IO_OPERATION_ENABLE */
static uint16_t get_atcmd_table_size(void);
static cmd_tbl_t *get_atcmd_by_index(uint16_t index);
static char *split_string_by_semicolons(char *str, char *out_buf);
#if PLC_SUPPORT_CCO_ROLE
static uint16_t app_atcmd_delaytime_rsp(uint8_t *data, uint16_t data_len,
uint8_t * src_addr);
#endif
uint32_t macstr_to_hex(char value, uint8_t *hex)
{
uint8_t s = 0;
if(value >= '0' && value <= '9') {
s = value - '0';
}else if(value >= 'A' && value <= 'F') {
s = value - 'A' + 0x0A;
}else if(value >= 'a' && value <= 'f') {
s = value - 'a' + 0x0A;
} else {
return ERR_FAIL;
}
*hex = s;
return ERR_OK;
}
uint16_t mac_str2hex(char *str_mac, uint8_t * hex_mac)
{
char ch1, ch2;
uint8_t s1, s2, i;
if (iot_strlen(str_mac) != 12) {
goto drop;
}
for (i = 0; i < IOT_MAC_ADDR_LEN; i++) {
ch1 = str_mac[2 * i];
ch2 = str_mac[2 * i + 1];
if (macstr_to_hex(ch1, &s1) || macstr_to_hex(ch2, &s2)) {
goto drop;
}
hex_mac[i] = (s1 << 4) + s2;
}
return ERR_OK;
drop:
return ERR_FAIL;
}
uint8_t is_hex(char v)
{
if((v >= '0' && v <= '9') || (v >= 'A' && v <= 'F') || (v >= 'a' && v <= 'f')) {
return 1;
} else {
return 0;
}
}
uint8_t to_hex(char v)
{
if (is_hex(v)) {
return (v <= '9' ? v - '0' : (v <= 'F' ? v - 'A' + 10 : v - 'a' + 10));
} else {
return 0;
}
}
uint16_t string2hex(char *str, uint16_t len, uint8_t *out, uint16_t *outlen)
{
char *p = str;
char high = 0, low = 0;
uint16_t tmplen = iot_strlen(p), cnt = 0;
if (len*2 > tmplen) {
APP_PRINTF("[ERR] %s strlen:%d, len:%d", __FUNCTION__, tmplen, len);
return 0;
}
while (cnt < (tmplen / 2)) {
if (!is_hex(*p) || !is_hex(*(p+1))) {
APP_PRINTF("[ERR] %s invalid hex:%s", __FUNCTION__, str);
return 0;
}
high = to_hex(*p);
p++;
low = to_hex(*p);
out[cnt] = ((high & 0x0f) << 4 | (low & 0x0f));
p++;
cnt++;
}
if (tmplen % 2 != 0)
out[cnt] = to_hex(*p);
if (outlen != NULL)
*outlen = len;
return tmplen;
}
uint32_t hexstring2uint32(char *str)
{
char hex_str[9] = {0};
uint8_t data[4] = {0};
if (strlen(str) > 8) {
return 0;
}
iot_sprintf(hex_str, "%08x", 0);
iot_strcpy(hex_str + 8 - strlen(str), str);
string2hex(hex_str, sizeof(uint32_t), data, NULL);
return data[0]<< 24 | data[1] << 16| data[2] << 8 | data[3];
}
AT_RET atcmd_test(uint16_t argc, char *argv[])
{
AT_RESP("AT Test\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_echo_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+ECHO=(0:off,1:on)\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_echo_query(uint16_t argc, char *argv[])
{
uint16_t flag;
flag = app_atcmd_get_echo();
AT_RESP_EQU("ECHO","%d\r\n\r\n", flag);
return AT_RET_OK;
}
AT_RET atcmd_echo_setup(uint16_t argc, char *argv[])
{
uint16_t flag = 0;
if (iot_atoi_to_uint16(argv[1], &flag) ||
(flag != 0 && flag != 1)){
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
app_atcmd_set_echo(flag);
ATCMD_PRINT("%s AT command echo.\n", (flag == 1 ? "open":"close"));
return AT_RET_OK;
}
AT_RET atcmd_log_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+LOG=(0:off,1:on)\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_log_query(uint16_t argc, char *argv[])
{
uint8_t flag;
flag = app_get_log_enable();
AT_RESP_EQU("LOG","%d\r\n\r\n", flag);
return AT_RET_OK;
}
AT_RET atcmd_log_setup(uint16_t argc, char *argv[])
{
uint8_t flag = 0;
if (iot_atoi_to_uint8(argv[1], &flag) ||
(flag != 0 && flag != 1)){
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
app_set_log_enable(flag);
ATCMD_PRINT("%s AT command log.\n", (flag == 1 ? "on":"off"));
return AT_RET_OK;
}
AT_RET atcmd_exit_exe(uint16_t argc, char *argv[])
{
uint8_t work_mode = app_get_init_work_mode();
app_set_work_mode(work_mode);
return AT_RET_OK;
}
AT_RET atcmd_mode_test(uint16_t argc, char *argv[])
{
#if (IOT_AT_ONLY == 1)
AT_RESP("AT+MODE=(0:bypass,2:at)\r\n");
#else /* else IOT_AT_ONLY == 0 */
AT_RESP("AT+MODE=(0:bypass,1:sila,2:at)\r\n");
#endif /* end IOT_AT_ONLY */
return AT_RET_OK;
}
AT_RET atcmd_mode_query(uint16_t argc, char *argv[])
{
uint8_t mode;
mode = app_get_init_work_mode();
AT_RESP_EQU("MODE","%d\r\n\r\n", mode);
return AT_RET_OK;
}
AT_RET atcmd_mode_setup(uint16_t argc, char *argv[])
{
uint8_t val = 0;
if (iot_atoi_to_uint8(argv[1], &val)) {
AT_RESP("invalid args:%d\r\n\r\n", val);
return AT_RET_ERR;
}
#if (IOT_AT_ONLY == 1)
if (val != APP_WORK_MODE_BYPASS && val != APP_WORK_MODE_AT) {
#else /* else IOT_AT_ONLY == 0 */
if (val < 0 || val > APP_WORK_MODE_MAX) {
#endif /* end IOT_AT_ONLY */
AT_RESP("invalid args:%d\r\n\r\n", val);
return AT_RET_ERR;
}
app_set_work_mode_to_nv(val);
return AT_RET_OK;
}
AT_RET atcmd_mac_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+MAC=<mac>\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_mac_query(uint16_t argc, char *argv[])
{
uint8_t *mac;
mac = app_get_mac_addr();
AT_RESP_EQU("MAC",""MAC_FMT"\r\n\r\n", MAC_ARG(mac));
return AT_RET_OK;
}
#if (IOT_APP_SELECTION == IOT_APP_DEF_25_AT_MICRO_CCTT)
/* at micro cctt does not support AT+MAC setup command */
AT_RET atcmd_mac_setup(uint16_t argc, char *argv[])
{
(void)argc;
(void)argv;
return AT_RET_ERR;
}
#else
AT_RET atcmd_mac_setup(uint16_t argc, char *argv[])
{
uint8_t mac[IOT_MAC_ADDR_LEN] = {0};
app_entity_t *app_entry = NULL;
iot_oem_base_cfg_t * oem_cfg;
app_entry = app_get_main_entry();
(void)iot_oem_get_base_cfg(&oem_cfg);
if (mac_str2hex(argv[1], mac) || 0 == iot_mac_addr_valid(mac)) {
AT_RESP("invalid <mac>\r\n\r\n");
return AT_RET_ERR;
}
ATCMD_PRINT("Set MAC Addr:"MAC_FMT, MAC_ARG(mac));
app_set_mac_addr(mac);
iot_mac_addr_cpy(oem_cfg->module_mac, mac);
if (iot_oem_set_base_cfg(oem_cfg) != ERR_OK) {
AT_RESP("set mac failed\r\n\r\n");
return AT_RET_ERR;
}
iot_mac_addr_cpy(app_entry->dev.mac_addr, mac);
return AT_RET_OK;
}
#endif
AT_RET atcmd_group_test(uint16_t argc, char *argv[])
{
if (!iot_plc_is_client_mode()) {
AT_RESP("cco not support\r\n\r\n");
return AT_RET_ERR;
}
//only cco support
AT_RESP("AT+GROUP=<add/del>,<group_list>,<mac_list>\r\n\r\n");
return AT_RET_OK;
}
/* AT+GROUP?
+GROUP=<cnt>,<group_list>
*/
AT_RET atcmd_group_query(uint16_t argc, char *argv[])
{
uint8_t *pdata;
uint8_t group_cnt;
uint16_t i;
uint16_t group = 0;
uint16_t index = 0;
iot_pkt_t *tmp_pkt;
app_entity_t *app_entry = app_get_main_entry();
if (!iot_plc_is_client_mode()) {
AT_RESP("cco not support\r\n\r\n");
return AT_RET_ERR;
}
group_cnt = app_entry->dev.sta_group.group_cnt;
APP_PRINTF("settd group_cnt=%d %d", group_cnt,
iot_bitmap_cbs(app_entry->dev.sta_group.group, IOT_STA_GROUP_BITMAP));
tmp_pkt = iot_pkt_alloc(ATCMD_STR_BUF_LEN, IOT_APP_DEMO_MID);
if (tmp_pkt == NULL) {
APP_PRINTF("[ERR] %s Mem Malloc Failed !!", __FUNCTION__);
return AT_RET_FAIL;
}
pdata = iot_pkt_data(tmp_pkt);
index += iot_sprintf((char*)pdata, "+GROUP:,%d", group_cnt);
if (group_cnt) {
index += iot_sprintf((char*)pdata + index, ",");
for (i = 0; i < group_cnt; i++) {
group = iot_bitmap_ffs_from(app_entry->dev.sta_group.group,
IOT_STA_GROUP_BITMAP, group + 1);
if (i > 0) {
index += iot_sprintf((char*)pdata + index, ";");
}
index += iot_sprintf((char*)pdata + index, "%d", group - 1);
}
}
iot_sprintf((char*)pdata + index,"\r\n\r\n");
AT_RESP("%s", (char*)pdata);
iot_pkt_free(tmp_pkt);
return AT_RET_OK;
}
/* example:
argv[1]:add/del
argv[2]:group_list
argv[3]:mac_list
group support from 0 to 255
AT+GROUP=add,1;2;4;5
AT+GROUP=del,1
AT+GROUP=add,1;2;4;5,000000001234;000000001235
AT+GROUP=del,2;4,000000001234;000000001235
*/
AT_RET atcmd_group_setup(uint16_t argc, char *argv[])
{
char *ptr;
uint8_t i, action;
uint8_t group;
uint8_t org_cnt;
uint8_t group_cnt = 0;
uint8_t allow_set = 0;
uint8_t set_group_list[IOT_STA_SUPPORT_MAX_GROUP] = {0};
uint8_t mac[IOT_MAC_ADDR_LEN] = {0};
char str[IOT_MAC_ADDR_LEN*2+1] = {0};
app_entity_t *app_entry = app_get_main_entry();
if (!iot_plc_is_client_mode()) {
AT_RESP("cco not support\r\n\r\n");
return AT_RET_ERR;
}
if (iot_strstr(argv[1], "add")) {
action = 1;
} else if (iot_strstr(argv[1], "del")) {
action = 0;
} else {
AT_RESP("invalid argv[1]:%s\r\n\r\n", argv[1]);
return AT_RET_ERR;
}
if (argc > 4 || argc < 3) {
AT_RESP("invalid args:%d\r\n\r\n", argc);
return AT_RET_ERR;
}
/* if mac_list include local mac, need handle */
if (argc == 4) {
ptr = argv[3];
//check mac
while (ptr) {
ptr = split_string_by_semicolons(ptr, str);
if ((mac_str2hex(str, mac) == ERR_OK) &&
iot_mac_addr_valid(mac) &&
iot_mac_addr_cmp(mac, app_entry->dev.mac_addr)) {
allow_set = 1;
break;
}
};
if (!allow_set) {
APP_PRINTF("not allow set group");
return AT_RET_NULL;
}
}
// checking group info
ptr = argv[2];
while (ptr) {
ptr = split_string_by_semicolons(ptr, str);
if (iot_atoi_to_uint8(str, &group)) {
AT_RESP("invalid group:%d\r\n\r\n", group);
return AT_RET_ERR;
}
// not add duplicate group address
if (action == 0 || (action == 1 &&
0 == iot_bitmap_is_set(app_entry->dev.sta_group.group,
IOT_STA_GROUP_BITMAP, group + 1))){
set_group_list[group_cnt++] = group;
}
};
org_cnt = app_entry->dev.sta_group.group_cnt;
APP_PRINTF("group_cnt=(%d %d) %s %d", org_cnt,
iot_bitmap_cbs(app_entry->dev.sta_group.group, IOT_STA_GROUP_BITMAP),
argv[1], group_cnt);
// group cnt error
if (action == 1 && (org_cnt + group_cnt) > IOT_STA_SUPPORT_MAX_GROUP) {
AT_RESP("invalid group_cnt=%d\r\n\r\n", group_cnt);
return AT_RET_ERR;
}
// set group
for (i = 0; i < group_cnt; i++) {
if (iot_bitmap_is_set(app_entry->dev.sta_group.group,
IOT_STA_GROUP_BITMAP, set_group_list[i] + 1)) {
// only setted delete
if (action == 0) {
iot_bitmap_clear(app_entry->dev.sta_group.group,
IOT_STA_GROUP_BITMAP, set_group_list[i] + 1);
app_entry->dev.sta_group.group_cnt--;
}
} else {
if (action == 1) {
// not set, then add
if (app_entry->dev.sta_group.group_cnt < IOT_STA_SUPPORT_MAX_GROUP) {
iot_bitmap_set(app_entry->dev.sta_group.group,
IOT_STA_GROUP_BITMAP, set_group_list[i] + 1);
app_entry->dev.sta_group.group_cnt++;
}
} else {
APP_PRINTF("del group:%d not added", set_group_list[i]);
}
}
}
// save group info when group num changes
if (app_entry->dev.sta_group.group_cnt != org_cnt) {
app_save_group_to_nv();
}
return AT_RET_OK;
}
#if PLC_SUPPORT_STA_ROLE
AT_RET atcmd_cco_mac_query(uint16_t argc, char *argv[])
{
uint8_t *mac;
mac = app_get_cco_mac_addr();
AT_RESP_EQU("CCOMAC",""MAC_FMT"\r\n\r\n", MAC_ARG(mac));
return AT_RET_OK;
}
AT_RET atcmd_mac_lock_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+LOCKMAC=(0:off,1:on)\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_mac_lock_query(uint16_t argc, char *argv[])
{
uint8_t lock_mac;
lock_mac = app_get_lock_mac();
AT_RESP_EQU("LOCKMAC","%d\r\n\r\n", lock_mac);
return AT_RET_OK;
}
AT_RET atcmd_mac_lock_setup(uint16_t argc, char *argv[])
{
/* point to app_entry->dev.cco_addr */
uint8_t *mac_cco;
uint8_t mac[IOT_MAC_ADDR_LEN];
uint8_t action;
if (iot_atoi_to_uint8(argv[1], &action)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if (action == ATCMD_MAC_LOCK) {
mac_cco = app_get_cco_mac_addr();
iot_mac_addr_cpy(mac, mac_cco);
if (0 == iot_mac_addr_valid(mac)) {
AT_RESP("lock mac failed\r\n\r\n");
ATCMD_PRINT("Invalid cco mac\n");
return AT_RET_ERR;
}
iot_mac_addr_reverse(mac);
if (ERR_OK != iot_plc_cco_set_whitelist_func(IOT_PLC_WL_ADD, 1, mac)) {
AT_RESP("lock mac failed\r\n\r\n");
ATCMD_PRINT("Set Whitelist Failed.\n");
return AT_RET_ERR;
}
if (ERR_OK != iot_plc_cco_set_whitelist_func(IOT_PLC_WL_ENABLE, 0, 0)) {
AT_RESP("lock mac failed\r\n\r\n");
ATCMD_PRINT("Open Whitelist Failed.\n");
return AT_RET_ERR;
}
app_set_lock_mac(ATCMD_MAC_LOCK);
AT_RESP_EQU("LOCKMAC",""MAC_FMT"\r\n\r\n", MAC_ARG(mac_cco));
} else if (action == ATCMD_MAC_UNLOCK) {
if (ERR_OK != iot_plc_cco_set_whitelist_func(IOT_PLC_WL_DISABLE, 0, 0)) {
AT_RESP("unlock mac failed\r\n\r\n");
ATCMD_PRINT("Close Whitelist Failed.\n");
return AT_RET_ERR;
}
if (ERR_OK != iot_plc_cco_set_whitelist_func(IOT_PLC_WL_DEL_ALL, 0, 0)) {
AT_RESP("unlock mac failed\r\n\r\n");
ATCMD_PRINT("Delete Whitelist Failed.\n");
return AT_RET_ERR;
}
app_set_lock_mac(ATCMD_MAC_UNLOCK);
} else {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
return AT_RET_OK;
}
static char *find_band_from_str(char *str, char *band)
{
char *pfind = NULL;
if (NULL == str)
return NULL;
pfind = iot_strstr(str,";");
if (pfind != NULL) {
pfind[0] = '\0';
pfind++;
}
iot_strcpy(band, str);
return pfind;
}
AT_RET atcmd_scan_band_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+SCANBAND=<cnt>,\"<band0>;<band1>;...\"[%d,%d]\r\n\r\n",
PLC_LIB_FREQ_BAND_0, PLC_LIB_FREQ_BAND_MAX - 1);
return AT_RET_OK;
}
AT_RET atcmd_scan_band_query(uint16_t argc, char *argv[])
{
uint8_t *fb_bitmap = NULL;
uint8_t i;
uint8_t bit_max = IOT_PLC_BAND_BITMAP_SIZE * 8;
if (0 == iot_app_get_scan_band_in_pib(&fb_bitmap)) {
ATCMD_PRINT("Query SCAN Band Failed\n");
return AT_RET_ERR;
}
for (i = 0; i < bit_max; i++) {
if (iot_bitmap_is_set(fb_bitmap, IOT_PLC_BAND_BITMAP_SIZE, i + 1)) {
AT_RESP_EQU("SCANBAND","%d\r\n", i);
}
}
return AT_RET_OK;
}
AT_RET atcmd_scan_band_setup(uint16_t argc, char *argv[])
{
uint8_t fb_bitmap[IOT_PLC_BAND_BITMAP_SIZE] = {0};
uint8_t count;
uint8_t str_band[4] = {0};
uint8_t band = 0xFF;
uint16_t i = 0;
if (argc < 3) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint8(argv[1], &count)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if (count >= PLC_LIB_FREQ_BAND_MAX) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
char *ptr = (char *)argv[2];
do {
if (ptr) {
ptr = find_band_from_str(ptr, (char *)str_band);
if (0 == iot_strlen((char *)str_band)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint8((char*)str_band, &band)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if ((band != PLC_LIB_FREQ_BAND_0) &&
(band != PLC_LIB_FREQ_BAND_1) &&
(band != PLC_LIB_FREQ_BAND_2) &&
(band != PLC_LIB_FREQ_BAND_9) &&
(band != PLC_LIB_FREQ_BAND_15)&&
(band != PLC_LIB_FREQ_BAND_8)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
iot_bitmap_set(fb_bitmap, IOT_PLC_BAND_BITMAP_SIZE, band + 1);
i++;
}
} while (ptr && (i != count));
app_set_scan_band_bitmap(fb_bitmap);
iot_app_save_scan_band_to_pib(fb_bitmap, IOT_PLC_BAND_BITMAP_SIZE);
return AT_RET_OK;
}
#endif
AT_RET atcmd_mid_query(uint16_t argc, char *argv[])
{
switch (app_get_hw_ver()) {
case APP_HW_IPL_YY01:
AT_RESP_EQU("MID","%s\r\n\r\n", "IPL_YY01");
break;
case APP_HW_IPL_YY03:
AT_RESP_EQU("MID","%s\r\n\r\n", "IPL_YY03");
break;
case APP_HW_Q111N_H:
AT_RESP_EQU("MID","%s\r\n\r\n", "Q111N-H");
break;
case APP_HW_Q111N_HS:
AT_RESP_EQU("MID","%s\r\n\r\n", "Q111N-HS");
break;
case APP_HW_Q111N_ISC:
AT_RESP_EQU("MID","%s\r\n\r\n", "Q111N-ISC");
break;
case APP_HW_Q111N_ISF:
AT_RESP_EQU("MID","%s\r\n\r\n", "Q111N-ISF");
break;
case APP_HW_Q111N_ISF03:
AT_RESP_EQU("MID","%s\r\n\r\n", "Q111N-ISF03");
break;
case APP_HW_Q111N_ISG:
AT_RESP_EQU("MID","%s\r\n\r\n", "Q111N-ISG");
break;
case APP_HW_LEDC_P:
AT_RESP_EQU("MID","%s\r\n\r\n", "LEDC_P");
break;
case APP_HW_LEDC:
AT_RESP_EQU("MID","%s\r\n\r\n", "LEDC");
break;
case APP_HW_HTZD_STA_1_PHASE:
AT_RESP_EQU("MID","%s\r\n\r\n", "HTZD_STA_1_PHASE");
break;
case APP_HW_HTZD_CCO_3_PHASE:
AT_RESP_EQU("MID","%s\r\n\r\n", "HTZD_CCO_3_PHASE");
break;
default:
AT_RESP_EQU("MID","%s\r\n\r\n", "NA");
break;
}
return AT_RET_OK;
}
AT_RET atcmd_gmr_query(uint16_t argc, char *argv[])
{
char sw_ver_info[20] = "";
iot_sprintf(sw_ver_info, "%d.%d.%d", iot_version_micro(), iot_version_build(),
APP_SW_VERSION_R);
AT_RESP_EQU("GMR","%s\r\n\r\n", sw_ver_info);
return AT_RET_OK;
}
AT_RET atcmd_restore_exe(uint16_t argc, char *argv[])
{
app_restore_factory();
app_pib_restore_factory();
ATCMD_PRINT("Restore Factory Settings.\n");
return AT_RET_OK;
}
AT_RET atcmd_reset_exe(uint16_t argc, char *argv[])
{
app_timer_start(APP_TIMER_ID_REBOOT, APP_TIMER_REBOOT_PERIOD, TIMER_TYPE_ONCE);
ATCMD_PRINT("Reboot.\n");
return AT_RET_OK;
}
AT_RET atcmd_heapsize_query(uint16_t argc, char *argv[])
{
return AT_RET_OK;
}
AT_RET atcmd_help(uint16_t argc, char *argv[])
{
uint16_t i;
uint16_t atcmd_list_len = get_atcmd_table_size();
cmd_tbl_t *atcmd = NULL;
AT_RESP("+HELP:\r\n");
for (i = 0; i < atcmd_list_len; i++) {
atcmd = get_atcmd_by_index(i);
if (atcmd && atcmd->usage) {
AT_RESP("%s - %s\r\n", atcmd->name, atcmd->usage);
}
}
return AT_RET_OK;
}
AT_RET atcmd_uart_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+UART=<baudrate>(2400,4800,9600,19200,38400,115200,380400,"
"921600,3000000), <data_bit>(5,6,7,8), <stop_bit>(1,1.5,2), "
"<parity>(0:none,1:odd,2:even), <thresholdvalue>[20,1000](unit:ms)\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_uart_query(uint16_t argc, char *argv[])
{
uart_cfg_t uart_para = {0};
char stop_bits[4] = {0};
if (iot_app_get_uart_cfg_in_pib(&uart_para) != ERR_OK) {
AT_RESP("get uart config failed\r\n\r\n");
return AT_RET_ERR;
}
if (0 == uart_para.uart_conf_vaild) {
uart_para.baud_rate = APP_DEFAULT_BAUND_RATE;
uart_para.data_bits = APP_DEFAULT_DATA_BITS;
uart_para.stop_bits = APP_DEFAULT_STOP_BITS;
uart_para.parity = APP_DEFAULT_PARITY;
uart_para.threshold_value = APP_DEFAULT_THDVALUE;
}
if (false == app_uart_stop_bits_itoa(uart_para.stop_bits, stop_bits)) {
AT_RESP("invalid uart param\r\n\r\n");
return AT_RET_ERR;
}
AT_RESP_EQU("UART","%d,%d,%s,%d,%d\r\n\r\n", uart_para.baud_rate,
uart_para.data_bits, stop_bits, uart_para.parity,
uart_para.threshold_value);
return AT_RET_OK;
}
AT_RET atcmd_uart_setup(uint16_t argc, char *argv[])
{
uart_cfg_t uart_para = {0};
if (argc < 5) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_app_get_uart_cfg_in_pib(&uart_para) != ERR_OK
|| 0 == uart_para.uart_conf_vaild) {
APP_PRINTF("[ERR] %s Get uart config failed, we will use default param!",
__FUNCTION__);
uart_para.baud_rate = APP_DEFAULT_BAUND_RATE;
uart_para.data_bits = APP_DEFAULT_DATA_BITS;
uart_para.stop_bits = APP_DEFAULT_STOP_BITS;
uart_para.parity = APP_DEFAULT_PARITY;
uart_para.threshold_value = APP_DEFAULT_THDVALUE;
}
if (false == app_uart_stop_bits_atoi((char *)argv[3],
&(uart_para.stop_bits))) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint32(argv[1], &uart_para.baud_rate)
|| iot_atoi_to_uint8(argv[2], &uart_para.data_bits)
|| iot_atoi_to_uint8(argv[4], &uart_para.parity)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if (argc > 5) {
if (iot_atoi_to_uint32(argv[5], &uart_para.threshold_value)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
}
if(uart_para.threshold_value < APP_DEFAULT_THDVALUE){
uart_para.threshold_value = APP_DEFAULT_THDVALUE;
}
if(uart_para.threshold_value > APP_MAX_THDVALUE){
uart_para.threshold_value = APP_MAX_THDVALUE;
}
ATCMD_PRINT("Set UART Param: baudrate=%d, data_bits=%d, stop_bits=%s(bits), "
"parity=%d, thresholdvalue=%d\n", uart_para.baud_rate, uart_para.data_bits,
(char *)argv[3], uart_para.parity, uart_para.threshold_value);
if (false == app_uart_is_valid(uart_para.baud_rate, uart_para.data_bits,
uart_para.stop_bits, uart_para.parity, uart_para.threshold_value)) {
AT_RESP("invalid uart config\r\n\r\n");
return AT_RET_ERR;
}
if (ERR_OK != iot_app_save_uart_cfg_to_pib(&uart_para)) {
AT_RESP("set uart failed\r\n\r\n");
return AT_RET_ERR;
}
return AT_RET_OK;
}
#if APP_IO_OPERATION_ENABLE
AT_RET atcmd_io_ctrl_test(uint16_t argc, char *argv[])
{
AT_RESP("At+IOCTRL=<mac>,<pin> :query sta gpio status\r\n");
AT_RESP("At+IOCTRL=<mac>,<pin>,<state:gpio level mode(0,1);pwm mode(0~100)>:"
"set sta gpio status\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_io_ctrl(uint16_t argc, char *argv[])
{
uint8_t ret = 0;
char at_cmd[30] = {0};
uint8_t len = 0;
uint8_t hex_mac[IOT_MAC_ADDR_LEN] = { 0 };
app_io_state io_state;
app_source_e source = app_atcmd_get_source();
if (argc < 3 || argc > 4) {
AT_RESP("invalid number of args\r\n\r\n");
ret = AT_RET_ERR;
goto RET;
}
if (ERR_OK != mac_str2hex((char *)argv[1], hex_mac)) {
ATCMD_PRINT("Convert MAC:%s Failed\n", argv[1]);
ret = AT_RET_ERR;
goto RET;
}
if (iot_plc_is_client_mode()) {
if (source == APP_SOURCE_UART) {
AT_RESP("unsupport <cmd>\r\n\r\n");
ret = AT_RET_ERR;
goto RET;
}
if (iot_atoi_to_uint8(argv[2], &io_state.pin_num)) {
AT_RESP("io num check failed\r\n\r\n");
ret = AT_RET_ERR;
goto RET;
}
app_get_gpio_state(&io_state);
if (argc == 3) {
if (app_check_io_state_param(&io_state) == false) {
AT_RESP("io param check failed\r\n\r\n");
ret = AT_RET_ERR;
goto RET;
}
AT_RESP_EQU("IOCTRL", ""MAC_FMT",%d,%d\r\n", MAC_ARG(hex_mac),
io_state.pin_num, io_state.state);
} else {
if (iot_atoi_to_uint8(argv[3], &io_state.state)) {
AT_RESP("io param check failed\r\n\r\n");
ret = AT_RET_ERR;
goto RET;
}
if (app_check_io_state_param(&io_state) == false) {
AT_RESP("io param check failed\r\n\r\n");
ret = AT_RET_ERR;
goto RET;
}
io_state.init_state = 0;
app_set_gpio_state(&io_state, STATE_SAVE_FLASH);
}
ret = AT_RET_OK;
} else {
if (argc == 3) {
len = sprintf(at_cmd,"%s=%s,%s\r\n", argv[0], argv[1], argv[2]);
} else {
len = sprintf(at_cmd,"%s=%s,%s,%s\r\n", argv[0], argv[1], argv[2],
argv[3]);
}
ret = AT_RET_NULL;
app_plc_tx((uint8_t *)at_cmd, len, hex_mac, ID_PLC_REMOTE_AT, NULL);
}
RET:
return ret;
}
AT_RET atcmd_io_param_test(uint16_t argc, char *argv[])
{
uint8_t io_pin[APP_IO_PIN_MAX_NUM] = {0}, i, num = 0;
AT_RESP("AT+IOPARAM=<pin:");
num = app_get_io_num(io_pin, sizeof(io_pin));
for (i = 0; i < num; i++) {
AT_RESP("%d",io_pin[i]);
if(i < num - 1) {
AT_RESP(",");
}
}
/* type: gpio mode
1:gpio level out mode;2:pwm mode;3:gpio level in mode
state: gpio status value
0 indicates low level,1 indicates high level when in gpio level mode
0~100 value range indicates duty when in pwm mode
pwm_freq: pwm frequence
the value range is 4~62 when pwm_ctl_mode is 0(adjust duty immediately)
the value is only 5 when pwm_ctl_mode is 1 or 2(adjust duty linearly
or logarithmically)
pwm_ctrl_mode: pwm adjustment mode
0:adjust duty immediately
1:adjust duty linearly gradually
2:adjust duty logarithmically gradually
pwm_adjust_time: duration of gradual duty adujustment
the range is 0~100 */
AT_RESP(">,<type:1,2,3>,<state:0,1(type=1,3)0~100(type=2)>,<pwm_freq:4~62>,"
"<pwm_ctl_mode:0(adjust duty immediately),1(adjust duty linearly gradually),"
"2(adjust duty logarithmically gradually)>,<pwm_adjust_time:0~100(duration"
" of gradual duty adujustment)>\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_io_param_query(uint16_t argc, char *argv[])
{
uint8_t i, pin_num[APP_IO_PIN_MAX_NUM] = {0};
app_io_state io_state;
app_get_io_num(pin_num, APP_IO_PIN_MAX_NUM);
for (i = 0; i < app_get_hw_io_array_size(); i++) {
io_state.pin_num = pin_num[i];
app_get_gpio_state(&io_state);
AT_RESP_EQU("IOPARAM", "%d,%d,%d,%d,%d,%d\r\n", io_state.pin_num,
io_state.type, io_state.state, io_state.pwm_freq,
io_state.pwm_ctl_mode, io_state.pwm_adjust_time);
}
AT_RESP("\r\n");
return AT_RET_OK;
}
AT_RET atcmd_io_param_setup(uint16_t argc, char *argv[])
{
app_io_state io_state;
if (argc < 7) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint8(argv[1], &io_state.pin_num)
|| iot_atoi_to_uint8(argv[2], &io_state.type)
|| iot_atoi_to_uint8(argv[3], &io_state.state)
|| iot_atoi_to_uint8(argv[4], &io_state.pwm_freq)
|| iot_atoi_to_uint8(argv[5], &io_state.pwm_ctl_mode)
|| iot_atoi_to_uint8(argv[6], &io_state.pwm_adjust_time)) {
AT_RESP("io param check failed\r\n\r\n");
return AT_RET_ERR;
}
io_state.init_state = 0;
if (app_check_io_state_param(&io_state) == false) {
AT_RESP("io param check failed\r\n\r\n");
return AT_RET_ERR;
}
app_set_gpio_state(&io_state, STATE_SAVE_FLASH);
return AT_RET_OK;
}
#define ATCMD_PWM_CASE_CNT 8
AT_RET atcmd_pwm_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+pwm=<chl>[0,5],<case>[0,%d],[pin_h][0,0xFF],[pin_l][0,0xFF],"
"[pin_tz][0,0xFF]\r\n\r\n", ATCMD_PWM_CASE_CNT);
return AT_RET_OK;
}
AT_RET atcmd_pwm_setup(uint16_t argc, char *argv[])
{
static int flag_pwm_init = 0;
iot_epwm_global_config_t epwm_glb_cfg = IOT_EPWM_GLOBAL_CONFIG_DEFAULT;
iot_epwm_ch_config_t epwm_ch_cfg = IOT_EPWM_CHANNEL_CONFIG_DEFAULT;
uint8_t chl = 0;
uint8_t sel = 0;
uint8_t pin_h = 0xFF;
uint8_t pin_l = 0xFF;
uint8_t pin_tz = 0xFF;
uint8_t err = 0;
if (argc < 3) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint8(argv[1], &chl)
|| iot_atoi_to_uint8(argv[2], &sel)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if ((argc >= 4) && iot_atoi_to_uint8(argv[3], &pin_h)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if ((argc >= 5) && iot_atoi_to_uint8(argv[4], &pin_l)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if ((argc >= 6) && iot_atoi_to_uint8(argv[5], &pin_tz)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if (chl >= iot_epwm_get_channel_count() || sel > ATCMD_PWM_CASE_CNT) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if (flag_pwm_init <= 0) {
iot_pwm_api_mode_select(IOT_API_MODE_EPWM);
iot_epwm_global_config_set(&epwm_glb_cfg);
flag_pwm_init = 1;
}
iot_epwm_global_stop();
epwm_glb_cfg.tz_pins[IOT_EPWM_TZ_1] = pin_tz;
iot_epwm_global_config_set(&epwm_glb_cfg);
switch (sel) {
case 0:
{
/* close all PWM channel output */
flag_pwm_init = 0;
for (chl = 0; chl < iot_epwm_get_channel_count(); chl++) {
if (chl == app_pwm_get_usable_channel()) {
continue;
}
iot_epwm_ch_close(chl);
}
break;
}
case 1:
{
/* output 1KHz 10% PWM */
epwm_ch_cfg.ch_usage = IOT_EPWM_CH_USEAGE_COMMON;
epwm_ch_cfg.ch_common_cfg.freq = 1000;
epwm_ch_cfg.ch_common_cfg.duty = 1000;
epwm_ch_cfg.ch_pin_outa = pin_h;
epwm_ch_cfg.ch_pin_outb = pin_l;
if (0 != iot_epwm_ch_config_set(chl, &epwm_ch_cfg)) {
err = 1;
goto OUT;
}
iot_epwm_ch_start(chl);
iot_epwm_global_start();
break;
}
case 2:
{
/* output 100kHz 50% PWM */
epwm_ch_cfg.ch_clk_div = 1;
epwm_ch_cfg.ch_usage = IOT_EPWM_CH_USEAGE_PRECISE;
epwm_ch_cfg.ch_precise_cfg.period_cnt = 250;
epwm_ch_cfg.ch_precise_cfg.compare_cnt = 125;
epwm_ch_cfg.ch_pin_outa = pin_h;
epwm_ch_cfg.ch_pin_outb = pin_l;
if (0 != iot_epwm_ch_config_set(chl, &epwm_ch_cfg)) {
err = 1;
goto OUT;
}
iot_epwm_ch_start(chl);
iot_epwm_global_start();
break;
}
case 3:
{
/* output 1KHz 50% PWM, enable trip-zone */
epwm_ch_cfg.ch_usage = IOT_EPWM_CH_USEAGE_COMMON;
epwm_ch_cfg.ch_common_cfg.freq = 1000;
epwm_ch_cfg.ch_common_cfg.duty = 5000;
epwm_ch_cfg.ch_pin_outa = pin_h;
epwm_ch_cfg.ch_pin_outb = pin_l;
epwm_ch_cfg.ch_trip_zone.enable = 1;
epwm_ch_cfg.ch_trip_zone.tz_en_for_cbc[IOT_EPWM_TZ_1] = 1;
epwm_ch_cfg.ch_trip_zone.act_outa = IOT_EPWM_TZ_ACT_SET_LOW;
epwm_ch_cfg.ch_trip_zone.act_outb = IOT_EPWM_TZ_ACT_SET_LOW;
if (0 != iot_epwm_ch_config_set(chl, &epwm_ch_cfg)) {
err = 1;
goto OUT;
}
iot_epwm_ch_start(chl);
iot_epwm_global_start();
break;
}
case 4:
{
/* output 1KHz 50% PWM, enable dead-band */
epwm_ch_cfg.ch_usage = IOT_EPWM_CH_USEAGE_COMMON;
epwm_ch_cfg.ch_common_cfg.freq = 1000;
epwm_ch_cfg.ch_common_cfg.duty = 5000;
epwm_ch_cfg.ch_pin_outa = pin_h;
epwm_ch_cfg.ch_pin_outb = pin_l;
epwm_ch_cfg.ch_dead_band.enable = 1;
epwm_ch_cfg.ch_dead_band.rising_delay = 10;
epwm_ch_cfg.ch_dead_band.falling_delay = 20;
if (0 != iot_epwm_ch_config_set(chl, &epwm_ch_cfg)) {
err = 1;
goto OUT;
}
iot_epwm_ch_start(chl);
iot_epwm_global_start();
break;
}
case 5:
{
/* output 1KHz 50% PWM, enable PWM chopper */
epwm_ch_cfg.ch_usage = IOT_EPWM_CH_USEAGE_COMMON;
epwm_ch_cfg.ch_common_cfg.freq = 1000;
epwm_ch_cfg.ch_common_cfg.duty = 5000;
epwm_ch_cfg.ch_pin_outa = pin_h;
epwm_ch_cfg.ch_pin_outb = pin_l;
epwm_ch_cfg.ch_chopper.enable = 1;
epwm_ch_cfg.ch_chopper.duty = 2;
epwm_ch_cfg.ch_chopper.divider = 1;
epwm_ch_cfg.ch_chopper.osht_width = 5;
if (0 != iot_epwm_ch_config_set(chl, &epwm_ch_cfg)) {
err = 1;
goto OUT;
}
iot_epwm_ch_start(chl);
iot_epwm_global_start();
break;
}
case 6:
{
/* output 1KHz 50% PWM, enable auto-duty */
epwm_ch_cfg.ch_usage = IOT_EPWM_CH_USEAGE_PRECISE;
epwm_ch_cfg.ch_precise_cfg.period_cnt = 1000;
epwm_ch_cfg.ch_pin_outa = pin_h;
epwm_ch_cfg.ch_pin_outb = pin_l;
epwm_ch_cfg.ch_auto_duty.enable = 1;
epwm_ch_cfg.ch_auto_duty.cmp_start = 100;
epwm_ch_cfg.ch_auto_duty.cmp_end = 800;
epwm_ch_cfg.ch_auto_duty.cmp_step = 1;
if (0 != iot_epwm_ch_config_set(chl, &epwm_ch_cfg)) {
err = 1;
goto OUT;
}
iot_epwm_ch_start(chl);
iot_epwm_global_start();
break;
}
case 7:
{
/* output 1KHz 50% PWM, enable single-pulse */
epwm_ch_cfg.ch_usage = IOT_EPWM_CH_USEAGE_COMMON;
epwm_ch_cfg.ch_common_cfg.freq = 1000;
epwm_ch_cfg.ch_common_cfg.duty = 5000;
epwm_ch_cfg.ch_pin_outa = pin_h;
epwm_ch_cfg.ch_pin_outb = pin_l;
epwm_ch_cfg.ch_single_pulse_en = 1;
if (0 != iot_epwm_ch_config_set(chl, &epwm_ch_cfg)) {
err = 1;
goto OUT;
}
iot_epwm_ch_start(chl);
iot_epwm_global_start();
break;
}
case 8:
{
/* output 1KHz 50% PWM, and reset after 5s */
epwm_ch_cfg.ch_usage = IOT_EPWM_CH_USEAGE_COMMON;
epwm_ch_cfg.ch_common_cfg.freq = 1000;
epwm_ch_cfg.ch_common_cfg.duty = 5000;
epwm_ch_cfg.ch_pin_outa = pin_h;
epwm_ch_cfg.ch_pin_outb = pin_l;
if (0 != iot_epwm_ch_config_set(chl, &epwm_ch_cfg)) {
err = 1;
goto OUT;
}
iot_epwm_ch_start(chl);
iot_epwm_global_start();
os_delay(5000);
iot_system_restart(IOT_SYS_RST_REASON_APP_REQ);
break;
}
default:
break;
}
OUT:
if (err) {
AT_RESP("epwm config failed!!\r\n\r\n");
}
return AT_RET_OK;
}
#endif /* end APP_IO_OPERATION_ENABLE */
AT_RET atcmd_calc_validity_query(uint16_t argc, char *argv[])
{
AT_RESP_EQU("CALC","%d\r\n\r\n", iot_board_calc_data_check());
return AT_RET_OK;
}
AT_RET atcmd_nid_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+NID=<nid>[1,16777215]\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_nid_query(uint16_t argc, char *argv[])
{
iot_plc_nid_info *nid_info = NULL;
iot_plc_cco_get_nid(&nid_info);
AT_RESP_EQU("NID","%d\r\n\r\n", nid_info->nid);
return AT_RET_OK;
}
AT_RET atcmd_nid_setup(uint16_t argc, char *argv[])
{
#if PLC_SUPPORT_CCO_ROLE
uint32_t nid;
if (iot_atoi_to_uint32(argv[1], &nid) || (nid < 1) || (nid > 16777215)) {
AT_RESP("invalid <nid>\r\n\r\n");
return AT_RET_ERR;
}
if (ERR_OK != iot_plc_cco_set_nid(nid)) {
AT_RESP("set <nid> failed\r\n\r\n");
return AT_RET_ERR;
}
return AT_RET_OK;
#else
AT_RESP("STA unsupport\r\n\r\n");
return AT_RET_NULL;
#endif
}
AT_RET atcmd_tei_info_query(uint16_t argc, char *argv[])
{
#if PLC_SUPPORT_STA_ROLE
uint16_t tei = 0;
uint8_t snr = 0, atten = 0, sr = 0;
tei = iot_plc_sta_get_proxy_tei_func();
if (0 == tei) {
AT_RESP("get tei failed\r\n\r\n");
return AT_RET_ERR;
}
snr = iot_plc_sta_get_snr_by_tei_func(tei);
atten = iot_plc_sta_get_atten_by_tei_func(tei);
sr = iot_plc_sta_get_tf_sr_by_tei_func(tei);
AT_RESP_EQU("TEIINFO", "SNR:%d,Atten:%d,TF-SR:%d\r\n\r\n", snr, atten, sr);
return AT_RET_OK;
#else
AT_RESP("CCO unsupport\r\n\r\n");
return AT_RET_NULL;
#endif
}
AT_RET atcmd_notify_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+NOTIFY=(0:off,1:on)\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_notify_query(uint16_t argc, char *argv[])
{
uint8_t sta_join_notify = 0;
sta_join_notify = app_get_sta_join_notify();
AT_RESP_EQU("NOTIFY","%d\r\n\r\n", sta_join_notify);
return AT_RET_OK;
}
AT_RET atcmd_notify_setup(uint16_t argc, char *argv[])
{
uint8_t sta_join_notify = 0;
if (iot_atoi_to_uint8(argv[1], &sta_join_notify)
|| (sta_join_notify != 0 && sta_join_notify != 1)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
app_set_sta_join_notify(sta_join_notify);
return AT_RET_OK;
}
AT_RET atcmd_txpwr_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+TXPWR=<power>[95,137]\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_txpwr_query(uint16_t argc, char *argv[])
{
iot_plc_freq_band_info *band_info = NULL;
iot_plc_query_band(&band_info);
AT_RESP_EQU("TXPWR","%d\r\n\r\n", band_info->power_cap);
return AT_RET_OK;
}
AT_RET atcmd_txpwr_setup(uint16_t argc, char *argv[])
{
uint8_t power = 0;
if (argc < 2) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint8(argv[1], &power) || power > 137 || power < 95) {
AT_RESP("invalid <power>\r\n\r\n");
return AT_RET_ERR;
}
if (ERR_OK != iot_plc_set_tx_power(power)) {
AT_RESP("set <power> failed\r\n\r\n");
return AT_RET_ERR;
}
return AT_RET_OK;
}
AT_RET atcmd_signal_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+SIGNAL=<mac>\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_signal_setup(uint16_t argc, char *argv[])
{
signal_test_t info = {0};
if (argc < 2) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (ERR_OK != mac_str2hex((char *)argv[1], info.dst)) {
ATCMD_PRINT("Convert MAC:%s Failed\n", argv[1]);
return AT_RET_ERR;
}
iot_mac_addr_cpy(info.src, app_get_mac_addr());
if (iot_mac_addr_cmp(info.dst, info.src)) {
ATCMD_PRINT("MAC:%s can't be self\n", argv[1]);
return AT_RET_ERR;
}
app_plc_tx((uint8_t*)(&info), sizeof(signal_test_t), info.dst,
ID_PLC_DATA_TEST, NULL);
return AT_RET_NULL;
}
AT_RET atcmd_nbnet_query(uint16_t argc, char *argv[])
{
iot_plc_nbnet_info *nbnet = NULL;
uint8_t i;
iot_plc_query_nbnet(&nbnet);
if (NULL == nbnet) {
ATCMD_PRINT("Query nbnet Failed\n");
return AT_RET_ERR;
}
for (i = 0; i < nbnet->count; i++) {
AT_RESP_EQU("NBNET",""MAC_FMT",0x%0x,%d,%d,%d\r\n",
MAC_ARG(nbnet->nbnet_info[i].cco_mac),
nbnet->nbnet_info[i].nid,
nbnet->nbnet_info[i].snr[0],
nbnet->nbnet_info[i].snr[1],
nbnet->nbnet_info[i].snr[2]);
}
return AT_RET_OK;
}
/* 通过分号拆分字符串
out_buf:找到的第一个字符串
返回去掉第一个拆分后的字符串 */
static char *split_string_by_semicolons(char *str, char *out_buf)
{
char *pfind = NULL;
if (NULL == str)
return NULL;
pfind = iot_strstr(str, ";");
if (pfind != NULL) {
pfind[0] = '\0';
pfind++;
}
if (out_buf)
iot_strcpy(out_buf, str);
return pfind;
}
#if PLC_SUPPORT_CCO_ROLE
AT_RET atcmd_toponum_query(uint16_t argc, char *argv[])
{
uint16_t topo_num = 0;
iot_plc_topo_info *topo = NULL;
iot_plc_cco_query_nw_topo(&topo, 0, 5);
if (NULL == topo) {
ATCMD_PRINT("Query TOPO Failed\n");
return AT_RET_ERR;
}
topo_num = topo->total_cnt;
AT_RESP_EQU("TOPONUM","%d\r\n\r\n", topo_num);
return AT_RET_OK;
}
AT_RET atcmd_topoinfo_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+TOOPINFO=<start_req>,<req_cnt>\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_topoinfo_query(uint16_t argc, char *argv[])
{
uint16_t start_req = 0, req_cnt = 0;
iot_plc_topo_info *topo = NULL;
uint16_t i;
if (argc < 3) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint16(argv[1], &start_req)
|| iot_atoi_to_uint16(argv[2], &req_cnt)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if (start_req <= 0 || (start_req > IOT_APP_WL_PIB_ADDR_CNT + 1)) {
AT_RESP("invalid args, max start:%d\r\n\r\n",
IOT_APP_WL_PIB_ADDR_CNT + 1);
return AT_RET_ERR;
}
if (start_req + req_cnt > IOT_APP_WL_PIB_ADDR_CNT + 1) {
req_cnt = IOT_APP_WL_PIB_ADDR_CNT + 1 - start_req;
}
if (req_cnt == 0) {
/* request query count is zero */
return AT_RET_OK;
}
iot_plc_cco_query_nw_topo(&topo, start_req - 1, req_cnt);
if (NULL == topo) {
ATCMD_PRINT("Query TOPO Failed\n");
return AT_RET_ERR;
}
for (i = 0; i < topo->cur_cnt; i++) {
AT_RESP_EQU("TOPOINFO", ""MAC_FMT",%d,%d,%d,%d,%d,%d,%d\r\n",
MAC_ARG(topo->topo_info[i].mac),
topo->topo_info[i].sta_tei,
topo->topo_info[i].proxy_tei,
topo->topo_info[i].level,
topo->topo_info[i].role,
iot_plc_sta_get_snr_by_addr_func(topo->topo_info[i].mac),
0,
iot_plc_sta_get_phase_by_addr_func(topo->topo_info[i].mac));
}
return AT_RET_OK;
}
AT_RET atcmd_whitelist_num_query(uint16_t argc, char *argv[])
{
uint16_t cnt = iot_app_get_wl_cnt();
AT_RESP_EQU("WHNUM","%d\r\n\r\n", cnt);
return AT_RET_OK;
}
AT_RET atcmd_whitelist_info_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+WHINFO=<start_req>,<req_cnt>\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_whitelist_info_query(uint16_t argc, char *argv[])
{
uint16_t start_req = 0, req_cnt = 0, i;
iot_plc_white_info_ext *whitelist_info = NULL;
if (argc < 3) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint16(argv[1], &start_req)
|| iot_atoi_to_uint16(argv[2], &req_cnt)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if (start_req == 0 || req_cnt == 0 || start_req > IOT_APP_WL_PIB_ADDR_CNT) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
req_cnt = min(req_cnt, IOT_APP_WL_PIB_ADDR_CNT + 1 - start_req);
iot_plc_cco_get_wl_info_ext_func(&whitelist_info, start_req - 1, req_cnt);
if (whitelist_info == NULL) {
ATCMD_PRINT("Get Whitelist Failed\n");
return AT_RET_ERR;
}
for (i = 0; i < whitelist_info->cur_cnt; i++) {
AT_RESP_EQU("WHINFO",""MAC_FMT" phase:%d\r\n",
MAC_ARG(whitelist_info->white_info[i].mac),
whitelist_info->white_info[i].phase);
}
return AT_RET_OK;
}
AT_RET atcmd_whitelist_add_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+WHADD=<cnt>,\"<mac0>;<mac1>;...\",phase\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_whitelist_add_setup(uint16_t argc, char *argv[])
{
uint16_t i = 0, count = 0;
char str[13] = {0};
uint8_t hex_mac[IOT_MAC_ADDR_LEN] = {0};
char *ptr;
uint8_t *data;
iot_pkt_t *pkt;
uint8_t phase = 0;
uint8_t action = IOT_PLC_WL_ADD;
if (argc < 3) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint16(argv[1], &count)
|| (count > APP_WHITELIST_SETUP_MAX)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
ptr = argv[2];
pkt = iot_pkt_alloc(ATCMD_SEND_MAX, IOT_APP_DEMO_MID);
if (pkt == NULL) {
ATCMD_PRINT("Alloc pkt Failed\n");
return AT_RET_ERR;
}
data = iot_pkt_put(pkt, ATCMD_SEND_MAX);
do {
if (ptr) {
ptr = split_string_by_semicolons(ptr, str);
if ((mac_str2hex(str, hex_mac) != ERR_OK) ||
(0 == iot_mac_addr_valid(hex_mac))) {
AT_RESP("invalid mac addr\r\n\r\n");
iot_pkt_free(pkt);
return AT_RET_ERR;
}
iot_mac_addr_reverse(hex_mac);
os_mem_cpy(data + IOT_MAC_ADDR_LEN*i, hex_mac, IOT_MAC_ADDR_LEN);
i++;
}
} while (ptr && (i != count));
if (argc >= 4) {
if (iot_atoi_to_uint8(argv[3], &phase)) {
AT_RESP("invalid phase\r\n\r\n");
iot_pkt_free(pkt);
return AT_RET_ERR;
}
switch (phase) {
case 1:
action = IOT_PLC_WL_ADD_PA;
break;
case 2:
action = IOT_PLC_WL_ADD_PB;
break;
case 3:
action = IOT_PLC_WL_ADD_PC;
break;
case 0:
default:
action = IOT_PLC_WL_ADD;
break;
}
}
if (ERR_OK != iot_plc_cco_set_whitelist_func(action, min(i, count), data)) {
AT_RESP("add whitelist failed\r\n\r\n");
iot_pkt_free(pkt);
return AT_RET_ERR;
}
iot_pkt_free(pkt);
return AT_RET_OK;
}
AT_RET atcmd_whitelist_delete_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+WHDEL=<cnt>,\"<mac0>;<mac1>;...\"\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_whitelist_delete_setup(uint16_t argc, char *argv[])
{
uint16_t i = 0, count = 0;
char str[13] = {0};
uint8_t hex_mac[IOT_MAC_ADDR_LEN] = {0};
char *ptr;
uint8_t *data;
iot_pkt_t *pkt;
if (argc < 3) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint16(argv[1], &count)
|| (count > APP_WHITELIST_SETUP_MAX)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
ptr = argv[2];
pkt = iot_pkt_alloc(ATCMD_SEND_MAX, IOT_APP_DEMO_MID);
if (pkt == NULL) {
ATCMD_PRINT("Alloc pkt Failed\n");
return AT_RET_ERR;
}
data = iot_pkt_put(pkt, ATCMD_SEND_MAX);
do {
if (ptr) {
ptr = split_string_by_semicolons(ptr, str);
if ((mac_str2hex(str, hex_mac) != ERR_OK) ||
(0 == iot_mac_addr_valid(hex_mac))) {
AT_RESP("invalid mac addr\r\n\r\n");
iot_pkt_free(pkt);
return AT_RET_ERR;
}
iot_mac_addr_reverse(hex_mac);
os_mem_cpy(data + IOT_MAC_ADDR_LEN*i, hex_mac, IOT_MAC_ADDR_LEN);
i++;
}
} while (ptr && (i != count));
if (ERR_OK != iot_plc_cco_set_whitelist_func(IOT_PLC_WL_DEL, min(i, count), data)) {
AT_RESP("del whitelist failed\r\n\r\n");
iot_pkt_free(pkt);
return AT_RET_ERR;
}
iot_pkt_free(pkt);
return AT_RET_OK;
}
AT_RET atcmd_whitelist_clear_exe(uint16_t argc, char *argv[])
{
if (ERR_OK != iot_plc_cco_set_whitelist_func(IOT_PLC_WL_DEL_ALL, 0, NULL)) {
AT_RESP("clear whitelist failed\r\n\r\n");
return AT_RET_ERR;
}
return AT_RET_OK;
}
AT_RET atcmd_whitelist_status_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+WHSTATUS=(0:off,1:on)\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_whitelist_status_query(uint16_t argc, char *argv[])
{
uint8_t flag;
flag = iot_plc_cco_get_whiltlist_state_func();
AT_RESP_EQU("WHSTATUS","%d\r\n\r\n", flag);
return AT_RET_OK;
}
AT_RET atcmd_whitelist_status_setup(uint16_t argc, char *argv[])
{
uint8_t flag = 0;
if (iot_atoi_to_uint8(argv[1], &flag)
|| (flag != 0 && flag != 1)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
if (flag == 0) {
if (ERR_OK != iot_plc_cco_set_whitelist_func(IOT_PLC_WL_DISABLE, 0, NULL)) {
AT_RESP("disable whitelist failed\r\n\r\n");
return AT_RET_ERR;
}
} else if (flag == 1) {
if (ERR_OK != iot_plc_cco_set_whitelist_func(IOT_PLC_WL_ENABLE, 0, NULL)) {
AT_RESP("enable whitelist failed\r\n\r\n");
return AT_RET_ERR;
}
}
return AT_RET_OK;
}
AT_RET atcmd_network_idf_status_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+IDFSTATUS=(0:off,1:on)\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_network_idf_status_query(uint16_t argc, char *argv[])
{
uint8_t flag;
flag = app_get_idf_status();
AT_RESP_EQU("IDFSTATUS","%d\r\n\r\n", flag);
return AT_RET_OK;
}
AT_RET atcmd_network_idf_status_setup(uint16_t argc, char *argv[])
{
uint8_t flag = 0;
if (iot_atoi_to_uint8(argv[1], &flag)
|| (flag != 0 && flag != 1)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
app_set_idf_status(flag);
if (flag) {
AT_RESP("effective after reboot\r\n\r\n");
}
return AT_RET_OK;
}
AT_RET atcmd_remote_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+REMOTE=<mac>,<cmd>\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_remote_setup(uint16_t argc, char *argv[])
{
uint8_t flag = 0;
uint8_t *buffer;
uint16_t i;
uint16_t len = 0;
uint16_t atcmd_list_len = get_atcmd_table_size();
cmd_tbl_t *cmd_tbl = NULL;
uint8_t hex_mac[IOT_MAC_ADDR_LEN] = { 0 };
iot_pkt_t *pkt_buf = NULL;
if (argc < 3) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (ERR_OK != mac_str2hex((char *)argv[1], hex_mac)) {
ATCMD_PRINT("Convert MAC:%s Failed\n", argv[1]);
return AT_RET_ERR;
}
for (i = 0; i < atcmd_list_len; i++) {
cmd_tbl = get_atcmd_by_index(i);
if (cmd_tbl && (iot_strstr(argv[2], cmd_tbl->name) != NULL) &&
(cmd_tbl->is_remote == 1)) {
flag = 1;
break;
}
}
if (flag == 0) {
AT_RESP("unsupport <cmd>\r\n\r\n");
return AT_RET_ERR;
}
len = iot_strlen(argv[2]);
pkt_buf = iot_pkt_alloc(len + 2, IOT_APP_DEMO_MID);
if (NULL == pkt_buf) {
ATCMD_PRINT("Malloc failed!!!\n");
return AT_RET_ERR;
}
buffer = iot_pkt_put(pkt_buf, len + 2);
os_mem_cpy((char *)buffer, argv[2], len);
os_mem_cpy((char *)buffer + len, "\r\n", 2);
app_plc_tx(buffer, len + 2, hex_mac, ID_PLC_REMOTE_AT, NULL);
iot_pkt_free(pkt_buf);
return AT_RET_NULL;
}
AT_RET atcmd_band_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+BAND=<band>[%d,%d]\r\n\r\n", PLC_LIB_FREQ_BAND_0,
PLC_LIB_FREQ_BAND_MAX);
return AT_RET_OK;
}
AT_RET atcmd_band_query(uint16_t argc, char *argv[])
{
iot_plc_freq_band_info *band_info;
iot_plc_query_band(&band_info);
AT_RESP_EQU("BAND","%d\r\n\r\n", band_info->freq_band);
return AT_RET_OK;
}
/* the minimum frequency band allowed to be set is PLC_LIB_FREQ_BAND_0 */
AT_RET atcmd_band_setup(uint16_t argc, char *argv[])
{
uint8_t freq_band = 0;
if (argc < 2) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint8(argv[1], &freq_band)) {
AT_RESP("invalid paran of args\r\n\r\n");
return AT_RET_ERR;
}
if ((freq_band != PLC_LIB_FREQ_BAND_0) &&
(freq_band != PLC_LIB_FREQ_BAND_1) &&
(freq_band != PLC_LIB_FREQ_BAND_2) &&
(freq_band != PLC_LIB_FREQ_BAND_9) &&
(freq_band != PLC_LIB_FREQ_BAND_15) &&
(freq_band != PLC_LIB_FREQ_BAND_8)) {
iot_cus_printf("invalid <band %d>\n", freq_band);
return AT_RET_ERR;
}
if (iot_plc_set_band(freq_band)) {
AT_RESP("set fail\r\n\r\n");
return AT_RET_ERR;
}
iot_app_save_work_band_to_pib(freq_band);
return AT_RET_OK;
}
AT_RET atcmd_upgrade_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+UPGRADE=<cmd>\r\n\r\n");
return AT_RET_OK;
}
void app_proto_upgrd_resp(uint8_t *data)
{
upgrd_resp_t *resp;
resp = (upgrd_resp_t*)(data + UPGRADE_DATA_HEAD_LEN);
AT_RESP("+UPGRADE=%d,%d\r\n\r\n", resp->state, resp->reason);
}
void app_proto_upgrd_state_resp(uint8_t *data)
{
upgrade_state_resp_t *resp;
resp = (upgrade_state_resp_t*)(data + UPGRADE_DATA_HEAD_LEN);
AT_RESP("+UPGRADE=%d,%d\r\n\r\n", resp->state, resp->fail_sta);
}
void app_proto_upgrd_progress_resp(uint8_t *data)
{
uint8_t i;
query_progress_ind *resp;
resp = (query_progress_ind*)(data + UPGRADE_DATA_HEAD_LEN);
AT_RESP("+UPGRADE=%d,%d,%d,\r\n", resp->upgrade_total_count,
resp->start_index, resp->resp_count);
for (i = 0; i < resp->resp_count; i++) {
AT_RESP("\t"MAC_FMT"-%d-%d,\r\n", MAC_ARG(resp->info[i].mac),
resp->info[i].status, resp->info[i].progress);
}
AT_RESP("\r\n");
}
AT_RET atcmd_upgrade_setup(uint16_t argc, char *argv[])
{
uint8_t cmd_type = 0;
uint16_t out_len = 0;
iot_pkt_t *pkt = NULL;
uint8_t ret = AT_RET_ERR;
app_entity_t *app_entry = NULL;
app_entry = app_get_main_entry();
if (argc < 2) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint8(argv[1], &cmd_type)) {
AT_RESP("invalid paran of args\r\n\r\n");
return AT_RET_ERR;
}
switch (cmd_type) {
case UPGRADE_START_TRANS_FILE:
{
proto_start_trans_file_req req;
if (argc < 7) {
AT_RESP("invalid number of args for upgrade start trans_file\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint8(argv[2], &req.file_attr)
|| iot_atoi_to_uint16(argv[3], &req.seg_total)
|| iot_atoi_to_uint32(argv[5], &req.file_len)
|| iot_atoi_to_uint32(argv[7], &req.trans_timeout)) {
AT_RESP("invalid paran of args\r\n\r\n");
return AT_RET_ERR;
}
req.file_crc = hexstring2uint32(argv[6]);
iot_cus_printf("upgrade: cmd=%d file_attr=%d seg_total=%d "
"file_len=%d file_crc=0x%X tm_out=%d\n", cmd_type, req.file_attr,
req.seg_total, req.file_len, req.file_crc, req.trans_timeout);
ret = app_proto_start_trans_file(&req, app_entry->out_buf, &out_len);
if (ret == 0) {
app_proto_upgrd_resp(app_entry->out_buf);
}
break;
}
case UPGRADE_TRANS_FILE_DATA:
{
uint16_t seg_len;
proto_trans_file_data_req *req = NULL;
if (argc < 5) {
AT_RESP("invalid number of args for upgrade start trans_file\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint16(argv[3], &seg_len)) {
AT_RESP("invalid paran of args\r\n\r\n");
return AT_RET_ERR;
}
/* seg_len need less than or equal to PROTO_UPGRADE_BLOCK_SIZE */
if (seg_len > PROTO_UPGRADE_BLOCK_SIZE) {
AT_RESP("cmd seg_len err:%d > %d\r\n\r\n", seg_len,
PROTO_UPGRADE_BLOCK_SIZE);
return AT_RET_ERR;
}
pkt = iot_pkt_alloc(sizeof(proto_trans_file_data_req) + seg_len,
IOT_APP_DEMO_MID);
if (pkt == NULL) {
AT_RESP("alloc mem err\r\n\r\n");
return AT_RET_ERR;
}
req = (proto_trans_file_data_req*)iot_pkt_put(pkt,
sizeof(proto_trans_file_data_req) + seg_len);
if (iot_atoi_to_uint16(argv[2], &req->seg_num)) {
AT_RESP("invalid paran of args\r\n\r\n");
return AT_RET_ERR;
}
req->seg_size = seg_len;
req->seg_crc = hexstring2uint32(argv[4]);
iot_data_reverse((uint8_t*)&req->seg_crc, sizeof(uint16_t));
string2hex(argv[5], req->seg_size, req->seg_data, NULL);
ret = app_proto_trans_file_data(req, app_entry->out_buf, &out_len);
iot_pkt_free(pkt);
if (ret == 0) {
app_proto_upgrd_resp(app_entry->out_buf);
}
break;
}
case UPGRADE_STATE_QUERY:
{
ret = app_proto_trans_file_query(app_entry->out_buf, &out_len);
app_proto_upgrd_state_resp(app_entry->out_buf);
break;
}
case UPGRADE_SET_MAC_LIST:
{
uint8_t i;
uint8_t renew;
uint8_t count;
set_upgrd_list_t *req;
uint8_t hex_mac[IOT_MAC_ADDR_LEN] = { 0 };
if (argc < 4) {
AT_RESP("invalid number of args for upgrade set mac list\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint8(argv[2], &renew)) {
AT_RESP("invalid paran of renew\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint8(argv[3], &count)) {
AT_RESP("invalid paran of count\r\n\r\n");
return AT_RET_ERR;
}
pkt = iot_pkt_alloc(sizeof(set_upgrd_list_t) + count * IOT_MAC_ADDR_LEN,
IOT_APP_DEMO_MID);
if (pkt == NULL) {
AT_RESP("alloc mem err\r\n\r\n");
return AT_RET_ERR;
}
req = (set_upgrd_list_t*)iot_pkt_put(pkt,
sizeof(set_upgrd_list_t) + count * IOT_MAC_ADDR_LEN);
if (argc < 3 + count) {
AT_RESP("invalid number of args for upgrade set mac list\r\n");
return AT_RET_ERR;
}
for (i = 0; i < count; i++) {
if (ERR_OK != mac_str2hex((char*)argv[i+4], hex_mac)) {
break;
}
iot_mac_addr_cpy(req->mac + i * IOT_MAC_ADDR_LEN, hex_mac);
req->count++;
}
ret = app_proto_set_upgrd_list(req, app_entry->out_buf, &out_len, renew);
iot_pkt_free(pkt);
if (ret == 0) {
app_proto_upgrd_resp(app_entry->out_buf);
}
break;
}
case UPGRADE_STA_PROGRESS_QUERY:
{
query_progress_req req;
if (argc < 3) {
AT_RESP("invalid number of args for upgrade sta progress\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint16(argv[2], &req.start_index)
|| iot_atoi_to_uint8(argv[3], &req.count)) {
AT_RESP("invalid paran of args\r\n\r\n");
return AT_RET_ERR;
}
if (req.start_index == 0) {
AT_RESP("invalid req start, need start from 1.\r\n\r\n");
return AT_RET_ERR;
}
if (req.count > PROTO_UPGD_RESP_MAX_CNT) {
AT_RESP("invalid req count:%d > %d\r\n\r\n",req.count, PROTO_UPGD_RESP_MAX_CNT);
return AT_RET_ERR;
}
ret = app_proto_trans_file_query_progress(&req, app_entry->out_buf, &out_len);
if (ret == 0) {
app_proto_upgrd_progress_resp(app_entry->out_buf);
}
break;
}
default:
AT_RESP("invalid cmd_tyoe:%d\r\n\r\n", cmd_type);
return AT_RET_ERR;
}
if (ret != AT_RET_OK) {
ret = AT_RET_FAIL;
}
return ret;
}
AT_RET atcmd_bcast_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+BCAST=<status>[%d,%d],<period>[%d,%d],<len>[%d,%d],"
"<data>,[send_flag][%d,%d]\r\n\r\n", APP_BCAST_STATUS_OFF,
APP_BCAST_STATUS_ON, APP_BCAST_PERIOD_MIN, APP_BCAST_PERIOD_MAX,
APP_BCAST_LEN_MIN, APP_BCAST_LEN_MAX, APP_BCAST_SEND_DEFAULT,
APP_BCAST_SEND_CONNLESS);
return AT_RET_OK;
}
AT_RET atcmd_bcast_query(uint16_t argc, char *argv[])
{
uint8_t i = 0;
app_entity_t *app_entry = NULL;
app_entry = app_get_main_entry();
AT_RESP_EQU("BCAST","%d,%d,%d,", app_entry->app_cfg.bcast.status,
app_entry->app_cfg.bcast.period, app_entry->app_cfg.bcast.len);
for (; i < app_entry->app_cfg.bcast.len; i++) {
AT_RESP("%02x", app_entry->app_cfg.bcast.data[i]);
}
if (app_entry->app_cfg.bcast.len == 0) {
AT_RESP("0");
}
AT_RESP(",%d", app_entry->app_cfg.bcast.send_flag);
AT_RESP("\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_bcast_setup(uint16_t argc, char *argv[])
{
uint8_t status, send_flag;
uint16_t period, len, data_len;
app_entity_t *app_entry = NULL;
app_entry = app_get_main_entry();
if (argc != 2 && argc != 5 && argc != 6) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint8(argv[1], &status)
|| (status != APP_BCAST_STATUS_ON && status != APP_BCAST_STATUS_OFF)) {
AT_RESP("invalid status[%d]\r\n\r\n", status);
return AT_RET_ERR;
}
if (argc > 2) {
if (iot_atoi_to_uint16(argv[2], &period)
|| period < APP_BCAST_PERIOD_MIN
|| period > APP_BCAST_PERIOD_MAX) {
AT_RESP("invalid period[%d]\r\n\r\n", period);
return AT_RET_ERR;
}
if (iot_atoi_to_uint16(argv[3], &len)
|| len < APP_BCAST_LEN_MIN
|| len > APP_BCAST_LEN_MAX) {
AT_RESP("invalid len[%d]\r\n\r\n", len);
return AT_RET_ERR;
}
data_len = iot_strlen((char *)argv[4]);
if (data_len <= (2 * APP_BCAST_LEN_MAX)) {
if (data_len != (2 * len)) {
ATCMD_PRINT("data len is mismatch\r\n");
return AT_RET_ERR;
}
string2hex((char *)argv[4], len, app_entry->app_cfg.bcast.data, NULL);
} else {
AT_RESP("data_len exceed max\r\n");
return AT_RET_ERR;
}
if (argc == 6) {
if (iot_atoi_to_uint8(argv[5], &send_flag)
|| (send_flag != 0 && send_flag != 1)) {
AT_RESP("invalid arg[%d], %s\r\n\r\n", argc - 1, argv[5]);
return AT_RET_ERR;
}
/* use at command argument to set force connless */
app_entry->app_cfg.bcast.send_flag = send_flag;
}
app_entry->cco_bcast_per_cnt = 0;
app_entry->app_cfg.bcast.period = period;
app_entry->app_cfg.bcast.len = len;
}
app_entry->app_cfg.bcast.status = status;
app_save_bcast_to_nv();
return AT_RET_OK;
}
#endif /* PLC_SUPPORT_CCO_ROLE */
AT_RET atcmd_delay_time_test(uint16_t argc, char *argv[])
{
uint8_t hex_mac[IOT_MAC_ADDR_LEN] = { 0 };
uint8_t *data;
uint32_t mcu_time = 0;
uint32_t sn;
uint16_t datalen = sizeof(delay_time_test);
uint16_t fill_num = 0;
iot_pkt_t *tmp_pkt = NULL;
delay_time_test *p_delay;
if (argc == 5) {
if (iot_atoi_to_uint32(argv[3], &mcu_time)
|| iot_atoi_to_uint16(argv[4], &fill_num)) {
AT_RESP("invalid param of args\r\n\r\n");
return AT_RET_ERR;
}
} else if (argc == 4) {
if (iot_atoi_to_uint32(argv[3], &mcu_time)) {
AT_RESP("invalid param of args\r\n\r\n");
return AT_RET_ERR;
}
} else {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (0 == mcu_time) {
AT_RESP("invalid mcu time\n");
return AT_RET_ERR;
}
if (iot_atoi_to_uint32(argv[2], &sn) || (sn > ATCMD_DALAYTIME_SN_MAX)) {
ATCMD_PRINT("the max index is %d\n", ATCMD_DALAYTIME_SN_MAX);
return AT_RET_ERR;
}
if (fill_num > ATCMD_DALAYTIME_PAD_MAX) {
fill_num = ATCMD_DALAYTIME_PAD_MAX;
ATCMD_PRINT("the max fill count is %d\n", fill_num);
}
datalen += fill_num;
tmp_pkt = iot_pkt_alloc(datalen, IOT_APP_DEMO_MID);
if (tmp_pkt == NULL) {
ATCMD_PRINT("AT timer delay alloc pkt Failed\n");
return AT_RET_ERR;
}
APP_PRINTF("fill_num is %d\n", fill_num);
data = (uint8_t *)iot_pkt_put(tmp_pkt, datalen);
p_delay = (delay_time_test *)data;
p_delay->datalen = fill_num;
p_delay->sn = sn;
if (ERR_OK != mac_str2hex((char*)argv[1], hex_mac)) {
ATCMD_PRINT("%s delay time test Failed\n", argv[1]);
iot_pkt_free(tmp_pkt);
return AT_RET_ERR;
}
os_mem_cpy(data + sizeof(uint32_t), &mcu_time, sizeof(uint32_t));
delay_timer_get(data, CCO_TX_TIME, 0);
app_plc_tx(data, datalen, hex_mac, ID_PLC_AT_DELAYTIME, NULL);
iot_pkt_free(tmp_pkt);
return AT_RET_OK;
}
AT_RET atcmd_net_set_query(uint16_t argc, char *argv[])
{
uint8_t flag;
flag = app_get_net_enable();
AT_RESP_EQU("NET","%d\r\n\r\n", flag);
return AT_RET_OK;
}
AT_RET atcmd_net_set_setup(uint16_t argc, char *argv[])
{
uint8_t flag;
if (iot_atoi_to_uint8(argv[1], &flag) || (flag != 0 && flag != 1)) {
AT_RESP("invalid args\r\n\r\n");
return AT_RET_ERR;
}
app_set_net_enable(flag);
ATCMD_PRINT("%s AT net.\n", (flag == 1 ? "on":"off"));
return AT_RET_OK;
}
/* 命令格式：AT+DELAYTIME=MAC,sn,MCU时间,填充数据数量(可为0-1024,可不填）
eg:AT+DELAYTIME=120312031203,100,00000006,128 */
uint16_t app_atcmd_plc_linktest_handle(uint8_t *data, uint16_t data_len,
uint8_t *src_addr)
{
app_entity_t *app_entry = app_get_main_entry();
#if PLC_SUPPORT_CCO_ROLE
delay_time_test *p_delay = (delay_time_test *)data;
/* 填充部分不用上传 */
data_len = data_len - p_delay->datalen;
delay_timer_get(data, CCO_RX_TIME, app_entry->receivetime);
app_ntb_to_us(data);
app_atcmd_delaytime_rsp(data, data_len, src_addr);
#else
delay_timer_get(data, STA_RX_TIME, app_entry->receivetime);
delay_timer_get(data, STA_TX_TIME, 0);
app_plc_tx(data, data_len, src_addr, ID_PLC_AT_DELAYTIME, NULL);
#endif
return ERR_OK;
}
/* 命令格式：AT+SIGNAL=MAC query loop snr rssi */
uint16_t app_atcmd_signal_test_handle(uint8_t *data, uint16_t data_len,
void *rx_info)
{
uint8_t *pdata;
uint16_t index = 0;
iot_pkt_t *tmp_pkt = NULL;
signal_test_t *signal_info = (signal_test_t*)data;
if (data_len != sizeof(signal_test_t)) {
/* check recv plc data length error */
return ERR_FAIL;
}
if (iot_mac_addr_cmp(signal_info->dst, app_get_mac_addr())) {
/* send plc back */
signal_info->dl_snr = ((recv_info_t*)rx_info)->recv_snr;
signal_info->dl_rssi = ((recv_info_t*)rx_info)->recv_rssi;
app_plc_tx(data, data_len, signal_info->src, ID_PLC_DATA_TEST, NULL);
return ERR_OK;
}
tmp_pkt = iot_pkt_alloc(ATCMD_STR_BUF_LEN, IOT_APP_DEMO_MID);
if (tmp_pkt == NULL) {
APP_PRINTF("[ERR] %s Mem Malloc Failed !!", __FUNCTION__);
return ERR_FAIL;
}
pdata = iot_pkt_data(tmp_pkt);
index += iot_sprintf((char *)pdata, "+SIGNAL:"MAC_FMT",",
MAC_ARG(signal_info->dst));
/* downlink dir msdu recv */
index += iot_sprintf((char *)(pdata + index), "%d,", signal_info->dl_snr);
index += iot_sprintf((char *)(pdata + index), "%d,", signal_info->dl_rssi);
/* uplink dir msdu recv */
signal_info->ul_snr = ((recv_info_t*)rx_info)->recv_snr;
signal_info->ul_rssi = ((recv_info_t*)rx_info)->recv_rssi;
index += iot_sprintf((char *)(pdata + index), "%d,", signal_info->ul_snr);
index += iot_sprintf((char *)(pdata + index), "%d,", signal_info->ul_rssi);
iot_strcat((char *)(pdata), "\r\n\r\n");
index += iot_strlen("\r\n\r\n");
iot_pkt_set_tail(tmp_pkt, pdata + index);
app_cus_task_msg_post(E_CUS_FROM_APPTASK_MSG, APP_CUS_TASK_MSG_ID_FROM_APP,
(void*)tmp_pkt);
return ERR_OK;
}
AT_RET atcmd_send_plc_data_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+SEND=<mac>,<len>,<data>,<format>(0:hex,1:ascii),[send_flag](n)\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_send_plc_nbdata_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+SENDNB=<cco mac>,<len>,<data>,<format>(0:hex,1:ascii)\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_send_plc_data(uint16_t argc, char *argv[])
{
uint8_t *data, send_flag, format = 0;
uint16_t len = 0;
uint16_t data_len = 0;
iot_pkt_t *pkt;
append_tx_info_t tx_info = {0};
uint8_t hex_mac[IOT_MAC_ADDR_LEN] = { 0 };
if (argc < 4) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (ERR_OK != mac_str2hex((char*)argv[1], hex_mac)) {
ATCMD_PRINT("Convert MAC:%s Failed\n", argv[1]);
return AT_RET_ERR;
}
if (iot_atoi_to_uint16(argv[2], &len) || (len > ATCMD_SEND_MAX)) {
AT_RESP("invalid len\r\n\r\n");
return AT_RET_ERR;
}
if (argc == 6) {
if (iot_atoi_to_uint8(argv[5], &send_flag) ||
(send_flag != SEND_FORCE_TYPE_DEF && send_flag != SEND_FORCE_TYPE_CONNLESS
&& send_flag != SEND_FORCE_TYPE_CONNECT)) {
APP_PRINTF("invalid arg %s", argv[5]);
AT_RESP("invalid arg[%d], %s\r\n\r\n", argc - 1, argv[5]);
return AT_RET_ERR;
}
/* use at command argument to set force connless */
tx_info.force_type = send_flag;
}
if (argc >= 5) {
if (iot_atoi_to_uint8(argv[4], &format) ||
(format != 0 && format != 1)) {
AT_RESP("invalid format:%d\r\n\r\n", format);
return AT_RET_ERR;
}
}
if (format == 0) {
/* hex data */
pkt = iot_pkt_alloc(len, IOT_APP_DEMO_MID);
if (pkt == NULL) {
ATCMD_PRINT("Alloc pkt Failed\n");
return AT_RET_ERR;
}
data = iot_pkt_put(pkt, len);
if (0 == string2hex((char *)argv[3], len, data, &data_len)) {
iot_pkt_free(pkt);
ATCMD_PRINT("Convert String Failed\n");
return AT_RET_ERR;
}
app_plc_tx(data, data_len, hex_mac, ID_PLC_AT_DATA, &tx_info);
iot_pkt_free(pkt);
return AT_RET_OK;
} else {
/* string data */
len = min(iot_strlen(argv[3]), len);
app_plc_tx((uint8_t *)argv[3], len, hex_mac, ID_PLC_AT_STRING, &tx_info);
return AT_RET_OK;
}
return AT_RET_OK;
}
AT_RET atcmd_send_plc_data_ex_test(uint16_t argc, char *argv[])
{
AT_RESP("AT+SENDEX=<mac>,<len>\r\n\r\n");
return AT_RET_OK;
}
AT_RET atcmd_send_plc_data_ex(uint16_t argc, char *argv[])
{
uint8_t hex_mac[IOT_MAC_ADDR_LEN] = { 0 }, len = 0;
if (argc < 2) {
AT_RESP("invalid number of args\r\n\r\n");
return AT_RET_ERR;
}
if (ERR_OK != mac_str2hex((char*)argv[1], hex_mac)) {
ATCMD_PRINT("Convert MAC:%s Failed\n", argv[1]);
return AT_RET_ERR;
}
len = iot_atoi(argv[2]);
if (iot_atoi_to_uint8(argv[2], &len) || (len > ATCMD_SEND_MAX)) {
AT_RESP("invalid len\r\n\r\n");
return AT_RET_ERR;
}
//TODO:
app_bypass_set_param(len, hex_mac, 1);
app_timer_start(APP_TIMER_ID_AT_SEND_PLC, APP_TIMER_AT_SEND_PERIOD, TIMER_TYPE_ONCE);
AT_RESP(">");
return AT_RET_NULL;
}
AT_RET atcmd_nf_query(uint16_t argc, char *argv[])
{
uint8_t nf;
nf = iot_plc_get_local_nf();
AT_RESP_EQU("NF","%d\r\n\r\n", nf);
return AT_RET_OK;
}
void app_atcmd_onoffline_rsp(uint8_t *mac, uint8_t flag)
{
if (flag == 1) {
AT_RESP_EQU("ONLINE",""MAC_FMT"\r\n\r\n", MAC_ARG(mac));
} else {
AT_RESP_EQU("OFFLINE",""MAC_FMT"\r\n\r\n", MAC_ARG(mac));
}
return;
}
#if PLC_SUPPORT_CCO_ROLE
static uint16_t app_atcmd_delaytime_rsp(uint8_t *data, uint16_t data_len,
uint8_t * src_addr)
{
uint8_t * pdata, level;
uint16_t i = 0;
uint16_t index = 0;
delay_time_test *rsp_data = (delay_time_test *)data;
uint8_t sn_len = sizeof(rsp_data->sn);
uint8_t time_len = sizeof(uint32_t);
iot_pkt_t *tmp_pkt;
if (data_len > sizeof(delay_time_test)) {
APP_PRINTF("[ERR] %s data len:%d err!!", __FUNCTION__, data_len);
return ERR_FAIL;
}
tmp_pkt = iot_pkt_alloc(sizeof(delay_time_test) + ATCMD_STR_PAD_LEN,
IOT_APP_DEMO_MID);
if (tmp_pkt == NULL) {
APP_PRINTF("[ERR] %s Mem Malloc Failed !!", __FUNCTION__);
return ERR_FAIL;
}
level = iot_plc_cco_query_node_level(src_addr);
pdata = (uint8_t *)iot_pkt_data(tmp_pkt);
index += iot_sprintf((char *)pdata, "+DELAYTIME:"MAC_FMT",",
MAC_ARG(src_addr));
index += iot_sprintf((char *)(pdata + index), "%d,", level);
index += iot_sprintf((char *)(pdata + index), "%d,", rsp_data->sn);
index += iot_sprintf((char *)(pdata + index), "%d,", rsp_data->mcu_tx_time);
iot_data_reverse(&data[sn_len + time_len], time_len);
for (i = sn_len + time_len; i < data_len - sizeof(rsp_data->datalen); i++) {
index += iot_sprintf((char *)(pdata + index), "%02X", data[i]);
if (!((i + 1 - sn_len) % time_len)) {
index += iot_sprintf((char *)(pdata + index), ",");
if (i < data_len - sizeof(rsp_data->datalen) - 1) {
iot_data_reverse(&data[i + 1], time_len);
}
}
}
index += iot_sprintf((char *)(pdata + index), "%d", rsp_data->datalen);
iot_strcat((char *)(pdata), "\r\n\r\n");
iot_pkt_set_tail(tmp_pkt, pdata + index + 4);
APP_PRINT_BUF("[APP_ATCMD_DELAY_TIME]", pdata, index + 4);
app_cus_task_msg_post(E_CUS_FROM_APPTASK_MSG, APP_CUS_TASK_MSG_ID_FROM_APP,
(void*)tmp_pkt);
return ERR_OK;
}
#endif
uint16_t app_atcmd_uart_tx(uint8_t *data, uint16_t data_len,
uint8_t *src_addr, uint8_t format, uint8_t recv_flag)
{
uint16_t i = 0;
uint16_t index = 0;
iot_pkt_t *tmp_pkt;
tmp_pkt = iot_pkt_alloc(ATCMD_STR_BUF_LEN, IOT_APP_DEMO_MID);
if (tmp_pkt == NULL) {
APP_PRINTF("[ERR] %s Mem Malloc Failed !!", __FUNCTION__);
return ERR_FAIL;
}
uint8_t *pdata = (uint8_t *)iot_pkt_data(tmp_pkt);
index += iot_sprintf((char *)pdata, "+RECV:"MAC_FMT",%d,",
MAC_ARG(src_addr), data_len);
if (format == 0) {
for (i = 0; i < data_len; i++) {
index += iot_sprintf((char *)(pdata + index), "%02X", data[i]);
}
} else {
index += iot_sprintf((char *)(pdata + index), "\"");
os_mem_cpy((char *)(pdata + index), (const char *)data, data_len);
index += data_len;
index += iot_sprintf((char *)(pdata + index), "\"");
}
index += iot_sprintf((char *)(pdata + index), ",%d", format);
index += iot_sprintf((char *)(pdata + index), ",%d", recv_flag);
iot_strcat((char *)(pdata), "\r\n\r\n");
iot_pkt_set_tail(tmp_pkt, pdata + index + 4);
APP_PRINT_BUF("[APP_ATCMD_TX_TO_CUS]", pdata, index + 4);
app_cus_task_msg_post(E_CUS_FROM_APPTASK_MSG, APP_CUS_TASK_MSG_ID_FROM_APP,
(void*)tmp_pkt);
pdata = NULL;
return ERR_OK;
}
static const cmd_tbl_t at_cmd_list[] =
{
/****name*********maxargs*****test_cmd*****query_cmd*****setup_cmd*****usage*****is_remote*****************/
{ "AT", 1, atcmd_test, atcmd_test, atcmd_test, atcmd_test, "test cmd", 0 },
/* MANAGEMENT CMD */
{ "AT+HELP", 1, atcmd_help, atcmd_help, NULL, atcmd_help, "get AT help", 1 },
{ "AT+ECHO", 1, atcmd_echo_test, atcmd_echo_query, atcmd_echo_setup, NULL, "open/close uart echo", 0 },
{ "AT+LOG", 1, atcmd_log_test, atcmd_log_query, atcmd_log_setup, NULL, "open/close log output", 1 },
{ "AT+MODE", 1, atcmd_mode_test, atcmd_mode_query, atcmd_mode_setup, NULL, "set/get work mode", 1 },
{ "AT+MAC", 1, atcmd_mac_test, atcmd_mac_query, atcmd_mac_setup, NULL, "set/get mac addr", 1 },
{ "AT+GROUP", 1, atcmd_group_test, atcmd_group_query, atcmd_group_setup, NULL, "set/get group addr", 1 },
{ "AT+MID", 0, NULL, atcmd_mid_query, NULL, NULL, "get mid", 1 },
{ "AT+GMR", 0, NULL, atcmd_gmr_query, NULL, NULL, "get version", 1 },
{ "AT+RESTORE", 0, NULL, NULL, NULL, atcmd_restore_exe, "restore factory settings", 1 },
{ "AT+RST", 0, NULL, NULL, NULL, atcmd_reset_exe, "reboot", 1 },
{ "AT+UART", 4, atcmd_uart_test, atcmd_uart_query, atcmd_uart_setup, NULL, "set/get uart parameter", 1 },
{ "AT+NID", 1, atcmd_nid_test, atcmd_nid_query, atcmd_nid_setup, NULL, "set/get nid", 1 },
{ "AT+TEIINFO", 1, NULL, atcmd_tei_info_query, NULL, NULL, "get tei info", 1 },
{ "AT+CALC", 0, NULL, atcmd_calc_validity_query, NULL, NULL, "get board calc data validity", 0 },
#if APP_IO_OPERATION_ENABLE
{ "AT+IOPARAM", 6, atcmd_io_param_test, atcmd_io_param_query, atcmd_io_param_setup, NULL, "set/get gpio init param", 1 },
{ "AT+IOCTRL", 3, atcmd_io_ctrl_test, NULL, atcmd_io_ctrl, NULL, "cco control sta's gpio", 0 },
{ "AT+PWM", 0, atcmd_pwm_test, NULL, atcmd_pwm_setup, NULL, "output pwm", 1 },
#endif /* end APP_IO_OPERATION_ENABLE */
#if PLC_SUPPORT_STA_ROLE
{ "AT+CCOMAC", 1, NULL, atcmd_cco_mac_query, NULL, NULL, "get cco mac", 1 },
{ "AT+LOCKMAC", 1, atcmd_mac_lock_test, atcmd_mac_lock_query, atcmd_mac_lock_setup, NULL, "set lock mac", 1 },
{ "AT+SCANBAND", 2, atcmd_scan_band_test, atcmd_scan_band_query, atcmd_scan_band_setup, NULL, "set/get scan freq band", 1 },
#endif
#if PLC_SUPPORT_CCO_ROLE
{ "AT+TOPONUM", 0, NULL, atcmd_toponum_query, NULL, NULL, "get topo num", 0 },
{ "AT+TOPOINFO", 2, atcmd_topoinfo_test, NULL, atcmd_topoinfo_query, NULL, "get topo info", 0 },
{ "AT+WHNUM", 0, NULL, atcmd_whitelist_num_query, NULL, NULL, "get whitelist num", 0 },
{ "AT+WHINFO", 2, atcmd_whitelist_info_test, NULL, atcmd_whitelist_info_query, NULL, "get whitelist info", 0 },
{ "AT+WHADD", 2, atcmd_whitelist_add_test, NULL, atcmd_whitelist_add_setup, NULL, "add whitelist node", 0 },
{ "AT+WHDEL", 2, atcmd_whitelist_delete_test, NULL, atcmd_whitelist_delete_setup, NULL, "delete whitelist node", 0 },
{ "AT+WHCLR", 0, NULL, NULL, NULL, atcmd_whitelist_clear_exe, "clear whitelist", 0 },
{ "AT+WHSTATUS", 1, atcmd_whitelist_status_test, atcmd_whitelist_status_query, atcmd_whitelist_status_setup, NULL, "get/set whitelist state", 0 },
{ "AT+IDFSTATUS", 1, atcmd_network_idf_status_test, atcmd_network_idf_status_query, atcmd_network_idf_status_setup, NULL, "enable/disable network idf status", 0 },
{ "AT+REMOTE", 2, atcmd_remote_test, NULL, atcmd_remote_setup, NULL, "remote cmd", 0 },
{ "AT+DELAYTIME", 3, NULL, NULL, atcmd_delay_time_test, NULL, "communication delay time test", 0 },
{ "AT+BAND", 1, atcmd_band_test, atcmd_band_query, atcmd_band_setup, NULL, "set/get freq band", 0 },
{ "AT+UPGRADE", 1, atcmd_upgrade_test, NULL, atcmd_upgrade_setup, NULL, "upgrade cmd's", 0 },
{ "AT+BCAST", 7, atcmd_bcast_test, atcmd_bcast_query, atcmd_bcast_setup, NULL, "set/get period bacst", 0},
#endif
{ "AT+SIGNAL", 2, atcmd_signal_test, NULL, atcmd_signal_setup, NULL, "query loop snr rssi cmd", 0 },
{ "AT+NBNET", 0, NULL, atcmd_nbnet_query, NULL, NULL, "get nbnet info", 0},
{ "AT+NOTIFY", 1, atcmd_notify_test, atcmd_notify_query, atcmd_notify_setup, NULL, "set notify msg", 1 },
{ "AT+SEND", 4, atcmd_send_plc_data_test, NULL, atcmd_send_plc_data, NULL, "send plc data to cco/sta", 0 },
{ "AT+SENDNB", 4, atcmd_send_plc_nbdata_test, NULL, atcmd_send_plc_data, NULL, "send plc data to nbnet", 0 },
//{ "AT+SENDEX", 2, atcmd_send_plc_data_ex_test, NULL, atcmd_send_plc_data_ex, NULL, "send plc data to cco/sta", 0 },
{ "AT+TXPWR", 2, atcmd_txpwr_test, atcmd_txpwr_query, atcmd_txpwr_setup, NULL, "set/get tx power", 1 },
{ "AT+NET", 1, NULL, atcmd_net_set_query, atcmd_net_set_setup, NULL, "set/get network", 0},
{ "AT+NFGET", 0, NULL, atcmd_nf_query, NULL, NULL, "get local noise floor", 0},
{ "AT+EXIT", 0, NULL, NULL, NULL, atcmd_exit_exe, "exit AT mode", 0 },
};
static uint16_t get_atcmd_table_size(void)
{
return sizeof(at_cmd_list) / sizeof(cmd_tbl_t);
}
static cmd_tbl_t *get_atcmd_by_index(uint16_t index)
{
if (index < get_atcmd_table_size()) {
return (cmd_tbl_t*)&at_cmd_list[index];
} else {
return NULL;
}
}
cmd_tbl_t *atcmd_find_cmd(char *cmd)
{
uint16_t i;
uint16_t atcmd_list_len = get_atcmd_table_size();
uint32_t len = iot_strlen(cmd);
cmd_tbl_t *cmd_tbl = NULL;
for (i = 0; i < atcmd_list_len; i++) {
cmd_tbl = get_atcmd_by_index(i);
if (cmd_tbl && (0 == iot_strcmp(cmd_tbl->name, cmd)) &&
(len == iot_strlen(cmd_tbl->name))) {
return cmd_tbl;
}
}
return NULL; /* not found or ambiguous command */
}
void app_atcmd_init(void)
{
if (APP_WORK_MODE_AT == app_get_work_mode()) {
AT_RESP("+READY\r\n\r\n");
}
return;
}
Reference in New Issue View Git Blame Copy Permalink