mirror of
https://github.com/jialexd/sdk-ameba-v4.0c_180328.git
synced 2024-11-01 11:54:17 +00:00
589 lines
16 KiB
C
Executable file
589 lines
16 KiB
C
Executable file
/******************************************************************************
|
|
*
|
|
* Copyright(c) 2007 - 2015 Realtek Corporation. All rights reserved.
|
|
*
|
|
*
|
|
******************************************************************************/
|
|
#include <platform_opts.h>
|
|
#include "FreeRTOS.h"
|
|
#include "task.h"
|
|
#include <platform/platform_stdlib.h>
|
|
#include "semphr.h"
|
|
#include "device.h"
|
|
#include "serial_api.h"
|
|
#include "at_cmd/log_service.h"
|
|
#include "uart_atcmd/example_uart_atcmd.h"
|
|
#include "flash_api.h"
|
|
#include "device_lock.h"
|
|
#if defined(configUSE_WAKELOCK_PMU) && (configUSE_WAKELOCK_PMU == 1)
|
|
#include "freertos_pmu.h"
|
|
#endif
|
|
#include "osdep_service.h"
|
|
#include "serial_ex_api.h"
|
|
#include "at_cmd/atcmd_wifi.h"
|
|
#include "at_cmd/atcmd_lwip.h"
|
|
#include "pinmap.h"
|
|
|
|
#if CONFIG_EXAMPLE_UART_ATCMD
|
|
|
|
typedef int (*init_done_ptr)(void);
|
|
extern init_done_ptr p_wlan_init_done_callback;
|
|
extern char log_buf[LOG_SERVICE_BUFLEN];
|
|
extern xSemaphoreHandle log_rx_interrupt_sema;
|
|
extern void serial_rx_fifo_level(serial_t *obj, SerialFifoLevel FifoLv);
|
|
extern int atcmd_wifi_restore_from_flash(void);
|
|
extern int atcmd_lwip_restore_from_flash(void);
|
|
|
|
serial_t at_cmd_sobj;
|
|
char at_string[ATSTRING_LEN];
|
|
//_sema at_printf_sema;
|
|
_sema uart_at_dma_tx_sema;
|
|
unsigned char gAT_Echo = 1; // default echo on
|
|
|
|
#define UART_AT_MAX_DELAY_TIME_MS 20
|
|
|
|
#define UART_AT_DATA UART_SETTING_SECTOR
|
|
#define BACKUP_SECTOR FLASH_SYSTEM_DATA_ADDR-0x1000
|
|
|
|
#define UART_AT_USE_DMA_TX 0
|
|
|
|
void atcmd_update_partition_info(AT_PARTITION id, AT_PARTITION_OP ops, u8 *data, u16 len){
|
|
flash_t flash;
|
|
int size, offset, i;
|
|
u32 read_data;
|
|
|
|
switch(id){
|
|
case AT_PARTITION_UART:
|
|
size = UART_CONF_DATA_SIZE;
|
|
offset = UART_CONF_DATA_OFFSET;
|
|
break;
|
|
case AT_PARTITION_WIFI:
|
|
size = WIFI_CONF_DATA_SIZE;
|
|
offset = WIFI_CONF_DATA_OFFSET;
|
|
break;
|
|
case AT_PARTITION_LWIP:
|
|
size = LWIP_CONF_DATA_SIZE;
|
|
offset = LWIP_CONF_DATA_OFFSET;
|
|
break;
|
|
case AT_PARTITION_ALL:
|
|
size = 0x1000;
|
|
offset = 0;
|
|
break;
|
|
default:
|
|
printf("partition id is invalid!\r\n");
|
|
return;
|
|
}
|
|
|
|
device_mutex_lock(RT_DEV_LOCK_FLASH);
|
|
|
|
if(id == AT_PARTITION_ALL && ops == AT_PARTITION_ERASE){
|
|
flash_erase_sector(&flash, UART_SETTING_SECTOR);
|
|
goto exit;
|
|
}
|
|
|
|
if(ops == AT_PARTITION_READ){
|
|
flash_stream_read(&flash, UART_SETTING_SECTOR+offset, len, data);
|
|
goto exit;
|
|
}
|
|
|
|
//erase BACKUP_SECTOR
|
|
flash_erase_sector(&flash, UART_SETTING_BACKUP_SECTOR);
|
|
|
|
if(ops == AT_PARTITION_WRITE){
|
|
// backup new data
|
|
flash_stream_write(&flash, UART_SETTING_BACKUP_SECTOR+offset, len, data);
|
|
}
|
|
|
|
//backup front data to backup sector
|
|
for(i = 0; i < offset; i += sizeof(read_data)){
|
|
flash_read_word(&flash, UART_SETTING_SECTOR + i, &read_data);
|
|
flash_write_word(&flash, UART_SETTING_BACKUP_SECTOR + i,read_data);
|
|
}
|
|
|
|
//backup rear data
|
|
for(i = (offset + size); i < 0x1000; i += sizeof(read_data)){
|
|
flash_read_word(&flash, UART_SETTING_SECTOR + i, &read_data);
|
|
flash_write_word(&flash, UART_SETTING_BACKUP_SECTOR + i,read_data);
|
|
}
|
|
|
|
//erase UART_SETTING_SECTOR
|
|
flash_erase_sector(&flash, UART_SETTING_SECTOR);
|
|
|
|
//retore data to UART_SETTING_SECTOR from UART_SETTING_BACKUP_SECTOR
|
|
for(i = 0; i < 0x1000; i+= sizeof(read_data)){
|
|
flash_read_word(&flash, UART_SETTING_BACKUP_SECTOR + i, &read_data);
|
|
flash_write_word(&flash, UART_SETTING_SECTOR + i,read_data);
|
|
}
|
|
|
|
//erase BACKUP_SECTOR
|
|
flash_erase_sector(&flash, UART_SETTING_BACKUP_SECTOR);
|
|
|
|
exit:
|
|
device_mutex_unlock(RT_DEV_LOCK_FLASH);
|
|
return;
|
|
}
|
|
|
|
int read_uart_atcmd_setting_from_system_data(UART_LOG_CONF* uartconf)
|
|
{
|
|
// flash_t flash;
|
|
UART_LOG_CONF conf;
|
|
bool load_default = _TRUE;
|
|
|
|
// device_mutex_lock(RT_DEV_LOCK_FLASH);
|
|
// flash_stream_read(&flash, UART_AT_DATA,sizeof(UART_LOG_CONF), (u8 *)&conf);
|
|
atcmd_update_partition_info(AT_PARTITION_UART, AT_PARTITION_READ, (u8 *)&conf, sizeof(UART_LOG_CONF));
|
|
do{
|
|
if(conf.FlowControl != DISABLE && conf.FlowControl != ENABLE)
|
|
break;
|
|
|
|
if(conf.DataBits != 5
|
|
&& conf.DataBits != 6
|
|
&& conf.DataBits != 7
|
|
&& conf.DataBits != 8) //5, 6, 7, 8
|
|
break;
|
|
|
|
if(conf.Parity != ParityNone && conf.Parity != ParityOdd && conf.Parity != ParityEven)
|
|
break;
|
|
|
|
if(conf.StopBits != 1 && conf.StopBits != 2)
|
|
break;
|
|
|
|
load_default = _FALSE;
|
|
}while(0);
|
|
|
|
if(load_default == _TRUE){
|
|
// load default setting
|
|
uartconf->BaudRate = 38400;
|
|
uartconf->DataBits = 8;
|
|
uartconf->Parity = ParityNone;
|
|
uartconf->StopBits = 1;
|
|
uartconf->FlowControl = DISABLE;
|
|
}
|
|
else{
|
|
uartconf->BaudRate = conf.BaudRate;
|
|
uartconf->DataBits = conf.DataBits;
|
|
uartconf->Parity = conf.Parity;
|
|
uartconf->StopBits = conf.StopBits;
|
|
uartconf->FlowControl = conf.FlowControl;
|
|
}
|
|
// device_mutex_unlock(RT_DEV_LOCK_FLASH);
|
|
printf("\r\nAT_UART_CONF: %d,%d,%d,%d,%d\r\n",
|
|
uartconf->BaudRate,
|
|
uartconf->DataBits,
|
|
uartconf->StopBits,
|
|
uartconf->Parity,
|
|
uartconf->FlowControl);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int write_uart_atcmd_setting_to_system_data(UART_LOG_CONF* uartconf)
|
|
{
|
|
#if 0
|
|
flash_t flash;
|
|
|
|
u8 data1[sizeof(UART_LOG_CONF)];
|
|
u8 data2[sizeof(UART_LOG_CONF)];
|
|
|
|
u32 data,i;
|
|
|
|
rtw_memset(data2, 0xFF, sizeof(UART_LOG_CONF));
|
|
|
|
//Get upgraded image 2 addr from offset
|
|
device_mutex_lock(RT_DEV_LOCK_FLASH);
|
|
flash_stream_read(&flash, UART_AT_DATA,sizeof(UART_LOG_CONF), data1);
|
|
|
|
if(rtw_memcmp(data1,data2,sizeof(UART_LOG_CONF)) == _TRUE){
|
|
flash_stream_write(&flash, UART_AT_DATA, sizeof(UART_LOG_CONF),(u8*)uartconf);
|
|
}else{
|
|
//erase backup sector
|
|
flash_erase_sector(&flash, BACKUP_SECTOR);
|
|
|
|
// backup log uart configuration
|
|
flash_stream_write(&flash, BACKUP_SECTOR, sizeof(UART_LOG_CONF),(u8*)uartconf);
|
|
|
|
//backup system data to backup sector
|
|
for(i = sizeof(UART_LOG_CONF); i < 0x1000; i+= 4){
|
|
flash_read_word(&flash, UART_AT_DATA + i, &data);
|
|
flash_write_word(&flash, BACKUP_SECTOR + i,data);
|
|
}
|
|
//erase system data
|
|
flash_erase_sector(&flash, UART_AT_DATA);
|
|
//write data back to system data
|
|
for(i = 0; i < 0x1000; i+= 4){
|
|
flash_read_word(&flash, BACKUP_SECTOR + i, &data);
|
|
flash_write_word(&flash, UART_AT_DATA + i,data);
|
|
}
|
|
//erase backup sector
|
|
flash_erase_sector(&flash, BACKUP_SECTOR);
|
|
}
|
|
device_mutex_unlock(RT_DEV_LOCK_FLASH);
|
|
#else
|
|
atcmd_update_partition_info(AT_PARTITION_UART, AT_PARTITION_WRITE, (u8 *)uartconf, sizeof(UART_LOG_CONF));
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
int reset_uart_atcmd_setting(){
|
|
#if 0
|
|
flash_t flash;
|
|
|
|
u8 data1[sizeof(UART_LOG_CONF)];
|
|
u8 data2[sizeof(UART_LOG_CONF)];
|
|
|
|
u32 data,i;
|
|
|
|
rtw_memset(data2, 0xFF, sizeof(UART_LOG_CONF));
|
|
|
|
//Get upgraded image 2 addr from offset
|
|
device_mutex_lock(RT_DEV_LOCK_FLASH);
|
|
flash_stream_read(&flash, UART_AT_DATA,sizeof(UART_LOG_CONF), data1);
|
|
|
|
if(rtw_memcmp(data1,data2,sizeof(UART_LOG_CONF)) == _TRUE){
|
|
;
|
|
}else{
|
|
//erase backup sector
|
|
flash_erase_sector(&flash, BACKUP_SECTOR);
|
|
|
|
// erase uart configuration
|
|
flash_stream_write(&flash, BACKUP_SECTOR, sizeof(UART_LOG_CONF),(u8*)data2);
|
|
//backup system data to backup sector
|
|
for(i = sizeof(UART_LOG_CONF); i < 0x1000; i+= 4){
|
|
flash_read_word(&flash, UART_AT_DATA + i, &data);
|
|
flash_write_word(&flash, BACKUP_SECTOR + i,data);
|
|
}
|
|
//erase system data
|
|
flash_erase_sector(&flash, UART_AT_DATA);
|
|
//write data back to system data
|
|
for(i = 0; i < 0x1000; i+= 4){
|
|
flash_read_word(&flash, BACKUP_SECTOR + i, &data);
|
|
flash_write_word(&flash, UART_AT_DATA + i,data);
|
|
}
|
|
//erase backup sector
|
|
flash_erase_sector(&flash, BACKUP_SECTOR);
|
|
}
|
|
device_mutex_unlock(RT_DEV_LOCK_FLASH);
|
|
#else
|
|
atcmd_update_partition_info(AT_PARTITION_ALL, AT_PARTITION_ERASE, NULL, 0);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
#if ATCMD_RX_GPIO_WAKEUP
|
|
#if defined(configUSE_WAKELOCK_PMU) && (configUSE_WAKELOCK_PMU == 1)
|
|
#include "gpio_irq_api.h"
|
|
#define UART_AT_RX_WAKE UART_RX
|
|
void gpio_uart_at_rx_irq_callback (uint32_t id, gpio_irq_event event)
|
|
{
|
|
/* PMU_LOGUART_DEVICE is also handled in log service.
|
|
* It is release after a complete command is sent.
|
|
**/
|
|
//pmu_acquire_wakelock(BIT(PMU_LOGUART_DEVICE));
|
|
}
|
|
|
|
void uart_at_rx_wakeup()
|
|
{
|
|
gpio_irq_t gpio_rx_wake;
|
|
gpio_irq_init(&gpio_rx_wake, UART_AT_RX_WAKE, gpio_uart_at_rx_irq_callback, NULL);
|
|
gpio_irq_set(&gpio_rx_wake, IRQ_FALL, 1); // Falling Edge Trigger
|
|
gpio_irq_enable(&gpio_rx_wake);
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
void uart_atcmd_reinit(UART_LOG_CONF* uartconf){
|
|
serial_baud(&at_cmd_sobj,uartconf->BaudRate);
|
|
serial_format(&at_cmd_sobj, uartconf->DataBits, (SerialParity)uartconf->Parity, uartconf->StopBits);
|
|
|
|
// set flow control, only support RTS and CTS concurrent mode
|
|
// rxflow and tx flow is fixed by hardware
|
|
#define rxflow UART_RTS
|
|
#define txflow UART_CTS
|
|
if(uartconf->FlowControl){
|
|
pin_mode(txflow, PullDown); //init CTS in low
|
|
serial_set_flow_control(&at_cmd_sobj, FlowControlRTSCTS, rxflow, txflow);
|
|
}
|
|
else
|
|
serial_set_flow_control(&at_cmd_sobj, FlowControlNone, rxflow, txflow);
|
|
}
|
|
|
|
void uart_at_send_string(char *str)
|
|
{
|
|
unsigned int i=0;
|
|
while (str[i] != '\0') {
|
|
serial_putc(&at_cmd_sobj, str[i]);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
#if UART_AT_USE_DMA_TX
|
|
static void uart_at_send_buf_done(uint32_t id)
|
|
{
|
|
//serial_t *sobj = (serial_t *)id;
|
|
|
|
rtw_up_sema_from_isr(&uart_at_dma_tx_sema);
|
|
}
|
|
#endif
|
|
|
|
void uart_at_send_buf(u8 *buf, u32 len)
|
|
{
|
|
unsigned char *st_p=buf;
|
|
if(!len || (!buf)){
|
|
return;
|
|
}
|
|
#if UART_AT_USE_DMA_TX
|
|
int ret;
|
|
while(rtw_down_sema(&uart_at_dma_tx_sema) == _TRUE){
|
|
ret = serial_send_stream_dma(&at_cmd_sobj, st_p, len);
|
|
if(ret != HAL_OK){
|
|
rtw_up_sema(&uart_at_dma_tx_sema);
|
|
return;
|
|
}else{
|
|
return;
|
|
}
|
|
}
|
|
#else
|
|
while(len){
|
|
serial_putc(&at_cmd_sobj, *st_p);
|
|
st_p++;
|
|
len--;
|
|
}
|
|
#endif
|
|
}
|
|
/*
|
|
void uart_at_lock(void)
|
|
{
|
|
rtw_down_sema(&at_printf_sema);
|
|
}
|
|
|
|
void uart_at_unlock(void)
|
|
{
|
|
rtw_up_sema(&at_printf_sema);
|
|
}
|
|
|
|
void uart_at_lock_init(){
|
|
rtw_init_sema(&at_printf_sema, 1);
|
|
}
|
|
*/
|
|
void uart_irq(uint32_t id, SerialIrq event)
|
|
{
|
|
serial_t *sobj = (serial_t *)id;
|
|
unsigned char rc=0;
|
|
static unsigned char temp_buf[LOG_SERVICE_BUFLEN] = "\0";
|
|
static unsigned int buf_count = 0;
|
|
static unsigned char combo_key = 0;
|
|
static u32 last_tickcnt = 0; //to check if any data lost
|
|
static bool is_data_cmd = _FALSE; // to mark if it's a data command
|
|
static u32 data_sz = 0, data_cmd_sz =0; // command will send to log handler until "data_cmd_sz" characters are received
|
|
|
|
if(event == RxIrq) {
|
|
rc = serial_getc(sobj);
|
|
|
|
if(atcmd_lwip_is_tt_mode()){
|
|
if(atcmd_lwip_tt_datasize < LOG_SERVICE_BUFLEN){
|
|
log_buf[atcmd_lwip_tt_datasize++] = rc;
|
|
atcmd_lwip_tt_lasttickcnt = xTaskGetTickCountFromISR();
|
|
}else{
|
|
//log_buf is overflow, the following data is drop here
|
|
}
|
|
if(atcmd_lwip_tt_datasize == 1)
|
|
rtw_up_sema_from_isr(&atcmd_lwip_tt_sema);
|
|
return;
|
|
}
|
|
|
|
if(buf_count == 4){
|
|
// if this is a data command with hex data, then '\n' should not be treated
|
|
// as the end of command
|
|
if(strncmp(temp_buf, "ATPT", C_NUM_AT_CMD)==0){
|
|
is_data_cmd = _TRUE;
|
|
}
|
|
}
|
|
if(buf_count > C_NUM_AT_CMD && is_data_cmd == _TRUE){
|
|
if(data_cmd_sz == 0){
|
|
if(data_sz == 0){
|
|
if(rc == ','){
|
|
//first delimeter, ATxx=[sz],....
|
|
char str[10]={0};
|
|
char size_pos = C_NUM_AT_CMD + C_NUM_AT_CMD_DLT;
|
|
memcpy(str, &temp_buf[size_pos], buf_count-size_pos);
|
|
data_sz = atoi(str); //get data size
|
|
}
|
|
}else{
|
|
if(rc == ':'){ //data will start after this delimeter ':'
|
|
strncpy(log_buf, (char *)temp_buf, buf_count);
|
|
rtw_memset(temp_buf,'\0',buf_count);
|
|
last_tickcnt = xTaskGetTickCountFromISR();
|
|
data_cmd_sz = buf_count + 1 + data_sz;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(data_cmd_sz){
|
|
if((!gAT_Echo) && (rtw_systime_to_ms(xTaskGetTickCountFromISR() - last_tickcnt) > UART_AT_MAX_DELAY_TIME_MS)){
|
|
uart_at_send_string("\r\nERROR: data timeout\r\n\n# ");
|
|
memset(log_buf, 0, buf_count);
|
|
is_data_cmd = _FALSE;
|
|
data_sz = 0;
|
|
data_cmd_sz = 0;
|
|
buf_count=0;
|
|
last_tickcnt = 0;
|
|
return;
|
|
}
|
|
last_tickcnt = xTaskGetTickCountFromISR();
|
|
log_buf[buf_count++]=rc;
|
|
if(gAT_Echo == 1){
|
|
serial_putc(sobj, rc);
|
|
}
|
|
if(buf_count >= data_cmd_sz){
|
|
log_buf[data_cmd_sz - data_sz - 1] = '\0'; //for log service handler parse to get command parameter, replace ":" with "\0"
|
|
is_data_cmd = _FALSE;
|
|
data_sz = 0;
|
|
data_cmd_sz = 0;
|
|
buf_count=0;
|
|
last_tickcnt = 0;
|
|
rtw_up_sema_from_isr(&log_rx_interrupt_sema);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (rc == KEY_ESC) {
|
|
combo_key = 1;
|
|
}
|
|
else if (combo_key == 1){
|
|
if (rc == KEY_LBRKT) {
|
|
combo_key = 2;
|
|
}
|
|
else{
|
|
combo_key = 0;
|
|
}
|
|
}
|
|
else if (combo_key == 2){
|
|
//if ((rc=='A')|| rc=='B'){//up and down
|
|
//}
|
|
combo_key=0;
|
|
}
|
|
else if(rc == KEY_ENTER){
|
|
if(buf_count>0){
|
|
rtw_memset(log_buf,'\0',LOG_SERVICE_BUFLEN);
|
|
strncpy(log_buf,(char *)&temp_buf[0],buf_count);
|
|
rtw_up_sema_from_isr(&log_rx_interrupt_sema);
|
|
rtw_memset(temp_buf,'\0',buf_count);
|
|
is_data_cmd = _FALSE;
|
|
data_sz = 0;
|
|
data_cmd_sz = 0;
|
|
buf_count=0;
|
|
last_tickcnt = 0;
|
|
}else{
|
|
uart_at_send_string(STR_END_OF_ATCMD_RET);
|
|
}
|
|
}
|
|
else if(rc == KEY_BS){
|
|
if(buf_count>0){
|
|
buf_count--;
|
|
temp_buf[buf_count] = '\0';
|
|
if(gAT_Echo == 1){
|
|
serial_putc(sobj, rc);
|
|
serial_putc(sobj, ' ');
|
|
serial_putc(sobj, rc);
|
|
}
|
|
}
|
|
}
|
|
else{
|
|
// skip characters until "A"
|
|
if((buf_count == 0) && (rc != 'A')){
|
|
// some consoles send "\r\n" for enter,
|
|
//so skip '\n' here to prevent ERROR message each time it sends command
|
|
if(gAT_Echo == 1 && rc != KEY_NL){
|
|
uart_at_send_string("\r\nERROR:command should start with 'A'"STR_END_OF_ATCMD_RET);
|
|
}
|
|
return;
|
|
}
|
|
if(buf_count < (LOG_SERVICE_BUFLEN - 1)){
|
|
temp_buf[buf_count] = rc;
|
|
buf_count++;
|
|
if(gAT_Echo == 1){
|
|
serial_putc(sobj, rc);
|
|
}
|
|
}
|
|
else if(buf_count == (LOG_SERVICE_BUFLEN - 1)){
|
|
temp_buf[buf_count] = '\0';
|
|
if(gAT_Echo == 1){
|
|
uart_at_send_string("\r\nERROR:exceed size limit"STR_END_OF_ATCMD_RET);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void uart_atcmd_main(void)
|
|
{
|
|
UART_LOG_CONF uartconf;
|
|
|
|
read_uart_atcmd_setting_from_system_data(&uartconf);
|
|
|
|
serial_init(&at_cmd_sobj,UART_TX,UART_RX);
|
|
serial_baud(&at_cmd_sobj,uartconf.BaudRate);
|
|
serial_format(&at_cmd_sobj, uartconf.DataBits, (SerialParity)uartconf.Parity, uartconf.StopBits);
|
|
serial_rx_fifo_level(&at_cmd_sobj, FifoLvHalf);
|
|
// set flow control, only support RTS and CTS concurrent mode
|
|
// rxflow and tx flow is fixed by hardware
|
|
#define rxflow UART_RTS
|
|
#define txflow UART_CTS
|
|
if(uartconf.FlowControl){
|
|
pin_mode(txflow, PullDown); //init CTS in low
|
|
serial_set_flow_control(&at_cmd_sobj, FlowControlRTSCTS, rxflow, txflow);
|
|
}
|
|
else
|
|
serial_set_flow_control(&at_cmd_sobj, FlowControlNone, rxflow, txflow);
|
|
|
|
/*uart_at_lock_init();*/
|
|
|
|
#if UART_AT_USE_DMA_TX
|
|
rtw_init_sema(&uart_at_dma_tx_sema, 1);
|
|
#endif
|
|
|
|
#if UART_AT_USE_DMA_TX
|
|
serial_send_comp_handler(&at_cmd_sobj, (void*)uart_at_send_buf_done, (uint32_t)&at_cmd_sobj);
|
|
#endif
|
|
|
|
serial_irq_handler(&at_cmd_sobj, uart_irq, (uint32_t)&at_cmd_sobj);
|
|
serial_irq_set(&at_cmd_sobj, RxIrq, 1);
|
|
|
|
#if ATCMD_RX_GPIO_WAKEUP
|
|
#if defined(configUSE_WAKELOCK_PMU) && (configUSE_WAKELOCK_PMU == 1)
|
|
uart_at_rx_wakeup();
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
static void uart_atcmd_thread(void *param)
|
|
{
|
|
p_wlan_init_done_callback = NULL;
|
|
atcmd_wifi_restore_from_flash();
|
|
atcmd_lwip_restore_from_flash();
|
|
rtw_msleep_os(20);
|
|
uart_atcmd_main();
|
|
at_printf("\r\nAT COMMAND READY");
|
|
if(atcmd_lwip_is_tt_mode())
|
|
at_printf(STR_END_OF_ATDATA_RET);
|
|
else
|
|
at_printf(STR_END_OF_ATCMD_RET);
|
|
_AT_DBG_MSG(AT_FLAG_COMMON, AT_DBG_ALWAYS, STR_END_OF_ATCMD_RET);
|
|
vTaskDelete(NULL);
|
|
}
|
|
|
|
int uart_atcmd_module_init(void){
|
|
if(xTaskCreate(uart_atcmd_thread, ((const char*)"uart_atcmd_thread"), 1024, NULL, tskIDLE_PRIORITY+1 , NULL) != pdPASS)
|
|
printf("\n\r%s xTaskCreate(uart_atcmd_thread) failed", __FUNCTION__);
|
|
return 0;
|
|
}
|
|
|
|
void example_uart_atcmd(void)
|
|
{
|
|
//if(xTaskCreate(uart_atcmd_thread, ((const char*)"uart_atcmd_thread"), 1024, NULL, tskIDLE_PRIORITY + 1 , NULL) != pdPASS)
|
|
// printf("\n\r%s xTaskCreate(uart_atcmd_thread) failed", __FUNCTION__);
|
|
p_wlan_init_done_callback = uart_atcmd_module_init;
|
|
return;
|
|
}
|
|
#endif
|