添加 atsrv_socket 代码

.gitignore

@@ -0,0 +1,52 @@
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf

SConscript

@@ -0,0 +1,51 @@
+from building import *
+
+cwd  = GetCurrentDir()
+src  = Glob('*.c')
+path = [cwd + '/inc']
+
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_SYSRAM']):
+    src += Glob('src/base/at_mem.c')
+	
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_GMR']):
+    src += Glob('src/base/at_version.c')	
+
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_CIPDOMAIN']):
+    src += Glob('src/ip/at_ipdns.c')
+
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_CIPMUX']):
+    src += Glob('src/ip/at_ipmode.c')
+
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_PING']):
+    src += Glob('src/ip/at_ipping.c')
+
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_CIPSEND']):
+    src += Glob('src/ip/at_ipsend.c')
+
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_CIPSTART']):
+    src += Glob('src/ip/at_ipstart.c')
+
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_CIPSTATUS']):
+    src += Glob('src/ip/at_ipstatus.c')
+
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_CIPCLOSE']):
+    src += Glob('src/ip/at_ipstop.c')
+
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_OTA']):
+    src += Glob('src/ota/at_ota.c')
+
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_CWJAP']):
+    src += Glob('src/wifi/at_connect.c')
+
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_CWQAP']):
+    src += Glob('src/wifi/at_disconnect.c')
+
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_CWMODE']):
+    src += Glob('src/wifi/at_mode.c')
+
+if GetDepend(['ATSRV_SOCKET_ENABLE_CMD_CWLAP']):
+    src += Glob('src/wifi/at_scan.c')
+	
+group = DefineGroup('atsrv_socket', src, depend = ['PKG_USING_ATSRV_SOCKET'], CPPPATH = path)
+
+Return('group')

src/base/at_mem.c

@@ -0,0 +1,12 @@
+#include <at.h>
+
+static at_result_t at_sysram_exec(void)
+{
+    rt_uint32_t total,used;
+
+    rt_memory_info(&total, &used, RT_NULL);
+    at_server_printfln("+SYSRAM:%d", total - used);
+    return AT_RESULT_OK;
+}
+
+AT_CMD_EXPORT("AT+SYSRAM", NULL, NULL, NULL, NULL, at_sysram_exec);

src/base/at_version.c

@@ -0,0 +1,11 @@
+#include <at.h>
+#define AT_VERSION "0.0.3"
+
+static at_result_t at_version_exec(void)
+{
+    at_server_printfln(AT_VERSION);
+    at_server_printfln("%s %s", __DATE__, __TIME__);
+    return AT_RESULT_OK;
+}
+
+AT_CMD_EXPORT("AT+GMR", NULL, NULL, NULL, NULL, at_version_exec);

src/ip/at_ipdns.c

@@ -0,0 +1,32 @@
+#include <at.h>
+#include <netdb.h>
+#include <sys/socket.h>
+
+static at_result_t at_ipdns_setup(const char *args)
+{
+    char domain[128];
+    struct hostent* host_info;
+    int i = 0;
+    if(at_req_parse_args(args, "=%*[\"]%[^\"]%*[\"]", domain) > 0)
+    {
+        host_info = gethostbyname(domain);
+        if(host_info == NULL)
+        {
+            at_server_printfln("DNS Fail");
+            return AT_RESULT_FAILE;
+        }
+        while(host_info->h_addr_list[i] != NULL)
+        {
+            at_server_printfln("+CIPDOMAIN:%s", inet_ntoa(*(struct in_addr*)host_info->h_addr_list[i]));
+            i++;
+        }
+        
+    }
+    else
+    {
+        return AT_RESULT_PARSE_FAILE;
+    }
+    return AT_RESULT_OK;
+}
+
+AT_CMD_EXPORT("AT+CIPDOMAIN", "=<domain name>", NULL, NULL, at_ipdns_setup, NULL);

src/ip/at_ipmode.c

