@@ -0,0 +1,96 @@
|
||||
menuconfig RT_USING_AT
|
||||
bool "Enable AT commands"
|
||||
default n
|
||||
|
||||
if RT_USING_AT
|
||||
|
||||
config AT_DEBUG
|
||||
bool "Enable debug log output"
|
||||
default n
|
||||
|
||||
config AT_USING_SERVER
|
||||
bool "Enable AT commands server"
|
||||
default n
|
||||
|
||||
if AT_USING_SERVER
|
||||
|
||||
config AT_SERVER_DEVICE
|
||||
string "Server device name"
|
||||
default "uart3"
|
||||
|
||||
config AT_SERVER_RECV_BUFF_LEN
|
||||
int "The maximum length of server data accepted"
|
||||
default 256
|
||||
|
||||
choice
|
||||
prompt "The commands new line sign"
|
||||
help
|
||||
This end mark can used for AT server determine the end of commands ,
|
||||
it can choose "\r", "\n" or "\r\n"
|
||||
|
||||
default AT_CMD_END_MARK_CRLF
|
||||
|
||||
config AT_CMD_END_MARK_CRLF
|
||||
bool "\\r\\n"
|
||||
|
||||
config AT_CMD_END_MARK_CR
|
||||
bool "\\r"
|
||||
|
||||
config AT_CMD_END_MARK_LF
|
||||
bool "\\n"
|
||||
|
||||
endchoice
|
||||
|
||||
endif
|
||||
|
||||
config AT_USING_CLIENT
|
||||
bool "Enable AT commands client"
|
||||
default n
|
||||
|
||||
if AT_USING_CLIENT
|
||||
|
||||
config AT_CLIENT_NUM_MAX
|
||||
int "The maximum number of supported clients"
|
||||
default 1
|
||||
range 1 65535
|
||||
|
||||
config AT_USING_SOCKET
|
||||
bool "Enable BSD Socket API support by AT commnads"
|
||||
select RT_USING_SAL
|
||||
select SAL_USING_AT
|
||||
default n
|
||||
|
||||
if AT_USING_SOCKET
|
||||
|
||||
config AT_USING_SOCKET_SERVER
|
||||
bool "Enable BSD Socket API support about AT server"
|
||||
default n
|
||||
|
||||
endif
|
||||
|
||||
endif
|
||||
|
||||
if AT_USING_SERVER || AT_USING_CLIENT
|
||||
|
||||
config AT_USING_CLI
|
||||
bool "Enable CLI(Command-Line Interface) for AT commands"
|
||||
default y
|
||||
depends on RT_USING_FINSH
|
||||
|
||||
config AT_PRINT_RAW_CMD
|
||||
bool "Enable print RAW format AT command communication data"
|
||||
default n
|
||||
|
||||
config AT_CMD_MAX_LEN
|
||||
int "The maximum length of AT Commands buffer"
|
||||
default 128
|
||||
|
||||
endif
|
||||
|
||||
config AT_SW_VERSION_NUM
|
||||
hex
|
||||
default 0x10301
|
||||
help
|
||||
software module version number
|
||||
|
||||
endif
|
||||
@@ -0,0 +1,26 @@
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
path = [cwd + '/include']
|
||||
|
||||
src = Glob('src/at_utils.c')
|
||||
|
||||
if GetDepend(['AT_USING_CLI']):
|
||||
src += Glob('src/at_cli.c')
|
||||
|
||||
if GetDepend(['AT_USING_SERVER']):
|
||||
src += Split('''
|
||||
src/at_server.c
|
||||
src/at_base_cmd.c
|
||||
''')
|
||||
|
||||
if GetDepend(['AT_USING_CLIENT']):
|
||||
src += Glob('src/at_client.c')
|
||||
|
||||
if GetDepend(['AT_USING_SOCKET']):
|
||||
src += Glob('at_socket/*.c')
|
||||
path += [cwd + '/at_socket']
|
||||
|
||||
group = DefineGroup('AT', src, depend = ['RT_USING_AT'], CPPPATH = path)
|
||||
|
||||
Return('group')
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,200 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-06-06 chenYong first version
|
||||
* 2022-06-02 xianxistu add implement about "AT server"
|
||||
*/
|
||||
|
||||
#ifndef __AT_SOCKET_H__
|
||||
#define __AT_SOCKET_H__
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include <rthw.h>
|
||||
|
||||
#include <netdb.h>
|
||||
#include <sys/socket.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef AT_SOCKET_RECV_BFSZ
|
||||
#define AT_SOCKET_RECV_BFSZ 512
|
||||
#endif
|
||||
|
||||
#define AT_DEFAULT_RECVMBOX_SIZE 10
|
||||
#define AT_DEFAULT_ACCEPTMBOX_SIZE 10
|
||||
|
||||
/* sal socket magic word */
|
||||
#define AT_SOCKET_MAGIC 0xA100
|
||||
|
||||
#ifdef AT_USING_SOCKET_SERVER
|
||||
#define AT_SOCKET_INFO_LEN (sizeof("SOCKET:") + 4)
|
||||
#endif
|
||||
|
||||
/* Current state of the AT socket. */
|
||||
enum at_socket_state
|
||||
{
|
||||
AT_SOCKET_NONE,
|
||||
AT_SOCKET_OPEN,
|
||||
AT_SOCKET_LISTEN,
|
||||
AT_SOCKET_CONNECT,
|
||||
AT_SOCKET_CLOSED
|
||||
};
|
||||
|
||||
enum at_socket_type
|
||||
{
|
||||
AT_SOCKET_INVALID = 0,
|
||||
AT_SOCKET_TCP = 0x10, /* TCP IPv4 */
|
||||
AT_SOCKET_UDP = 0x20, /* UDP IPv4 */
|
||||
};
|
||||
|
||||
typedef enum
|
||||
{
|
||||
AT_SOCKET_EVT_RECV,
|
||||
AT_SOCKET_EVT_CLOSED,
|
||||
#ifdef AT_USING_SOCKET_SERVER
|
||||
AT_SOCKET_EVT_CONNECTED,
|
||||
#endif
|
||||
} at_socket_evt_t;
|
||||
|
||||
struct at_socket;
|
||||
struct at_device;
|
||||
|
||||
typedef void (*at_evt_cb_t)(struct at_socket *socket, at_socket_evt_t event, const char *buff, size_t bfsz);
|
||||
|
||||
/* A callback prototype to inform about events for AT socket */
|
||||
typedef void (* at_socket_callback)(struct at_socket *conn, int event, uint16_t len);
|
||||
|
||||
/* AT socket operations function */
|
||||
struct at_socket_ops
|
||||
{
|
||||
int (*at_connect)(struct at_socket *socket, char *ip, int32_t port, enum at_socket_type type, rt_bool_t is_client);
|
||||
int (*at_closesocket)(struct at_socket *socket);
|
||||
int (*at_send)(struct at_socket *socket, const char *buff, size_t bfsz, enum at_socket_type type);
|
||||
int (*at_domain_resolve)(const char *name, char ip[16]);
|
||||
void (*at_set_event_cb)(at_socket_evt_t event, at_evt_cb_t cb);
|
||||
int (*at_socket)(struct at_device *device, enum at_socket_type type);
|
||||
#ifdef AT_USING_SOCKET_SERVER
|
||||
int (*at_listen)(struct at_socket *socket, int backlog);
|
||||
#endif
|
||||
};
|
||||
|
||||
/* AT receive package list structure */
|
||||
struct at_recv_pkt
|
||||
{
|
||||
rt_slist_t list;
|
||||
size_t bfsz_totle;
|
||||
size_t bfsz_index;
|
||||
char *buff;
|
||||
};
|
||||
typedef struct at_recv_pkt *at_recv_pkt_t;
|
||||
|
||||
#ifdef AT_USING_SOCKET_SERVER
|
||||
struct at_listen_state
|
||||
{
|
||||
uint16_t is_listen;
|
||||
uint16_t port;
|
||||
};
|
||||
#endif
|
||||
|
||||
struct at_socket
|
||||
{
|
||||
/* AT socket magic word */
|
||||
uint32_t magic;
|
||||
|
||||
int socket;
|
||||
#ifdef AT_USING_SOCKET_SERVER
|
||||
struct at_listen_state listen;
|
||||
#endif
|
||||
|
||||
/* device releated information for the socket */
|
||||
void *device;
|
||||
/* type of the AT socket (TCP, UDP or RAW) */
|
||||
enum at_socket_type type;
|
||||
/* current state of the AT socket */
|
||||
enum at_socket_state state;
|
||||
/* sockets operations */
|
||||
const struct at_socket_ops *ops;
|
||||
/* receive semaphore, received data release semaphore */
|
||||
rt_sem_t recv_notice;
|
||||
rt_mutex_t recv_lock;
|
||||
rt_slist_t recvpkt_list;
|
||||
|
||||
/* timeout to wait for send or received data in milliseconds */
|
||||
int32_t recv_timeout;
|
||||
int32_t send_timeout;
|
||||
/* A callback function that is informed about events for this AT socket */
|
||||
at_socket_callback callback;
|
||||
|
||||
/* number of times data was received, set by event_callback() */
|
||||
uint16_t rcvevent;
|
||||
/* number of times data was ACKed (free send buffer), set by event_callback() */
|
||||
uint16_t sendevent;
|
||||
/* error happened for this socket, set by event_callback() */
|
||||
uint16_t errevent;
|
||||
|
||||
#ifdef SAL_USING_POSIX
|
||||
rt_wqueue_t wait_head;
|
||||
#endif
|
||||
rt_slist_t list;
|
||||
|
||||
/* user-specific data */
|
||||
void *user_data;
|
||||
};
|
||||
|
||||
int at_socket(int domain, int type, int protocol);
|
||||
int at_closesocket(int socket);
|
||||
int at_shutdown(int socket, int how);
|
||||
int at_bind(int socket, const struct sockaddr *name, socklen_t namelen);
|
||||
#ifdef AT_USING_SOCKET_SERVER
|
||||
int at_listen(int socket, int backlog);
|
||||
#endif
|
||||
int at_connect(int socket, const struct sockaddr *name, socklen_t namelen);
|
||||
#ifdef AT_USING_SOCKET_SERVER
|
||||
int at_accept(int socket, struct sockaddr *name, socklen_t *namelen);
|
||||
#endif
|
||||
int at_sendto(int socket, const void *data, size_t size, int flags, const struct sockaddr *to, socklen_t tolen);
|
||||
int at_send(int socket, const void *data, size_t size, int flags);
|
||||
int at_recvfrom(int socket, void *mem, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen);
|
||||
int at_recv(int socket, void *mem, size_t len, int flags);
|
||||
int at_getsockopt(int socket, int level, int optname, void *optval, socklen_t *optlen);
|
||||
int at_setsockopt(int socket, int level, int optname, const void *optval, socklen_t optlen);
|
||||
struct hostent *at_gethostbyname(const char *name);
|
||||
int at_getaddrinfo(const char *nodename, const char *servname, const struct addrinfo *hints, struct addrinfo **res);
|
||||
void at_freeaddrinfo(struct addrinfo *ai);
|
||||
|
||||
struct at_socket *at_get_socket(int socket);
|
||||
#ifdef AT_USING_SOCKET_SERVER
|
||||
struct at_socket *at_get_base_socket(int base_socket);
|
||||
#endif
|
||||
|
||||
#ifndef RT_USING_SAL
|
||||
|
||||
#define socket(domain, type, protocol) at_socket(domain, type, protocol)
|
||||
#define closesocket(socket) at_closesocket(socket)
|
||||
#define shutdown(socket, how) at_shutdown(socket, how)
|
||||
#define bind(socket, name, namelen) at_bind(socket, name, namelen)
|
||||
#define connect(socket, name, namelen) at_connect(socket, name, namelen)
|
||||
#define sendto(socket, data, size, flags, to, tolen) at_sendto(socket, data, size, flags, to, tolen)
|
||||
#define send(socket, data, size, flags) at_send(socket, data, size, flags)
|
||||
#define recvfrom(socket, mem, len, flags, from, fromlen) at_recvfrom(socket, mem, len, flags, from, fromlen)
|
||||
#define getsockopt(socket, level, optname, optval, optlen) at_getsockopt(socket, level, optname, optval, optlen)
|
||||
#define setsockopt(socket, level, optname, optval, optlen) at_setsockopt(socket, level, optname, optval, optlen)
|
||||
|
||||
#define gethostbyname(name) at_gethostbyname(name)
|
||||
#define getaddrinfo(nodename, servname, hints, res) at_getaddrinfo(nodename, servname, hints, res)
|
||||
#define freeaddrinfo(ai) at_freeaddrinfo(ai)
|
||||
|
||||
#endif /* RT_USING_SAL */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* AT_SOCKET_H__ */
|
||||
@@ -0,0 +1,273 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-03-30 chenyong first version
|
||||
* 2018-08-17 chenyong multiple client support
|
||||
*/
|
||||
|
||||
#ifndef __AT_H__
|
||||
#define __AT_H__
|
||||
|
||||
#include <stddef.h>
|
||||
#include <rtthread.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define AT_SW_VERSION "1.3.1"
|
||||
|
||||
#define AT_CMD_NAME_LEN 16
|
||||
#define AT_END_MARK_LEN 4
|
||||
|
||||
#ifndef AT_CMD_MAX_LEN
|
||||
#define AT_CMD_MAX_LEN 128
|
||||
#endif
|
||||
|
||||
/* the server AT commands new line sign */
|
||||
#if defined(AT_CMD_END_MARK_CRLF)
|
||||
#define AT_CMD_END_MARK "\r\n"
|
||||
#elif defined(AT_CMD_END_MARK_CR)
|
||||
#define AT_CMD_END_MARK "\r"
|
||||
#elif defined(AT_CMD_END_MARK_LF)
|
||||
#define AT_CMD_END_MARK "\n"
|
||||
#endif
|
||||
|
||||
#ifndef AT_SERVER_RECV_BUFF_LEN
|
||||
#define AT_SERVER_RECV_BUFF_LEN 256
|
||||
#endif
|
||||
|
||||
#ifndef AT_SERVER_DEVICE
|
||||
#define AT_SERVER_DEVICE "uart2"
|
||||
#endif
|
||||
|
||||
/* the maximum number of supported AT clients */
|
||||
#ifndef AT_CLIENT_NUM_MAX
|
||||
#define AT_CLIENT_NUM_MAX 1
|
||||
#endif
|
||||
|
||||
#define AT_CMD_EXPORT(_name_, _args_expr_, _test_, _query_, _setup_, _exec_) \
|
||||
RT_USED static const struct at_cmd __at_cmd_##_test_##_query_##_setup_##_exec_ RT_SECTION("RtAtCmdTab") = \
|
||||
{ \
|
||||
_name_, \
|
||||
_args_expr_, \
|
||||
_test_, \
|
||||
_query_, \
|
||||
_setup_, \
|
||||
_exec_, \
|
||||
};
|
||||
|
||||
enum at_status
|
||||
{
|
||||
AT_STATUS_UNINITIALIZED = 0,
|
||||
AT_STATUS_INITIALIZED,
|
||||
AT_STATUS_CLI,
|
||||
};
|
||||
typedef enum at_status at_status_t;
|
||||
|
||||
#ifdef AT_USING_SERVER
|
||||
enum at_result
|
||||
{
|
||||
AT_RESULT_OK = 0, /* AT result is no error */
|
||||
AT_RESULT_FAILE = -1, /* AT result have a generic error */
|
||||
AT_RESULT_NULL = -2, /* AT result not need return */
|
||||
AT_RESULT_CMD_ERR = -3, /* AT command format error or No way to execute */
|
||||
AT_RESULT_CHECK_FAILE = -4, /* AT command expression format is error */
|
||||
AT_RESULT_PARSE_FAILE = -5, /* AT command arguments parse is error */
|
||||
};
|
||||
typedef enum at_result at_result_t;
|
||||
|
||||
struct at_cmd
|
||||
{
|
||||
char name[AT_CMD_NAME_LEN];
|
||||
char *args_expr;
|
||||
at_result_t (*test)(void);
|
||||
at_result_t (*query)(void);
|
||||
at_result_t (*setup)(const char *args);
|
||||
at_result_t (*exec)(void);
|
||||
};
|
||||
typedef struct at_cmd *at_cmd_t;
|
||||
|
||||
struct at_server
|
||||
{
|
||||
rt_device_t device;
|
||||
|
||||
at_status_t status;
|
||||
rt_err_t (*get_char)(struct at_server *server, char *ch, rt_int32_t timeout);
|
||||
rt_bool_t echo_mode;
|
||||
|
||||
char recv_buffer[AT_SERVER_RECV_BUFF_LEN];
|
||||
rt_size_t cur_recv_len;
|
||||
rt_sem_t rx_notice;
|
||||
char end_mark[AT_END_MARK_LEN];
|
||||
|
||||
rt_thread_t parser;
|
||||
void (*parser_entry)(struct at_server *server);
|
||||
};
|
||||
typedef struct at_server *at_server_t;
|
||||
#endif /* AT_USING_SERVER */
|
||||
|
||||
#ifdef AT_USING_CLIENT
|
||||
enum at_resp_status
|
||||
{
|
||||
AT_RESP_OK = 0, /* AT response end is OK */
|
||||
AT_RESP_ERROR = -1, /* AT response end is ERROR */
|
||||
AT_RESP_TIMEOUT = -2, /* AT response is timeout */
|
||||
AT_RESP_BUFF_FULL= -3, /* AT response buffer is full */
|
||||
};
|
||||
typedef enum at_resp_status at_resp_status_t;
|
||||
|
||||
struct at_response
|
||||
{
|
||||
/* response buffer */
|
||||
char *buf;
|
||||
/* the maximum response buffer size, it set by `at_create_resp()` function */
|
||||
rt_size_t buf_size;
|
||||
/* the length of current response buffer */
|
||||
rt_size_t buf_len;
|
||||
/* the number of setting response lines, it set by `at_create_resp()` function
|
||||
* == 0: the response data will auto return when received 'OK' or 'ERROR'
|
||||
* != 0: the response data will return when received setting lines number data */
|
||||
rt_size_t line_num;
|
||||
/* the count of received response lines */
|
||||
rt_size_t line_counts;
|
||||
/* the maximum response time */
|
||||
rt_int32_t timeout;
|
||||
};
|
||||
|
||||
typedef struct at_response *at_response_t;
|
||||
|
||||
struct at_client;
|
||||
|
||||
/* URC(Unsolicited Result Code) object, such as: 'RING', 'READY' request by AT server */
|
||||
struct at_urc
|
||||
{
|
||||
const char *cmd_prefix;
|
||||
const char *cmd_suffix;
|
||||
void (*func)(struct at_client *client, const char *data, rt_size_t size);
|
||||
};
|
||||
typedef struct at_urc *at_urc_t;
|
||||
|
||||
struct at_urc_table
|
||||
{
|
||||
size_t urc_size;
|
||||
const struct at_urc *urc;
|
||||
};
|
||||
typedef struct at_urc *at_urc_table_t;
|
||||
|
||||
struct at_client
|
||||
{
|
||||
rt_device_t device;
|
||||
|
||||
at_status_t status;
|
||||
char end_sign;
|
||||
|
||||
/* the current received one line data buffer */
|
||||
char *recv_line_buf;
|
||||
/* The length of the currently received one line data */
|
||||
rt_size_t recv_line_len;
|
||||
/* The maximum supported receive data length */
|
||||
rt_size_t recv_bufsz;
|
||||
rt_sem_t rx_notice;
|
||||
rt_mutex_t lock;
|
||||
|
||||
at_response_t resp;
|
||||
rt_sem_t resp_notice;
|
||||
at_resp_status_t resp_status;
|
||||
|
||||
struct at_urc_table *urc_table;
|
||||
rt_size_t urc_table_size;
|
||||
|
||||
rt_thread_t parser;
|
||||
};
|
||||
typedef struct at_client *at_client_t;
|
||||
#endif /* AT_USING_CLIENT */
|
||||
|
||||
#ifdef AT_USING_SERVER
|
||||
/* AT server initialize and start */
|
||||
int at_server_init(void);
|
||||
|
||||
/* AT server send command execute result to AT device */
|
||||
void at_server_printf(const char *format, ...);
|
||||
void at_server_printfln(const char *format, ...);
|
||||
void at_server_print_result(at_result_t result);
|
||||
rt_size_t at_server_send(at_server_t server, const char *buf, rt_size_t size);
|
||||
rt_size_t at_server_recv(at_server_t server, char *buf, rt_size_t size, rt_int32_t timeout);
|
||||
|
||||
/* AT server request arguments parse */
|
||||
int at_req_parse_args(const char *req_args, const char *req_expr, ...);
|
||||
#endif /* AT_USING_SERVER */
|
||||
|
||||
#ifdef AT_USING_CLIENT
|
||||
|
||||
/* AT client initialize and start*/
|
||||
int at_client_init(const char *dev_name, rt_size_t recv_bufsz);
|
||||
|
||||
/* ========================== multiple AT client function ============================ */
|
||||
|
||||
/* get AT client object */
|
||||
at_client_t at_client_get(const char *dev_name);
|
||||
at_client_t at_client_get_first(void);
|
||||
|
||||
/* AT client wait for connection to external devices. */
|
||||
int at_client_obj_wait_connect(at_client_t client, rt_uint32_t timeout);
|
||||
|
||||
/* AT client send or receive data */
|
||||
rt_size_t at_client_obj_send(at_client_t client, const char *buf, rt_size_t size);
|
||||
rt_size_t at_client_obj_recv(at_client_t client, char *buf, rt_size_t size, rt_int32_t timeout);
|
||||
|
||||
/* set AT client a line end sign */
|
||||
void at_obj_set_end_sign(at_client_t client, char ch);
|
||||
|
||||
/* Set URC(Unsolicited Result Code) table */
|
||||
int at_obj_set_urc_table(at_client_t client, const struct at_urc * table, rt_size_t size);
|
||||
|
||||
/* AT client send commands to AT server and waiter response */
|
||||
int at_obj_exec_cmd(at_client_t client, at_response_t resp, const char *cmd_expr, ...);
|
||||
|
||||
/* AT response object create and delete */
|
||||
at_response_t at_create_resp(rt_size_t buf_size, rt_size_t line_num, rt_int32_t timeout);
|
||||
void at_delete_resp(at_response_t resp);
|
||||
at_response_t at_resp_set_info(at_response_t resp, rt_size_t buf_size, rt_size_t line_num, rt_int32_t timeout);
|
||||
|
||||
/* AT response line buffer get and parse response buffer arguments */
|
||||
const char *at_resp_get_line(at_response_t resp, rt_size_t resp_line);
|
||||
const char *at_resp_get_line_by_kw(at_response_t resp, const char *keyword);
|
||||
int at_resp_parse_line_args(at_response_t resp, rt_size_t resp_line, const char *resp_expr, ...);
|
||||
int at_resp_parse_line_args_by_kw(at_response_t resp, const char *keyword, const char *resp_expr, ...);
|
||||
|
||||
/* ========================== single AT client function ============================ */
|
||||
|
||||
/**
|
||||
* NOTE: These functions can be used directly when there is only one AT client.
|
||||
* If there are multiple AT Client in the program, these functions can operate on the first initialized AT client.
|
||||
*/
|
||||
|
||||
#define at_exec_cmd(resp, ...) at_obj_exec_cmd(at_client_get_first(), resp, __VA_ARGS__)
|
||||
#define at_client_wait_connect(timeout) at_client_obj_wait_connect(at_client_get_first(), timeout)
|
||||
#define at_client_send(buf, size) at_client_obj_send(at_client_get_first(), buf, size)
|
||||
#define at_client_recv(buf, size, timeout) at_client_obj_recv(at_client_get_first(), buf, size, timeout)
|
||||
#define at_set_end_sign(ch) at_obj_set_end_sign(at_client_get_first(), ch)
|
||||
#define at_set_urc_table(urc_table, table_sz) at_obj_set_urc_table(at_client_get_first(), urc_table, table_sz)
|
||||
|
||||
#endif /* AT_USING_CLIENT */
|
||||
|
||||
/* ========================== User port function ============================ */
|
||||
|
||||
#ifdef AT_USING_SERVER
|
||||
/* AT server device reset */
|
||||
void at_port_reset(void);
|
||||
|
||||
/* AT server device factory reset */
|
||||
void at_port_factory_reset(void);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __AT_H__ */
|
||||
@@ -0,0 +1,27 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-10-12 armink first version
|
||||
*/
|
||||
|
||||
/*
|
||||
* NOTE: DO NOT include this file on the header file.
|
||||
*/
|
||||
|
||||
#ifndef LOG_TAG
|
||||
#define DBG_TAG "at"
|
||||
#else
|
||||
#define DBG_TAG LOG_TAG
|
||||
#endif /* LOG_TAG */
|
||||
|
||||
#ifdef AT_DEBUG
|
||||
#define DBG_LVL DBG_LOG
|
||||
#else
|
||||
#define DBG_LVL DBG_INFO
|
||||
#endif /* AT_DEBUG */
|
||||
|
||||
#include <rtdbg.h>
|
||||
@@ -0,0 +1,121 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-04-01 armink first version
|
||||
* 2018-04-04 chenyong add base commands
|
||||
*/
|
||||
|
||||
#include <at.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <rtdevice.h>
|
||||
|
||||
#ifdef AT_USING_SERVER
|
||||
|
||||
#define AT_ECHO_MODE_CLOSE 0
|
||||
#define AT_ECHO_MODE_OPEN 1
|
||||
|
||||
extern at_server_t at_get_server(void);
|
||||
|
||||
static at_result_t at_exec(void)
|
||||
{
|
||||
return AT_RESULT_OK;
|
||||
}
|
||||
AT_CMD_EXPORT("AT", RT_NULL, RT_NULL, RT_NULL, RT_NULL, at_exec);
|
||||
|
||||
static at_result_t atz_exec(void)
|
||||
{
|
||||
at_server_printfln("OK");
|
||||
|
||||
at_port_factory_reset();
|
||||
|
||||
return AT_RESULT_NULL;
|
||||
}
|
||||
AT_CMD_EXPORT("ATZ", RT_NULL, RT_NULL, RT_NULL, RT_NULL, atz_exec);
|
||||
|
||||
static at_result_t at_rst_exec(void)
|
||||
{
|
||||
at_server_printfln("OK");
|
||||
|
||||
at_port_reset();
|
||||
|
||||
return AT_RESULT_NULL;
|
||||
}
|
||||
AT_CMD_EXPORT("AT+RST", RT_NULL, RT_NULL, RT_NULL, RT_NULL, at_rst_exec);
|
||||
|
||||
static at_result_t ate_setup(const char *args)
|
||||
{
|
||||
int echo_mode = atoi(args);
|
||||
|
||||
if(echo_mode == AT_ECHO_MODE_CLOSE || echo_mode == AT_ECHO_MODE_OPEN)
|
||||
{
|
||||
at_get_server()->echo_mode = echo_mode;
|
||||
}
|
||||
else
|
||||
{
|
||||
return AT_RESULT_FAILE;
|
||||
}
|
||||
|
||||
return AT_RESULT_OK;
|
||||
}
|
||||
AT_CMD_EXPORT("ATE", "<value>", RT_NULL, RT_NULL, ate_setup, RT_NULL);
|
||||
|
||||
static at_result_t at_show_cmd_exec(void)
|
||||
{
|
||||
extern void rt_at_server_print_all_cmd(void);
|
||||
|
||||
rt_at_server_print_all_cmd();
|
||||
|
||||
return AT_RESULT_OK;
|
||||
}
|
||||
AT_CMD_EXPORT("AT&L", RT_NULL, RT_NULL, RT_NULL, RT_NULL, at_show_cmd_exec);
|
||||
|
||||
static at_result_t at_uart_query(void)
|
||||
{
|
||||
struct rt_serial_device *serial = (struct rt_serial_device *)at_get_server()->device;
|
||||
|
||||
at_server_printfln("AT+UART=%d,%d,%d,%d,%d", serial->config.baud_rate, serial->config.data_bits,
|
||||
serial->config.stop_bits, serial->config.parity, 1);
|
||||
|
||||
return AT_RESULT_OK;
|
||||
}
|
||||
|
||||
static at_result_t at_uart_setup(const char *args)
|
||||
{
|
||||
struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
|
||||
int baudrate, databits, stopbits, parity, flow_control, argc;
|
||||
const char *req_expr = "=%d,%d,%d,%d,%d";
|
||||
|
||||
argc = at_req_parse_args(args, req_expr, &baudrate, &databits, &stopbits, &parity, &flow_control);
|
||||
if (argc != 5)
|
||||
{
|
||||
return AT_RESULT_PARSE_FAILE;
|
||||
}
|
||||
|
||||
at_server_printfln("UART baudrate : %d", baudrate);
|
||||
at_server_printfln("UART databits : %d", databits);
|
||||
at_server_printfln("UART stopbits : %d", stopbits);
|
||||
at_server_printfln("UART parity : %d", parity);
|
||||
at_server_printfln("UART control : %d", flow_control);
|
||||
|
||||
config.baud_rate = baudrate;
|
||||
config.data_bits = databits;
|
||||
config.stop_bits = stopbits;
|
||||
config.parity = parity;
|
||||
|
||||
if(rt_device_control(at_get_server()->device, RT_DEVICE_CTRL_CONFIG, &config) != RT_EOK)
|
||||
{
|
||||
return AT_RESULT_FAILE;
|
||||
}
|
||||
|
||||
return AT_RESULT_OK;
|
||||
}
|
||||
|
||||
AT_CMD_EXPORT("AT+UART", "=<baudrate>,<databits>,<stopbits>,<parity>,<flow_control>", RT_NULL, at_uart_query, at_uart_setup, RT_NULL);
|
||||
|
||||
#endif /* AT_USING_SERVER */
|
||||
@@ -0,0 +1,355 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-04-02 armink first version
|
||||
*/
|
||||
|
||||
#include <at.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include <rthw.h>
|
||||
|
||||
#ifdef AT_USING_CLI
|
||||
|
||||
#define AT_CLI_FIFO_SIZE 256
|
||||
|
||||
static struct rt_semaphore console_rx_notice;
|
||||
static struct rt_ringbuffer *console_rx_fifo = RT_NULL;
|
||||
static rt_err_t (*odev_rx_ind)(rt_device_t dev, rt_size_t size) = RT_NULL;
|
||||
|
||||
#ifdef AT_USING_CLIENT
|
||||
static struct rt_semaphore client_rx_notice;
|
||||
static struct rt_ringbuffer *client_rx_fifo = RT_NULL;
|
||||
#endif
|
||||
|
||||
static char console_getchar(void)
|
||||
{
|
||||
char ch;
|
||||
|
||||
rt_sem_take(&console_rx_notice, RT_WAITING_FOREVER);
|
||||
rt_ringbuffer_getchar(console_rx_fifo, (rt_uint8_t *)&ch);
|
||||
|
||||
return ch;
|
||||
}
|
||||
|
||||
static rt_err_t console_getchar_rx_ind(rt_device_t dev, rt_size_t size)
|
||||
{
|
||||
uint8_t ch;
|
||||
rt_size_t i;
|
||||
|
||||
for (i = 0; i < size; i++)
|
||||
{
|
||||
/* read a char */
|
||||
if (rt_device_read(dev, 0, &ch, 1))
|
||||
{
|
||||
rt_ringbuffer_put_force(console_rx_fifo, &ch, 1);
|
||||
rt_sem_release(&console_rx_notice);
|
||||
}
|
||||
}
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
void at_cli_init(void)
|
||||
{
|
||||
rt_base_t level;
|
||||
rt_device_t console;
|
||||
|
||||
rt_sem_init(&console_rx_notice, "cli_c", 0, RT_IPC_FLAG_FIFO);
|
||||
|
||||
/* create RX FIFO */
|
||||
console_rx_fifo = rt_ringbuffer_create(AT_CLI_FIFO_SIZE);
|
||||
/* created must success */
|
||||
RT_ASSERT(console_rx_fifo);
|
||||
|
||||
level = rt_hw_interrupt_disable();
|
||||
console = rt_console_get_device();
|
||||
if (console)
|
||||
{
|
||||
/* backup RX indicate */
|
||||
odev_rx_ind = console->rx_indicate;
|
||||
rt_device_set_rx_indicate(console, console_getchar_rx_ind);
|
||||
}
|
||||
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
|
||||
void at_cli_deinit(void)
|
||||
{
|
||||
rt_base_t level;
|
||||
rt_device_t console;
|
||||
|
||||
level = rt_hw_interrupt_disable();
|
||||
console = rt_console_get_device();
|
||||
if (console && odev_rx_ind)
|
||||
{
|
||||
/* restore RX indicate */
|
||||
rt_device_set_rx_indicate(console, odev_rx_ind);
|
||||
}
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
rt_sem_detach(&console_rx_notice);
|
||||
rt_ringbuffer_destroy(console_rx_fifo);
|
||||
}
|
||||
|
||||
#ifdef AT_USING_SERVER
|
||||
static rt_err_t at_server_console_getchar(struct at_server *server, char *ch, rt_int32_t timeout)
|
||||
{
|
||||
*ch = console_getchar();
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static void server_cli_parser(void)
|
||||
{
|
||||
extern at_server_t at_get_server(void);
|
||||
|
||||
at_server_t server = at_get_server();
|
||||
rt_base_t level;
|
||||
static rt_device_t device_bak;
|
||||
static rt_err_t (*getchar_bak)(struct at_server *server, char *ch, rt_int32_t timeout);
|
||||
static char endmark_back[AT_END_MARK_LEN];
|
||||
|
||||
/* backup server device and getchar function */
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
|
||||
device_bak = server->device;
|
||||
getchar_bak = server->get_char;
|
||||
|
||||
rt_memset(endmark_back, 0x00, AT_END_MARK_LEN);
|
||||
rt_memcpy(endmark_back, server->end_mark, strlen(server->end_mark));
|
||||
|
||||
/* setup server device as console device */
|
||||
server->device = rt_console_get_device();
|
||||
server->get_char = at_server_console_getchar;
|
||||
|
||||
rt_memset(server->end_mark, 0x00, AT_END_MARK_LEN);
|
||||
server->end_mark[0] = '\r';
|
||||
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
|
||||
if (server)
|
||||
{
|
||||
rt_kprintf("======== Welcome to using RT-Thread AT command server cli ========\n");
|
||||
rt_kprintf("Input your at command for test server. Press 'ESC' to exit.\n");
|
||||
server->parser_entry(server);
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_kprintf("AT client not initialized\n");
|
||||
}
|
||||
|
||||
/* restore server device and getchar function */
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
|
||||
server->device = device_bak;
|
||||
server->get_char = getchar_bak;
|
||||
|
||||
rt_memset(server->end_mark, 0x00, AT_END_MARK_LEN);
|
||||
rt_memcpy(server->end_mark, endmark_back, strlen(endmark_back));
|
||||
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
}
|
||||
#endif /* AT_USING_SERVER */
|
||||
|
||||
#ifdef AT_USING_CLIENT
|
||||
static char client_getchar(void)
|
||||
{
|
||||
char ch;
|
||||
|
||||
rt_sem_take(&client_rx_notice, RT_WAITING_FOREVER);
|
||||
rt_ringbuffer_getchar(client_rx_fifo, (rt_uint8_t *)&ch);
|
||||
|
||||
return ch;
|
||||
}
|
||||
|
||||
static void at_client_entry(void *param)
|
||||
{
|
||||
char ch;
|
||||
|
||||
while(1)
|
||||
{
|
||||
ch = client_getchar();
|
||||
rt_kprintf("%c", ch);
|
||||
}
|
||||
}
|
||||
|
||||
static rt_err_t client_getchar_rx_ind(rt_device_t dev, rt_size_t size)
|
||||
{
|
||||
uint8_t ch;
|
||||
rt_size_t i;
|
||||
|
||||
for (i = 0; i < size; i++)
|
||||
{
|
||||
/* read a char */
|
||||
if (rt_device_read(dev, 0, &ch, 1))
|
||||
{
|
||||
rt_ringbuffer_put_force(client_rx_fifo, &ch, 1);
|
||||
rt_sem_release(&client_rx_notice);
|
||||
}
|
||||
}
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
static void client_cli_parser(at_client_t client)
|
||||
{
|
||||
#define ESC_KEY 0x1B
|
||||
#define BACKSPACE_KEY 0x08
|
||||
#define DELECT_KEY 0x7F
|
||||
|
||||
char ch;
|
||||
char cur_line[FINSH_CMD_SIZE] = { 0 };
|
||||
rt_size_t cur_line_len = 0;
|
||||
static rt_err_t (*client_odev_rx_ind)(rt_device_t dev, rt_size_t size) = RT_NULL;
|
||||
rt_base_t level;
|
||||
rt_thread_t at_client;
|
||||
at_status_t client_odev_status;
|
||||
|
||||
if (client)
|
||||
{
|
||||
/* backup client status */
|
||||
{
|
||||
client_odev_status = client->status;
|
||||
client->status = AT_STATUS_CLI;
|
||||
}
|
||||
|
||||
/* backup client device RX indicate */
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
client_odev_rx_ind = client->device->rx_indicate;
|
||||
rt_device_set_rx_indicate(client->device, client_getchar_rx_ind);
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
|
||||
rt_sem_init(&client_rx_notice, "cli_r", 0, RT_IPC_FLAG_FIFO);
|
||||
client_rx_fifo = rt_ringbuffer_create(AT_CLI_FIFO_SIZE);
|
||||
|
||||
at_client = rt_thread_create("at_cli", at_client_entry, RT_NULL, 512, 8, 8);
|
||||
if (client_rx_fifo && at_client)
|
||||
{
|
||||
rt_kprintf("======== Welcome to using RT-Thread AT command client cli ========\n");
|
||||
rt_kprintf("Cli will forward your command to server port(%s). Press 'ESC' to exit.\n", client->device->parent.name);
|
||||
rt_thread_startup(at_client);
|
||||
/* process user input */
|
||||
while (ESC_KEY != (ch = console_getchar()))
|
||||
{
|
||||
if (ch == BACKSPACE_KEY || ch == DELECT_KEY)
|
||||
{
|
||||
if (cur_line_len)
|
||||
{
|
||||
cur_line[--cur_line_len] = 0;
|
||||
rt_kprintf("\b \b");
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (ch == '\r' || ch == '\n')
|
||||
{
|
||||
/* execute a AT request */
|
||||
if (cur_line_len)
|
||||
{
|
||||
rt_kprintf("\n");
|
||||
at_obj_exec_cmd(client, RT_NULL, "%.*s", cur_line_len, cur_line);
|
||||
}
|
||||
cur_line_len = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(cur_line_len >= FINSH_CMD_SIZE)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
rt_kprintf("%c", ch);
|
||||
cur_line[cur_line_len++] = ch;
|
||||
}
|
||||
}
|
||||
|
||||
/* restore client status */
|
||||
client->status = client_odev_status;
|
||||
|
||||
/* restore client device RX indicate */
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
rt_device_set_rx_indicate(client->device, client_odev_rx_ind);
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
|
||||
rt_thread_delete(at_client);
|
||||
rt_sem_detach(&client_rx_notice);
|
||||
rt_ringbuffer_destroy(client_rx_fifo);
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_kprintf("No mem for AT cli client\n");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_kprintf("AT client not initialized\n");
|
||||
}
|
||||
}
|
||||
#endif /* AT_USING_CLIENT */
|
||||
|
||||
static void at(int argc, char **argv)
|
||||
{
|
||||
|
||||
if (argc != 2 && argc != 3)
|
||||
{
|
||||
rt_kprintf("Please input '<server|client [dev_name]>' \n");
|
||||
return;
|
||||
}
|
||||
|
||||
at_cli_init();
|
||||
|
||||
if (!strcmp(argv[1], "server"))
|
||||
{
|
||||
#ifdef AT_USING_SERVER
|
||||
server_cli_parser();
|
||||
#else
|
||||
rt_kprintf("Not support AT server, please check your configure!\n");
|
||||
#endif /* AT_USING_SERVER */
|
||||
}
|
||||
else if (!strcmp(argv[1], "client"))
|
||||
{
|
||||
#ifdef AT_USING_CLIENT
|
||||
at_client_t client = RT_NULL;
|
||||
|
||||
if (argc == 2)
|
||||
{
|
||||
client_cli_parser(at_client_get_first());
|
||||
}
|
||||
else if (argc == 3)
|
||||
{
|
||||
client = at_client_get(argv[2]);
|
||||
if (client == RT_NULL)
|
||||
{
|
||||
rt_kprintf("input AT client device name(%s) error.\n", argv[2]);
|
||||
}
|
||||
else
|
||||
{
|
||||
client_cli_parser(client);
|
||||
}
|
||||
}
|
||||
#else
|
||||
rt_kprintf("Not support AT client, please check your configure!\n");
|
||||
#endif /* AT_USING_CLIENT */
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_kprintf("Please input '<server|client [dev_name]>' \n");
|
||||
}
|
||||
|
||||
at_cli_deinit();
|
||||
}
|
||||
MSH_CMD_EXPORT(at, RT-Thread AT component cli: at <server|client [dev_name]>);
|
||||
|
||||
#endif /* AT_USING_CLI */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,651 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-03-30 chenyong first version
|
||||
* 2018-04-14 chenyong modify parse arguments
|
||||
*/
|
||||
|
||||
#include <at.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <rthw.h>
|
||||
|
||||
#define LOG_TAG "at.svr"
|
||||
#include <at_log.h>
|
||||
|
||||
#ifdef AT_USING_SERVER
|
||||
|
||||
#define AT_CMD_CHAR_0 '0'
|
||||
#define AT_CMD_CHAR_9 '9'
|
||||
#define AT_CMD_QUESTION_MARK '?'
|
||||
#define AT_CMD_EQUAL_MARK '='
|
||||
#define AT_CMD_L_SQ_BRACKET '['
|
||||
#define AT_CMD_R_SQ_BRACKET ']'
|
||||
#define AT_CMD_L_ANGLE_BRACKET '<'
|
||||
#define AT_CMD_R_ANGLE_BRACKET '>'
|
||||
#define AT_CMD_COMMA_MARK ','
|
||||
#define AT_CMD_SEMICOLON ';'
|
||||
#define AT_CMD_CR '\r'
|
||||
#define AT_CMD_LF '\n'
|
||||
|
||||
static at_server_t at_server_local = RT_NULL;
|
||||
static at_cmd_t cmd_table = RT_NULL;
|
||||
static rt_size_t cmd_num;
|
||||
|
||||
extern rt_size_t at_utils_send(rt_device_t dev,
|
||||
rt_off_t pos,
|
||||
const void *buffer,
|
||||
rt_size_t size);
|
||||
extern void at_vprintf(rt_device_t device, const char *format, va_list args);
|
||||
extern void at_vprintfln(rt_device_t device, const char *format, va_list args);
|
||||
|
||||
/**
|
||||
* AT server send data to AT device
|
||||
*
|
||||
* @param format the input format
|
||||
*/
|
||||
void at_server_printf(const char *format, ...)
|
||||
{
|
||||
va_list args;
|
||||
|
||||
va_start(args, format);
|
||||
|
||||
at_vprintf(at_server_local->device, format, args);
|
||||
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
/**
|
||||
* AT server send data and newline to AT device
|
||||
*
|
||||
* @param format the input format
|
||||
*/
|
||||
void at_server_printfln(const char *format, ...)
|
||||
{
|
||||
va_list args;
|
||||
|
||||
va_start(args, format);
|
||||
|
||||
at_vprintfln(at_server_local->device, format, args);
|
||||
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* AT server request arguments parse arguments
|
||||
*
|
||||
* @param req_args request arguments
|
||||
* @param req_expr request expression
|
||||
*
|
||||
* @return -1 : parse arguments failed
|
||||
* 0 : parse without match
|
||||
* >0 : The number of arguments successfully parsed
|
||||
*/
|
||||
int at_req_parse_args(const char *req_args, const char *req_expr, ...)
|
||||
{
|
||||
va_list args;
|
||||
int req_args_num = 0;
|
||||
|
||||
RT_ASSERT(req_args);
|
||||
RT_ASSERT(req_expr);
|
||||
|
||||
va_start(args, req_expr);
|
||||
|
||||
req_args_num = vsscanf(req_args, req_expr, args);
|
||||
|
||||
va_end(args);
|
||||
|
||||
return req_args_num;
|
||||
}
|
||||
|
||||
/**
|
||||
* AT server send command execute result to AT device
|
||||
*
|
||||
* @param result AT command execute result
|
||||
*/
|
||||
void at_server_print_result(at_result_t result)
|
||||
{
|
||||
switch (result)
|
||||
{
|
||||
case AT_RESULT_OK:
|
||||
at_server_printfln("");
|
||||
at_server_printfln("OK");
|
||||
break;
|
||||
|
||||
case AT_RESULT_FAILE:
|
||||
at_server_printfln("");
|
||||
at_server_printfln("ERROR");
|
||||
break;
|
||||
|
||||
case AT_RESULT_NULL:
|
||||
break;
|
||||
|
||||
case AT_RESULT_CMD_ERR:
|
||||
at_server_printfln("ERR CMD MATCH FAILED!");
|
||||
at_server_print_result(AT_RESULT_FAILE);
|
||||
break;
|
||||
|
||||
case AT_RESULT_CHECK_FAILE:
|
||||
at_server_printfln("ERR CHECK ARGS FORMAT FAILED!");
|
||||
at_server_print_result(AT_RESULT_FAILE);
|
||||
break;
|
||||
|
||||
case AT_RESULT_PARSE_FAILE:
|
||||
at_server_printfln("ERR PARSE ARGS FAILED!");
|
||||
at_server_print_result(AT_RESULT_FAILE);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* AT server print all commands to AT device
|
||||
*/
|
||||
void rt_at_server_print_all_cmd(void)
|
||||
{
|
||||
rt_size_t i = 0;
|
||||
|
||||
at_server_printfln("Commands list : ");
|
||||
|
||||
for (i = 0; i < cmd_num; i++)
|
||||
{
|
||||
at_server_printf("%s", cmd_table[i].name);
|
||||
|
||||
if (cmd_table[i].args_expr)
|
||||
{
|
||||
at_server_printfln("%s", cmd_table[i].args_expr);
|
||||
}
|
||||
else
|
||||
{
|
||||
at_server_printf("%c%c", AT_CMD_CR, AT_CMD_LF);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Send data to AT Client by uart device.
|
||||
*
|
||||
* @param server current AT server object
|
||||
* @param buf send data buffer
|
||||
* @param size send fixed data size
|
||||
*
|
||||
* @return >0: send data size
|
||||
* =0: send failed
|
||||
*/
|
||||
rt_size_t at_server_send(at_server_t server, const char *buf, rt_size_t size)
|
||||
{
|
||||
RT_ASSERT(buf);
|
||||
|
||||
if (server == RT_NULL)
|
||||
{
|
||||
LOG_E("input AT Server object is NULL, please create or get AT Server object!");
|
||||
return 0;
|
||||
}
|
||||
|
||||
return at_utils_send(server->device, 0, buf, size);
|
||||
}
|
||||
|
||||
/**
|
||||
* AT Server receive fixed-length data.
|
||||
*
|
||||
* @param client current AT Server object
|
||||
* @param buf receive data buffer
|
||||
* @param size receive fixed data size
|
||||
* @param timeout receive data timeout (ms)
|
||||
*
|
||||
* @note this function can only be used in execution function of AT commands
|
||||
*
|
||||
* @return >0: receive data size
|
||||
* =0: receive failed
|
||||
*/
|
||||
rt_size_t at_server_recv(at_server_t server, char *buf, rt_size_t size, rt_int32_t timeout)
|
||||
{
|
||||
rt_size_t read_idx = 0;
|
||||
rt_err_t result = RT_EOK;
|
||||
char ch = 0;
|
||||
|
||||
RT_ASSERT(buf);
|
||||
|
||||
if (server == RT_NULL)
|
||||
{
|
||||
LOG_E("input AT Server object is NULL, please create or get AT Server object!");
|
||||
return 0;
|
||||
}
|
||||
|
||||
while (1)
|
||||
{
|
||||
if (read_idx < size)
|
||||
{
|
||||
/* check get data value */
|
||||
result = server->get_char(server, &ch, timeout);
|
||||
if (result != RT_EOK)
|
||||
{
|
||||
LOG_E("AT Server receive failed, uart device get data error.");
|
||||
return 0;
|
||||
}
|
||||
|
||||
buf[read_idx++] = ch;
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return read_idx;
|
||||
}
|
||||
|
||||
at_server_t at_get_server(void)
|
||||
{
|
||||
RT_ASSERT(at_server_local);
|
||||
RT_ASSERT(at_server_local->status != AT_STATUS_UNINITIALIZED);
|
||||
|
||||
return at_server_local;
|
||||
}
|
||||
|
||||
static rt_err_t at_check_args(const char *args, const char *args_format)
|
||||
{
|
||||
rt_size_t left_sq_bracket_num = 0, right_sq_bracket_num = 0;
|
||||
rt_size_t left_angle_bracket_num = 0, right_angle_bracket_num = 0;
|
||||
rt_size_t comma_mark_num = 0;
|
||||
rt_size_t i = 0;
|
||||
|
||||
RT_ASSERT(args);
|
||||
RT_ASSERT(args_format);
|
||||
|
||||
for (i = 0; i < strlen(args_format); i++)
|
||||
{
|
||||
switch (args_format[i])
|
||||
{
|
||||
case AT_CMD_L_SQ_BRACKET:
|
||||
left_sq_bracket_num++;
|
||||
break;
|
||||
|
||||
case AT_CMD_R_SQ_BRACKET:
|
||||
right_sq_bracket_num++;
|
||||
break;
|
||||
|
||||
case AT_CMD_L_ANGLE_BRACKET:
|
||||
left_angle_bracket_num++;
|
||||
break;
|
||||
|
||||
case AT_CMD_R_ANGLE_BRACKET:
|
||||
right_angle_bracket_num++;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (left_sq_bracket_num != right_sq_bracket_num || left_angle_bracket_num != right_angle_bracket_num
|
||||
|| left_sq_bracket_num > left_angle_bracket_num)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
for (i = 0; i < strlen(args); i++)
|
||||
{
|
||||
if (args[i] == AT_CMD_COMMA_MARK)
|
||||
{
|
||||
comma_mark_num++;
|
||||
}
|
||||
}
|
||||
|
||||
if ((comma_mark_num + 1 < left_angle_bracket_num - left_sq_bracket_num)
|
||||
|| comma_mark_num + 1 > left_angle_bracket_num)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t at_cmd_process(at_cmd_t cmd, const char *cmd_args)
|
||||
{
|
||||
at_result_t result = AT_RESULT_OK;
|
||||
|
||||
RT_ASSERT(cmd);
|
||||
RT_ASSERT(cmd_args);
|
||||
|
||||
if (cmd_args[0] == AT_CMD_EQUAL_MARK && cmd_args[1] == AT_CMD_QUESTION_MARK && cmd_args[2] == AT_CMD_CR)
|
||||
{
|
||||
if (cmd->test == RT_NULL)
|
||||
{
|
||||
at_server_print_result(AT_RESULT_CMD_ERR);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
result = cmd->test();
|
||||
at_server_print_result(result);
|
||||
}
|
||||
else if (cmd_args[0] == AT_CMD_QUESTION_MARK && cmd_args[1] == AT_CMD_CR)
|
||||
{
|
||||
if (cmd->query == RT_NULL)
|
||||
{
|
||||
at_server_print_result(AT_RESULT_CMD_ERR);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
result = cmd->query();
|
||||
at_server_print_result(result);
|
||||
}
|
||||
else if (cmd_args[0] == AT_CMD_EQUAL_MARK
|
||||
|| (cmd_args[0] >= AT_CMD_CHAR_0 && cmd_args[0] <= AT_CMD_CHAR_9 && cmd_args[1] == AT_CMD_CR))
|
||||
{
|
||||
if (cmd->setup == RT_NULL)
|
||||
{
|
||||
at_server_print_result(AT_RESULT_CMD_ERR);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
if(at_check_args(cmd_args, cmd->args_expr) < 0)
|
||||
{
|
||||
at_server_print_result(AT_RESULT_CHECK_FAILE);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
result = cmd->setup(cmd_args);
|
||||
at_server_print_result(result);
|
||||
}
|
||||
else if (cmd_args[0] == AT_CMD_CR)
|
||||
{
|
||||
if (cmd->exec == RT_NULL)
|
||||
{
|
||||
at_server_print_result(AT_RESULT_CMD_ERR);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
result = cmd->exec();
|
||||
at_server_print_result(result);
|
||||
}
|
||||
else
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static at_cmd_t at_find_cmd(const char *cmd)
|
||||
{
|
||||
rt_size_t i = 0;
|
||||
|
||||
RT_ASSERT(cmd_table);
|
||||
|
||||
for (i = 0; i < cmd_num; i++)
|
||||
{
|
||||
if (!strcasecmp(cmd, cmd_table[i].name))
|
||||
{
|
||||
return &cmd_table[i];
|
||||
}
|
||||
}
|
||||
return RT_NULL;
|
||||
}
|
||||
|
||||
static rt_err_t at_cmd_get_name(const char *cmd_buffer, char *cmd_name)
|
||||
{
|
||||
rt_size_t cmd_name_len = 0, i = 0;
|
||||
|
||||
RT_ASSERT(cmd_name);
|
||||
RT_ASSERT(cmd_buffer);
|
||||
|
||||
for (i = 0; i < strlen(cmd_buffer) + 1; i++)
|
||||
{
|
||||
if (*(cmd_buffer + i) == AT_CMD_QUESTION_MARK || *(cmd_buffer + i) == AT_CMD_EQUAL_MARK
|
||||
|| *(cmd_buffer + i) == AT_CMD_CR
|
||||
|| (*(cmd_buffer + i) >= AT_CMD_CHAR_0 && *(cmd_buffer + i) <= AT_CMD_CHAR_9))
|
||||
{
|
||||
cmd_name_len = i;
|
||||
rt_memcpy(cmd_name, cmd_buffer, cmd_name_len);
|
||||
*(cmd_name + cmd_name_len) = '\0';
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
}
|
||||
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
static rt_err_t at_server_getchar(at_server_t server, char *ch, rt_int32_t timeout)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
while (rt_device_read(at_server_local->device, 0, ch, 1) == 0)
|
||||
{
|
||||
rt_sem_control(at_server_local->rx_notice, RT_IPC_CMD_RESET, RT_NULL);
|
||||
result = rt_sem_take(at_server_local->rx_notice, rt_tick_from_millisecond(timeout));
|
||||
if (result != RT_EOK)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static void server_parser(at_server_t server)
|
||||
{
|
||||
#define ESC_KEY 0x1B
|
||||
#define BACKSPACE_KEY 0x08
|
||||
#define DELECT_KEY 0x7F
|
||||
|
||||
char cur_cmd_name[AT_CMD_NAME_LEN] = { 0 };
|
||||
at_cmd_t cur_cmd = RT_NULL;
|
||||
char *cur_cmd_args = RT_NULL, ch, last_ch;
|
||||
|
||||
RT_ASSERT(server);
|
||||
RT_ASSERT(server->status != AT_STATUS_UNINITIALIZED);
|
||||
|
||||
while (1)
|
||||
{
|
||||
server->get_char(server, &ch, RT_WAITING_FOREVER);
|
||||
if (ESC_KEY == ch)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
if (server->echo_mode)
|
||||
{
|
||||
if (ch == AT_CMD_CR || (ch == AT_CMD_LF && last_ch != AT_CMD_CR))
|
||||
{
|
||||
at_server_printf("%c%c", AT_CMD_CR, AT_CMD_LF);
|
||||
}
|
||||
else if (ch == AT_CMD_LF)
|
||||
{
|
||||
// skip the end sign check
|
||||
}
|
||||
else if (ch == BACKSPACE_KEY || ch == DELECT_KEY)
|
||||
{
|
||||
if (server->cur_recv_len)
|
||||
{
|
||||
server->recv_buffer[--server->cur_recv_len] = 0;
|
||||
at_server_printf("\b \b");
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
at_server_printf("%c", ch);
|
||||
}
|
||||
}
|
||||
|
||||
server->recv_buffer[server->cur_recv_len++] = ch;
|
||||
last_ch = ch;
|
||||
|
||||
if(!strstr(server->recv_buffer, server->end_mark))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (at_cmd_get_name(server->recv_buffer, cur_cmd_name) < 0)
|
||||
{
|
||||
at_server_print_result(AT_RESULT_CMD_ERR);
|
||||
goto __retry;
|
||||
}
|
||||
|
||||
cur_cmd = at_find_cmd(cur_cmd_name);
|
||||
if (!cur_cmd)
|
||||
{
|
||||
at_server_print_result(AT_RESULT_CMD_ERR);
|
||||
goto __retry;
|
||||
}
|
||||
|
||||
cur_cmd_args = server->recv_buffer + strlen(cur_cmd_name);
|
||||
if (at_cmd_process(cur_cmd, cur_cmd_args) < 0)
|
||||
{
|
||||
goto __retry;
|
||||
}
|
||||
|
||||
__retry:
|
||||
rt_memset(server->recv_buffer, 0x00, AT_SERVER_RECV_BUFF_LEN);
|
||||
server->cur_recv_len = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static rt_err_t at_rx_ind(rt_device_t dev, rt_size_t size)
|
||||
{
|
||||
if (size > 0)
|
||||
{
|
||||
rt_sem_release(at_server_local->rx_notice);
|
||||
}
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
#if defined(__ICCARM__) || defined(__ICCRX__) /* for IAR compiler */
|
||||
#pragma section="RtAtCmdTab"
|
||||
#endif
|
||||
|
||||
int at_server_init(void)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
rt_err_t open_result = RT_EOK;
|
||||
|
||||
if (at_server_local)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
|
||||
/* initialize the AT commands table.*/
|
||||
#if defined(__CC_ARM) /* ARM C Compiler */
|
||||
extern const int RtAtCmdTab$$Base;
|
||||
extern const int RtAtCmdTab$$Limit;
|
||||
cmd_table = (at_cmd_t)&RtAtCmdTab$$Base;
|
||||
cmd_num = (at_cmd_t)&RtAtCmdTab$$Limit - cmd_table;
|
||||
#elif defined (__ICCARM__) || defined(__ICCRX__) /* for IAR Compiler */
|
||||
cmd_table = (at_cmd_t)__section_begin("RtAtCmdTab");
|
||||
cmd_num = (at_cmd_t)__section_end("RtAtCmdTab") - cmd_table;
|
||||
#elif defined (__GNUC__) /* for GCC Compiler */
|
||||
extern const int __rtatcmdtab_start;
|
||||
extern const int __rtatcmdtab_end;
|
||||
cmd_table = (at_cmd_t)&__rtatcmdtab_start;
|
||||
cmd_num = (at_cmd_t) &__rtatcmdtab_end - cmd_table;
|
||||
#endif /* defined(__CC_ARM) */
|
||||
|
||||
at_server_local = (at_server_t) rt_calloc(1, sizeof(struct at_server));
|
||||
if (!at_server_local)
|
||||
{
|
||||
result = -RT_ENOMEM;
|
||||
LOG_E("AT server session initialize failed! No memory for at_server structure !");
|
||||
goto __exit;
|
||||
}
|
||||
|
||||
at_server_local->echo_mode = 1;
|
||||
at_server_local->status = AT_STATUS_UNINITIALIZED;
|
||||
|
||||
rt_memset(at_server_local->recv_buffer, 0x00, AT_SERVER_RECV_BUFF_LEN);
|
||||
at_server_local->cur_recv_len = 0;
|
||||
|
||||
at_server_local->rx_notice = rt_sem_create("at_svr", 0, RT_IPC_FLAG_FIFO);
|
||||
if (!at_server_local->rx_notice)
|
||||
{
|
||||
LOG_E("AT server session initialize failed! at_rx_notice semaphore create failed!");
|
||||
result = -RT_ENOMEM;
|
||||
goto __exit;
|
||||
}
|
||||
|
||||
/* Find and open command device */
|
||||
at_server_local->device = rt_device_find(AT_SERVER_DEVICE);
|
||||
if (at_server_local->device)
|
||||
{
|
||||
RT_ASSERT(at_server_local->device->type == RT_Device_Class_Char);
|
||||
|
||||
/* using DMA mode first */
|
||||
open_result = rt_device_open(at_server_local->device, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_DMA_RX);
|
||||
/* using interrupt mode when DMA mode not supported */
|
||||
if (open_result == -RT_EIO)
|
||||
{
|
||||
open_result = rt_device_open(at_server_local->device, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
|
||||
}
|
||||
RT_ASSERT(open_result == RT_EOK);
|
||||
|
||||
rt_device_set_rx_indicate(at_server_local->device, at_rx_ind);
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_E("AT device initialize failed! Not find the device : %s.", AT_SERVER_DEVICE);
|
||||
result = -RT_ERROR;
|
||||
goto __exit;
|
||||
}
|
||||
|
||||
at_server_local->get_char = at_server_getchar;
|
||||
rt_memcpy(at_server_local->end_mark, AT_CMD_END_MARK, sizeof(AT_CMD_END_MARK));
|
||||
|
||||
at_server_local->parser_entry = server_parser;
|
||||
at_server_local->parser = rt_thread_create("at_svr",
|
||||
(void (*)(void *parameter))server_parser,
|
||||
at_server_local,
|
||||
2 * 1024,
|
||||
RT_THREAD_PRIORITY_MAX / 3 - 1,
|
||||
5);
|
||||
if (at_server_local->parser == RT_NULL)
|
||||
{
|
||||
result = -RT_ENOMEM;
|
||||
goto __exit;
|
||||
}
|
||||
|
||||
__exit:
|
||||
if (!result)
|
||||
{
|
||||
at_server_local->status = AT_STATUS_INITIALIZED;
|
||||
|
||||
rt_thread_startup(at_server_local->parser);
|
||||
|
||||
LOG_I("RT-Thread AT server (V%s) initialize success.", AT_SW_VERSION);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (at_server_local)
|
||||
{
|
||||
rt_free(at_server_local);
|
||||
}
|
||||
|
||||
LOG_E("RT-Thread AT server (V%s) initialize failed(%d).", AT_SW_VERSION, result);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
INIT_COMPONENT_EXPORT(at_server_init);
|
||||
|
||||
RT_WEAK void at_port_reset(void)
|
||||
{
|
||||
LOG_E("The reset for AT server is not implement.");
|
||||
}
|
||||
|
||||
RT_WEAK void at_port_factory_reset(void)
|
||||
{
|
||||
LOG_E("The factory reset for AT server is not implement.");
|
||||
}
|
||||
|
||||
#endif /* AT_USING_SERVER */
|
||||
@@ -0,0 +1,105 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-04-14 chenyong first version
|
||||
*/
|
||||
|
||||
#include <at.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
static char send_buf[AT_CMD_MAX_LEN];
|
||||
static rt_size_t last_cmd_len = 0;
|
||||
|
||||
/**
|
||||
* dump hex format data to console device
|
||||
*
|
||||
* @param name name for hex object, it will show on log header
|
||||
* @param buf hex buffer
|
||||
* @param size buffer size
|
||||
*/
|
||||
void at_print_raw_cmd(const char *name, const char *buf, rt_size_t size)
|
||||
{
|
||||
#define __is_print(ch) ((unsigned int)((ch) - ' ') < 127u - ' ')
|
||||
#define WIDTH_SIZE 32
|
||||
|
||||
rt_size_t i, j;
|
||||
|
||||
for (i = 0; i < size; i += WIDTH_SIZE)
|
||||
{
|
||||
rt_kprintf("[D/AT] %s: %04X-%04X: ", name, i, i + WIDTH_SIZE);
|
||||
for (j = 0; j < WIDTH_SIZE; j++)
|
||||
{
|
||||
if (i + j < size)
|
||||
{
|
||||
rt_kprintf("%02X ", buf[i + j]);
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_kprintf(" ");
|
||||
}
|
||||
if ((j + 1) % 8 == 0)
|
||||
{
|
||||
rt_kprintf(" ");
|
||||
}
|
||||
}
|
||||
rt_kprintf(" ");
|
||||
for (j = 0; j < WIDTH_SIZE; j++)
|
||||
{
|
||||
if (i + j < size)
|
||||
{
|
||||
rt_kprintf("%c", __is_print(buf[i + j]) ? buf[i + j] : '.');
|
||||
}
|
||||
}
|
||||
rt_kprintf("\n");
|
||||
}
|
||||
}
|
||||
|
||||
const char *at_get_last_cmd(rt_size_t *cmd_size)
|
||||
{
|
||||
*cmd_size = last_cmd_len;
|
||||
return send_buf;
|
||||
}
|
||||
|
||||
RT_WEAK rt_size_t at_utils_send(rt_device_t dev,
|
||||
rt_off_t pos,
|
||||
const void *buffer,
|
||||
rt_size_t size)
|
||||
{
|
||||
return rt_device_write(dev, pos, buffer, size);
|
||||
}
|
||||
|
||||
rt_size_t at_vprintf(rt_device_t device, const char *format, va_list args)
|
||||
{
|
||||
last_cmd_len = vsnprintf(send_buf, sizeof(send_buf), format, args);
|
||||
if(last_cmd_len > sizeof(send_buf))
|
||||
last_cmd_len = sizeof(send_buf);
|
||||
|
||||
#ifdef AT_PRINT_RAW_CMD
|
||||
at_print_raw_cmd("sendline", send_buf, last_cmd_len);
|
||||
#endif
|
||||
|
||||
return at_utils_send(device, 0, send_buf, last_cmd_len);
|
||||
}
|
||||
|
||||
rt_size_t at_vprintfln(rt_device_t device, const char *format, va_list args)
|
||||
{
|
||||
rt_size_t len;
|
||||
|
||||
last_cmd_len = vsnprintf(send_buf, sizeof(send_buf) - 2, format, args);
|
||||
if(last_cmd_len > sizeof(send_buf) - 2)
|
||||
last_cmd_len = sizeof(send_buf) - 2;
|
||||
rt_memcpy(send_buf + last_cmd_len, "\r\n", 2);
|
||||
|
||||
len = last_cmd_len + 2;
|
||||
|
||||
#ifdef AT_PRINT_RAW_CMD
|
||||
at_print_raw_cmd("sendline", send_buf, len);
|
||||
#endif
|
||||
|
||||
return at_utils_send(device, 0, send_buf, len);
|
||||
}
|
||||
Reference in New Issue
Block a user