@@ -0,0 +1,25 @@
+#include <at.h>
+
+int ipmode = 0;
+
+static at_result_t at_ipmode_query(void)
+{
+    at_server_printfln("+CIPMUX:%d", ipmode);
+    return AT_RESULT_OK;
+}
+
+extern int msh_exec(char *cmd, rt_size_t length);
+static at_result_t at_ipmode_setup(const char *args)
+{
+    if(at_req_parse_args(args, "=%d", &ipmode) > 0)
+    {
+        
+    }
+    else
+    {
+        return AT_RESULT_PARSE_FAILE;
+    }
+    return AT_RESULT_OK;
+}
+
+AT_CMD_EXPORT("AT+CIPMUX", "=<mode>", NULL, at_ipmode_query, at_ipmode_setup, NULL);

src/ip/at_ipping.c

@@ -0,0 +1,26 @@
+#include <at.h>
+#include <netdb.h>
+#include <sys/socket.h>
+
+extern rt_err_t at_ping(char* target_name, rt_size_t size);
+static at_result_t at_ipping_setup(const char *args)
+{
+    char domain[128];
+    struct hostent* host_info;
+    int i = 0;
+    if(at_req_parse_args(args, "=%*[\"]%[^\"]%*[\"]", domain) > 0)
+    {
+	    at_server_printfln("===AT+PING TODO == \r\n L:%d, F:%s, IN %s", __LINE__, __FUNCTION__, __FILE__);
+//        if(at_ping(domain, 0) != RT_EOK)
+//        {
+//            return AT_RESULT_FAILE;
+//        }
+    }
+    else
+    {
+        return AT_RESULT_PARSE_FAILE;
+    }
+    return AT_RESULT_OK;
+}
+
+AT_CMD_EXPORT("AT+PING", "=<domain name>", NULL, NULL, at_ipping_setup, NULL);

src/ip/at_ipsend.c

@@ -0,0 +1,154 @@
+#include <at.h>
+#include <netdb.h>
+#include <sys/socket.h>
+
+extern int ipmode;
+extern int single_connect_fd;
+extern int socket_fd_table[5];
+extern at_server_t at_get_server(void);
+
+static rt_err_t get_char_timeout(rt_tick_t timeout, char * chr)
+{
+    char ch;
+    rt_err_t result;
+    at_server_t at_server = at_get_server();
+    while (rt_device_read(at_server->device, 0, &ch, 1) == 0)
+    {
+        rt_sem_control(at_server->rx_notice, RT_IPC_CMD_RESET, RT_NULL);
+        if((result = rt_sem_take(at_server->rx_notice, timeout)) != RT_EOK)
+        {
+            return result;
+        }
+    }
+    if(at_server->echo_mode)
+    {
+        at_server_printf("%c", ch);
+    }
+    *chr = ch;
+    return RT_EOK;
+}
+
+static at_result_t at_ipsend_exec(void)
+{
+    uint8_t * sendbuffer = NULL;
+    uint8_t * psendbuffer;
+    rt_err_t result = RT_EOK;
+    int length = 0;
+    if(ipmode)
+    {
+        return AT_RESULT_FAILE;
+    }
+
+    if(single_connect_fd == -1)
+    {
+        return AT_RESULT_FAILE;
+    }
+
+    sendbuffer = malloc(2048);
+    at_server_printf("\r\n>");
+    while(1)
+    {
+        psendbuffer = sendbuffer;
+        length = 2048;
+        while(length)
+        {
+            result = get_char_timeout(rt_tick_from_millisecond(20), psendbuffer);
+            if(result != RT_EOK)
+            {
+                break;
+            }
+            length--;
+            psendbuffer++;
+        }
+        if(rt_strncmp("+++", sendbuffer, 3) == 0)
+        {
+            free(sendbuffer);
+            sendbuffer = NULL;
+            break;
+        }
+        if((psendbuffer - sendbuffer) > 0)
+        {
+            send(single_connect_fd, sendbuffer, psendbuffer - sendbuffer, 0);
+        }
+    }
+    return AT_RESULT_NULL;
+}
+
+
+
+static at_result_t at_ipsend_setup(const char *args)
+{
+    int length = 0;
+    int send_bytes = 0;
+    uint8_t * sendbuffer = NULL;
+    uint8_t * psendbuffer;
+    int linkid = -1;
+    int socket_fd = -1;
+    if(ipmode)
+    {
+        if(at_req_parse_args(args, "=%d,%d", &linkid, &length) <= 0)
+        {
+            return AT_RESULT_PARSE_FAILE;
+        }
+        socket_fd = socket_fd_table[linkid];
+    }
+    else
+    {
+        if(at_req_parse_args(args, "=%d", &length) <= 0)
+        {
+            return AT_RESULT_PARSE_FAILE;
+        }
+        socket_fd = single_connect_fd;
+    }
+
+    
+    send_bytes = length;
+
+    if(length > 0)
+    {
+        if(socket_fd == -1)
+        {
+            return AT_RESULT_FAILE;
+        }
+        
+        sendbuffer = malloc(length);
+        if(sendbuffer == NULL)
+        {
+            at_server_printfln("SEND FAIL");
+            return AT_RESULT_NULL;
+        }
+        psendbuffer = sendbuffer;
+        at_server_printfln("\r\nOK");
+        at_server_printf(">");
+        while(length)
+        {
+            if(get_char_timeout(rt_tick_from_millisecond(1000), psendbuffer) != RT_EOK)
+            {
+                at_server_printfln("SEND FAIL");
+                free(sendbuffer);
+                return AT_RESULT_NULL;
+            }
+            length--;
+            psendbuffer++;
+        }
+        at_server_printfln("\r\nRecv %d bytes", send_bytes);
+        if(send(socket_fd, sendbuffer, psendbuffer - sendbuffer, 0) == psendbuffer - sendbuffer)
+        {
+            free(sendbuffer);
+            sendbuffer = NULL;
+            
+            at_server_printfln("SEND OK");
+            return AT_RESULT_NULL;
+        }
+        else
+        {
+            free(sendbuffer);
+            sendbuffer = NULL;
+            at_server_printfln("SEND FAIL");
+            return AT_RESULT_NULL;
+        }
+    }
+    return AT_RESULT_OK;
+}
+
+AT_CMD_EXPORT("AT+CIPSEND", "=[<linkid>,]<length>", NULL, NULL, at_ipsend_setup, at_ipsend_exec);

src/ip/at_ipstart.c

@@ -0,0 +1,239 @@
+#include <at.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <string.h>
+#include <stdio.h>
+#include <rtthread.h>
+
+#define DBG_ENABLE
+#define DBG_SECTION_NAME  "[AT/IP]"
+#define DBG_LEVEL         DBG_LOG
+#define DBG_COLOR
+#include <rtdbg.h>
+
+extern at_server_t at_get_server(void);
+
+extern int ipmode;
+int socket_fd_table[5] = {-1, -1, -1, -1, -1};
+rt_mutex_t out_mutex;
+
+static at_result_t at_ipstart_query(void)
+{
+    at_server_printfln("AT+CIPSTART=<type>,<remoteIP>,<remote port>[,<TCP keepalive>]");
+    return AT_RESULT_OK;
+}
+
+static at_result_t at_ipstart_exec(void)
+{
+    at_server_printfln("AT+CIPSTART=<type>,<remoteIP>,<remote port>[,<TCP keepalive>]");
+    return AT_RESULT_OK;
+}
+
+int single_connect_fd = -1;
+
+static void receiver_thread_entry(void * args)
+{
+    static rt_uint8_t recv_data[4096];
+    int bytes_received = 0;
+    at_server_t at_server = at_get_server();
+    int socket_fd = ((int)args) == -1 ? single_connect_fd : socket_fd_table[((int)args)];
+	
+	out_mutex = rt_mutex_create("atserver", RT_IPC_FLAG_FIFO);
+	
+    while (1)
+    {
+        bytes_received = recv(socket_fd, recv_data, sizeof(recv_data) - 1, 0);
+        if (bytes_received < 0)
+        {
+            closesocket(socket_fd);
+            if(((int)args) == -1)
+            {
+                single_connect_fd = -1;
+            }
+            else
+            {
+                socket_fd_table[((int)args)] = -1;
+            }
+            LOG_E("\nreceived error,close the socket.\r\n");
+            break;
+        }
+        else if (bytes_received == 0)
+        {
+            LOG_I("\nReceived warning,recv function return 0.\r\n");
+            continue;
+        }
+
+        recv_data[bytes_received] = '\0';
+        rt_mutex_take(out_mutex, RT_WAITING_FOREVER);
+        at_server_printf("+IPD,%d,%d:", ((int)args), bytes_received, recv_data);
+        rt_device_write(at_server->device, 0, recv_data, bytes_received);
+        rt_mutex_release(out_mutex);
+    }
+}
+
+static void start_receiver_thread(int linkid)
+{
+    rt_thread_t tid;
+    tid = rt_thread_create("ssrt", receiver_thread_entry, (void *)linkid, 1024, 18, 20);
+    if(tid)
+    {
+        rt_thread_startup(tid);
+        return;
+    }
+    LOG_E("Receive thread startup failed");
+}
+
+static int at_fd_connect(struct sockaddr_in local_sockaddr, struct sockaddr_in remote_sockaddr, int istcp)
+{
+    int socket_fd = -1;
+    socket_fd = socket(local_sockaddr.sin_family, istcp ? SOCK_STREAM : SOCK_DGRAM, istcp ? IPPROTO_TCP : IPPROTO_UDP);
+    if(socket_fd == -1)
+    {
+        goto __error;
+    }
+    if((bind(socket_fd, (struct sockaddr *)&local_sockaddr, sizeof(local_sockaddr)) != 0))
+    {
+        LOG_E("Socket bind error");
+        goto __error;
+    }    
+    else
+    {
+        if((connect(socket_fd, (struct sockaddr *)&remote_sockaddr, sizeof(remote_sockaddr)) != 0))
+        {
+            LOG_E("Connect error");
+            goto __error;
+        }
+    }
+    return socket_fd;
+
+__error:
+    if(socket_fd != -1)
+    {
+        closesocket(socket_fd);
+        socket_fd = -1;
+    }
+    return -1;
+}
+
+static at_result_t at_ipstart_setup(const char * args)
+{
+    int result = 5;
+    static char connection_type[10];
+    static char remote_addr[128];
+    int port = 0;
+    int alive = 0;
+    int udp_local_port = 0;
+    int udp_mode = 0;
+    struct hostent* host_info = NULL;
+    struct sockaddr_in local_sockaddr;
+    struct sockaddr_in remote_sockaddr;
+    int is_tcp = 0;
+    int linkid = 0;
+
+    memset(&local_sockaddr,0,sizeof(local_sockaddr));
+    memset(&remote_sockaddr,0,sizeof(remote_sockaddr));
+
+    if(ipmode)
+    {
+        if(at_req_parse_args(args, "=%d,%*[\"]%[^\"]%*[\"],%*s", &linkid, connection_type) > 0)
+        {
+            if(linkid < 0 || linkid > 4)
+            {
+                return AT_RESULT_FAILE;
+            }
+            if(socket_fd_table[linkid] != -1)
+            {
+                at_server_printfln("ALREADY CONNECTED");
+                return AT_RESULT_NULL;
+            }
+            if(strcmp("TCP", connection_type) == 0)
+            {
+                is_tcp = 1;
+                if((result = at_req_parse_args(args, "=%d,%*[\"]%[^\"]%*[\"],%*[\"]%[^\"]%*[\"],%d,%d", &linkid, connection_type, remote_addr, &port, &alive)) <= 0)
+                {
+                    return AT_RESULT_PARSE_FAILE;
+                }
+            }
+            else
+            {
+                if((result = at_req_parse_args(args, "=%d,%*[\"]%[^\"]%*[\"],%*[\"]%[^\"]%*[\"],%d,%d,%d", &linkid, connection_type, remote_addr, &port, &udp_local_port, &udp_mode)) <= 0)
+                {
+                    return AT_RESULT_PARSE_FAILE;
+                }
+            }
+            host_info = gethostbyname(remote_addr);
+            if(host_info == NULL || host_info->h_addr_list[0] == NULL)
+            {
+                return AT_RESULT_FAILE;
+            }
+            local_sockaddr.sin_family = host_info->h_addrtype;
+            local_sockaddr.sin_len = host_info->h_length;
+
+            remote_sockaddr.sin_port = htons(port);
+            remote_sockaddr.sin_len = host_info->h_length;
+            remote_sockaddr.sin_family = host_info->h_addrtype;
+            remote_sockaddr.sin_addr = *((struct in_addr *)(host_info->h_addr_list[0]));//IPV6 TO DO:
+            socket_fd_table[linkid] = at_fd_connect(local_sockaddr, remote_sockaddr, is_tcp);
+            if(socket_fd_table[linkid] != -1)
+            {
+                at_server_printfln("%d,CONNECT",linkid);
+                start_receiver_thread(linkid);
+            }
+        }
+        else
+        {
+            return AT_RESULT_PARSE_FAILE;
+        }
+    }
+    else
+    {
+        if(at_req_parse_args(args, "=%*[\"]%[^\"]%*[\"],%*s", connection_type) > 0)
+        {
+            if(single_connect_fd != -1)
+            {
+                at_server_printfln("ALREADY CONNECTED");
+                return AT_RESULT_NULL;
+            }
+            if(strcmp("TCP", connection_type) == 0)
+            {
+                is_tcp = 1;
+                if((result = at_req_parse_args(args, "=%*[\"]%[^\"]%*[\"],%*[\"]%[^\"]%*[\"],%d,%d", connection_type, remote_addr, &port, &alive)) <= 0)
+                {
+                    return AT_RESULT_PARSE_FAILE;
+                }
+            }
+            else
+            {
+                if((result = at_req_parse_args(args, "=%*[\"]%[^\"]%*[\"],%*[\"]%[^\"]%*[\"],%d,%d,%d", connection_type, remote_addr, &port, &udp_local_port, &udp_mode)) <= 0)
+                {
+                    return AT_RESULT_PARSE_FAILE;
+                }
+            }
+            host_info = gethostbyname(remote_addr);
+            if(host_info == NULL || host_info->h_addr_list[0] == NULL)
+            {
+                return AT_RESULT_FAILE;
+            }
+            local_sockaddr.sin_family = host_info->h_addrtype;
+            local_sockaddr.sin_len = host_info->h_length;
+
+            remote_sockaddr.sin_port = htons(port);
+            remote_sockaddr.sin_len = host_info->h_length;
+            remote_sockaddr.sin_family = host_info->h_addrtype;
+            remote_sockaddr.sin_addr = *((struct in_addr *)(host_info->h_addr_list[0]));//IPV6 TO DO:
+            single_connect_fd = at_fd_connect(local_sockaddr, remote_sockaddr, is_tcp);
+            if(single_connect_fd != -1)
+            {
+                at_server_printfln("CONNECT");
+                start_receiver_thread(-1);
+            }
+        }
+        else
+        {
+            return AT_RESULT_PARSE_FAILE;
+        }
+    }
+    return AT_RESULT_OK;
+}
+
+AT_CMD_EXPORT("AT+CIPSTART", "=[<link id>,]<type>,<remoteIP>,<remote port>[,<TCP keepalive>][,<UDP local port>[,<UDP mode>]]", NULL, at_ipstart_query, at_ipstart_setup, at_ipstart_exec);

src/ip/at_ipstatus.c

@@ -0,0 +1,24 @@
+#include <at.h>
+
+static at_result_t at_ipstatus_query(void)
+{
+    at_server_printfln("AT+CIPSTATUS");
+    return AT_RESULT_OK;
+}
+
+static at_result_t at_ipstatus_exec(void)
+{
+    int status = 5;
+    if(rt_wlan_is_ready())
+    {
+        status = 2;
+    }
+    else if(rt_wlan_is_connected())
+    {
+        status = 4;
+    }
+    at_server_printfln("+STATUS:%d", status);
+    return AT_RESULT_OK;
+}
+
+AT_CMD_EXPORT("AT+CIPSTATUS", NULL, NULL, at_ipstatus_query, NULL, at_ipstatus_exec);

src/ip/at_ipstop.c

@@ -0,0 +1,54 @@
+#include <at.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <string.h>
+
+extern int ipmode;
+extern int socket_fd_table[5];
+extern int single_connect_fd;
+
+static at_result_t at_ipstop_exec(void)
+{
+    if(ipmode)
+    {
+        return AT_RESULT_FAILE;
+    }
+
+    if(single_connect_fd != -1)
+    {
+        closesocket(single_connect_fd);
+        single_connect_fd = -1;
+    }
+    return AT_RESULT_OK;
+}
+
+static at_result_t at_ipstop_setup(const char * args)
+{
+    int linkid = -1;
+    if(!ipmode)
+    {
+        return AT_RESULT_FAILE;
+    }
+    
+    if(at_req_parse_args(args, "=%d", &linkid) > 0)
+    {
+        if(linkid < 0 || linkid > 4)
+        {
+            return AT_RESULT_FAILE;
+        }
+
+        if(socket_fd_table[linkid] != -1)
+        {
+            closesocket(socket_fd_table[linkid]);
+            socket_fd_table[linkid] = -1;
+        }
+    }
+    else
+    {
+        return AT_RESULT_PARSE_FAILE;
+    }
+    return AT_RESULT_OK;
+    
+}
+
+AT_CMD_EXPORT("AT+CIPCLOSE", "=<link id>", NULL, NULL, at_ipstop_setup, at_ipstop_exec);

src/ota/at_ota.c

@@ -0,0 +1,23 @@
+#include <at.h>
+
+extern int msh_exec(char *cmd, rt_size_t length);
+static at_result_t at_ota_setup(const char *args)
+{
+    char url[256];
+    char cmd[256+sizeof("http_ota ")];
+    int len = 0;
+    if(at_req_parse_args(args, "=%*[\"]%[^\"]%*[\"]", url) > 0)
+    {
+        len = sprintf(cmd, "http_ota %s", url);
+        msh_exec(cmd, len);
+    }
+    else
+    {
+        return AT_RESULT_PARSE_FAILE;
+    }
+    return AT_RESULT_OK;
+}
+
+AT_CMD_EXPORT("AT+OTA", "=<url>", NULL, NULL, at_ota_setup, NULL);
+
+//AT+OTA="http://172.16.88.86/image2_all_ota1.rbl"

src/wifi/at_connect.c

@@ -0,0 +1,28 @@
+#include <at.h>
+#include <rtdevice.h>
+#define AT_VERSION "0.0.1"
+
+#define SSID_NAME_LENGTH_MAX 32
+#define PASSWORD_LENGTH_MAX 32
+
+static at_result_t at_connect_setup(const char *args)
+{
+    char ssid[SSID_NAME_LENGTH_MAX], pass[PASSWORD_LENGTH_MAX];
+    if(at_req_parse_args(args, "=%*[\"]%[^\"]%*[\"],%*[\"]%[^\"]%*[\"]", ssid, pass) > 0)
+    {
+        if(rt_wlan_connect(ssid, pass) == RT_EOK)
+        {
+            return AT_RESULT_OK;
+        }
+        else
+        {
+            return AT_RESULT_FAILE;
+        }
+    }
+    else
+    {
+        return AT_RESULT_PARSE_FAILE;
+    }
+}
+
+AT_CMD_EXPORT("AT+CWJAP", "=<ssid>,<pass>", NULL, NULL, at_connect_setup, NULL);

src/wifi/at_disconnect.c

@@ -0,0 +1,16 @@
+#include <at.h>
+#include <rtdevice.h>
+
+static at_result_t at_disconnect_query(void)
+{
+    at_server_printfln("AT+CWQAP");
+    return AT_RESULT_OK;
+}
+
+static at_result_t at_disconnect_exec(void)
+{
+    rt_wlan_disconnect();
+    return AT_RESULT_OK;
+}
+
+AT_CMD_EXPORT("AT+CWQAP", NULL, NULL, at_disconnect_query, NULL, at_disconnect_exec);

src/wifi/at_mode.c

@@ -0,0 +1,26 @@
+#include <at.h>
+
+static at_result_t at_mode_query(void)
+{
+	  at_server_printfln("===AT+CWMODE? TODO == \r\n L:%d, F:%s, IN %s", __LINE__, __FUNCTION__, __FILE__); 
+    at_server_printfln("+CWMODE:1");
+    return AT_RESULT_OK;
+}
+
+static at_result_t at_mode_setup(const char *args)
+{
+    int mode = 0;
+    if(at_req_parse_args(args, "=%d", &mode) > 0)
+    {
+        //TO DO:
+			  at_server_printfln("===AT+CWMODE= TODO == \r\n L:%d, F:%s, IN %s", __LINE__, __FUNCTION__, __FILE__);
+        return AT_RESULT_OK;
+    }
+    else
+    {
+        return AT_RESULT_PARSE_FAILE;
+    }
+    return AT_RESULT_OK;
+}
+
+AT_CMD_EXPORT("AT+CWMODE", "=<mode>", NULL, at_mode_query, at_mode_setup, NULL);

src/wifi/at_scan.c

@@ -0,0 +1,105 @@
+#include <rtdevice.h>
+#include <at.h>
+
+static int enc_parse(struct rt_wlan_info * info)
+{
+    switch(info->security)
+    {
+    case SECURITY_OPEN:
+        return 0;
+    case SECURITY_WEP_PSK:
+    case SECURITY_WEP_SHARED:
+        return 1;
+    case SECURITY_WPA_TKIP_PSK:
+    case SECURITY_WPA_AES_PSK:
+        return 2;
+    case SECURITY_WPA2_AES_PSK:
+    case SECURITY_WPA2_TKIP_PSK:
+        return 3;
+    case SECURITY_WPA2_MIXED_PSK:
+        return 4;
+    }
+}
+
+static int pairwise_cipher_parse(struct rt_wlan_info * info)
+{
+    if(info->security == SECURITY_OPEN)
+    {
+        return 0;
+    }
+    else if(info->security & WEP_ENABLED)
+    {
+        if(info->security & SHARED_ENABLED)
+        {
+            return 2;
+        }
+        return 1;
+    }
+    else if((info->security & TKIP_ENABLED) && (info->security & AES_ENABLED))
+    {
+        return 5;
+    }
+    else if(info->security & TKIP_ENABLED)
+    {
+        return 3;
+    }
+    else if(info->security & AES_ENABLED)
+    {
+        return 4;
+    }
+    return 6;
+}
+
+static int wps_parse(struct rt_wlan_info * info)
+{
+    if(info->security & WPS_ENABLED)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+static void print_mac(struct rt_wlan_info * info)
+{
+    at_server_printf("%02X:%02X:%02X:%02X:%02X:%02X",  info->bssid[0],
+                                                        info->bssid[1],
+                                                        info->bssid[2],
+                                                        info->bssid[3],
+                                                        info->bssid[4],
+                                                        info->bssid[5]);
+}
+
+static at_result_t at_scan_exec(void)
+{
+    int num = 0,i;
+    struct rt_wlan_info *info;
+    struct rt_wlan_scan_result * result = rt_wlan_scan_sync();
+    num = result->num;
+    info = result->info;
+    for(i = 0; i < num; i++)
+    {
+        at_server_printf("+CWLAP:");
+        at_server_printf("%d,",enc_parse(&info[i]));
+        info[i].ssid.val[info[i].ssid.len] = '\0';
+        at_server_printf("\"%s\",",info[i].ssid.val);
+        at_server_printf("%d,",info[i].rssi);
+        print_mac(&info[i]);at_server_printf(",");
+        at_server_printf("%d,",info[i].channel);
+        at_server_printf("0,0,");//<freq offset>, <freq cali>
+
+        at_server_printf("%d,",pairwise_cipher_parse(&info[i]));
+        at_server_printf("%d,",pairwise_cipher_parse(&info[i]));
+        at_server_printf("7,");//bgn
+        at_server_printfln("%d",wps_parse(&info[i]));
+    }
+
+    return AT_RESULT_OK;
+}
+
+static at_result_t at_scan_setup(const char *args)
+{
+    //TODO:
+    return at_scan_exec();
+}
+
+AT_CMD_EXPORT("AT+CWLAP", "=<ssid>[,<mac>,<channel>,<scan_type>,<scan_time_min>,<scan_time_max>]", NULL, NULL, at_scan_setup, at_scan_exec);