wrh/chrg
1
0
Fork 0
forked from chrg/chrg
Code Pull Requests Activity
Files
ea8dcada90bf490948a5a422d32985ed7c635ad6
chrg/rt-thread/components/net/at/src/at_client.c
T
wmano 5409d3a614 upgrade rtt 5.2.2
2025-09-03 20:50:03 +08:00

1113 lines
31 KiB
C
Raw Blame History

/*
* Copyright (c) 2006-2025 RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2018-03-30 chenyong first version
* 2018-04-12 chenyong add client implement
* 2018-08-17 chenyong multiple client support
* 2021-03-17 Meco Man fix a buf of leaking memory
* 2021-07-14 Sszl fix a buf of leaking memory
* 2025-01-02 dongly support SERIAL_V2
* 2025-04-18 RyanCw support New SERIAL_V2
* 2025-08-11 RyanCw add client deInit
*/
#include <at.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define LOG_TAG "at.clnt"
#include <at_log.h>
#ifdef AT_USING_CLIENT
#define AT_RESP_END_OK "OK"
#define AT_RESP_END_ERROR "ERROR"
#define AT_RESP_END_FAIL "FAIL"
#define AT_END_CR_LF "\r\n"
#define AT_END_CR "\r"
#define AT_END_LF "\n"
#define AT_END_RAW ""
#define at_client_rx_notice_event (1 << 0)
#define at_client_resp_notice_event (1 << 1)
#define at_client_deInit_event (1 << 2)
#define at_client_deInit_over_event (1 << 3)
static rt_slist_t g_at_client_list = RT_SLIST_OBJECT_INIT(g_at_client_list);
extern rt_size_t at_utils_send(rt_device_t dev,
rt_off_t pos,
const void *buffer,
rt_size_t size);
extern rt_size_t at_vprintfln(rt_device_t device, char *send_buf, rt_size_t buf_size, const char *format, va_list args);
extern rt_size_t at_vprintf(rt_device_t device, char *send_buf, rt_size_t buf_size, const char *format, va_list args);
extern rt_size_t at_vprintfcr(rt_device_t device, char *send_buf, rt_size_t buf_size, const char *format, va_list args);
extern rt_size_t at_vprintflf(rt_device_t device, char *send_buf, rt_size_t buf_size, const char *format, va_list args);
extern void at_print_raw_cmd(const char *type, const char *cmd, rt_size_t size);
/**
* Create response object.
*
* @param buf_size the maximum response buffer size
* @param line_num the number of setting response lines
* = 0: the response data will auto return when received 'OK' or 'ERROR'
* != 0: the response data will return when received setting lines number data
* @param timeout the maximum response time
*
* @return != RT_NULL: response object
* = RT_NULL: no memory
*/
at_response_t at_create_resp(rt_size_t buf_size, rt_size_t line_num, rt_int32_t timeout)
{
at_response_t resp = RT_NULL;
resp = (at_response_t)rt_calloc(1, sizeof(struct at_response));
if (resp == RT_NULL)
{
LOG_E("AT create response object failed! No memory for response object!");
return RT_NULL;
}
resp->buf = (char *)rt_calloc(1, buf_size);
if (resp->buf == RT_NULL)
{
LOG_E("AT create response object failed! No memory for response buffer!");
rt_free(resp);
return RT_NULL;
}
resp->buf_size = buf_size;
resp->line_num = line_num;
resp->line_counts = 0;
resp->timeout = timeout;
return resp;
}
/**
* Delete and free response object.
*
* @param resp response object
*/
void at_delete_resp(at_response_t resp)
{
if (resp && resp->buf)
{
rt_free(resp->buf);
}
if (resp)
{
rt_free(resp);
resp = RT_NULL;
}
}
/**
* Set response object information
*
* @param resp response object
* @param buf_size the maximum response buffer size
* @param line_num the number of setting response lines
* = 0: the response data will auto return when received 'OK' or 'ERROR'
* != 0: the response data will return when received setting lines number data
* @param timeout the maximum response time
*
* @return != RT_NULL: response object
* = RT_NULL: no memory
*/
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)
{
char *p_temp;
RT_ASSERT(resp);
if (resp->buf_size != buf_size)
{
resp->buf_size = buf_size;
p_temp = (char *)rt_realloc(resp->buf, buf_size);
if (p_temp == RT_NULL)
{
LOG_D("No memory for realloc response buffer size(%d).", buf_size);
return RT_NULL;
}
else
{
resp->buf = p_temp;
}
}
resp->line_num = line_num;
resp->timeout = timeout;
return resp;
}
/**
* Get one line AT response buffer by line number.
*
* @param resp response object
* @param resp_line line number, start from '1'
*
* @return != RT_NULL: response line buffer
* = RT_NULL: input response line error
*/
const char *at_resp_get_line(at_response_t resp, rt_size_t resp_line)
{
char *resp_buf = resp->buf;
rt_size_t line_num = 1;
RT_ASSERT(resp);
if (resp_line > resp->line_counts || resp_line <= 0)
{
LOG_E("AT response get line failed! Input response line(%d) error!", resp_line);
return RT_NULL;
}
for (line_num = 1; line_num <= resp->line_counts; line_num++)
{
if (resp_line == line_num)
{
return resp_buf;
}
resp_buf += strlen(resp_buf) + 1;
}
return RT_NULL;
}
/**
* Get one line AT response buffer by keyword
*
* @param resp response object
* @param keyword query keyword
*
* @return != RT_NULL: response line buffer
* = RT_NULL: no matching data
*/
const char *at_resp_get_line_by_kw(at_response_t resp, const char *keyword)
{
char *resp_buf = resp->buf;
rt_size_t line_num = 1;
RT_ASSERT(resp);
RT_ASSERT(keyword);
for (line_num = 1; line_num <= resp->line_counts; line_num++)
{
if (strstr(resp_buf, keyword))
{
return resp_buf;
}
resp_buf += strlen(resp_buf) + 1;
}
return RT_NULL;
}
/**
* Get and parse AT response buffer arguments by line number.
*
* @param resp response object
* @param resp_line line number, start from '1'
* @param resp_expr response buffer expression
*
* @return -1 : input response line number error or get line buffer error
* 0 : parsed without match
* >0 : the number of arguments successfully parsed
*/
int at_resp_parse_line_args(at_response_t resp, rt_size_t resp_line, const char *resp_expr, ...)
{
va_list args;
int resp_args_num = 0;
const char *resp_line_buf = RT_NULL;
RT_ASSERT(resp);
RT_ASSERT(resp_expr);
resp_line_buf = at_resp_get_line(resp, resp_line);
if (resp_line_buf == RT_NULL)
{
return -1;
}
va_start(args, resp_expr);
resp_args_num = vsscanf(resp_line_buf, resp_expr, args);
va_end(args);
return resp_args_num;
}
/**
* Get and parse AT response buffer arguments by keyword.
*
* @param resp response object
* @param keyword query keyword
* @param resp_expr response buffer expression
*
* @return -1 : input keyword error or get line buffer error
* 0 : parsed without match
* >0 : the number of arguments successfully parsed
*/
int at_resp_parse_line_args_by_kw(at_response_t resp, const char *keyword, const char *resp_expr, ...)
{
va_list args;
int resp_args_num = 0;
const char *resp_line_buf = RT_NULL;
RT_ASSERT(resp);
RT_ASSERT(resp_expr);
resp_line_buf = at_resp_get_line_by_kw(resp, keyword);
if (resp_line_buf == RT_NULL)
{
return -1;
}
va_start(args, resp_expr);
resp_args_num = vsscanf(resp_line_buf, resp_expr, args);
va_end(args);
return resp_args_num;
}
/**
* Send commands to AT server and wait response.
*
* @param client current AT client object
* @param resp AT response object, using RT_NULL when you don't care response
* @param cmd_expr AT commands expression
*
* @return 0 : success
* -1 : response status error
* -2 : wait timeout
* -7 : enter AT CLI mode
*/
int at_obj_exec_cmd(at_client_t client, at_response_t resp, const char *cmd_expr, ...)
{
va_list args;
rt_err_t result = RT_EOK;
RT_ASSERT(cmd_expr);
if (client == RT_NULL)
{
LOG_E("input AT Client object is NULL, please create or get AT Client object!");
return -RT_ERROR;
}
/* check AT CLI mode */
if (client->status == AT_STATUS_CLI && resp)
{
return -RT_EBUSY;
}
rt_mutex_take(&client->lock, RT_WAITING_FOREVER);
client->resp_status = AT_RESP_OK;
if (resp != RT_NULL)
{
resp->buf_len = 0;
resp->line_counts = 0;
}
client->resp = resp;
rt_event_recv(&client->event, at_client_resp_notice_event, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 0, NULL);
va_start(args, cmd_expr);
client->last_cmd_len = at_vprintfln(client->device, client->send_buf, client->send_bufsz, cmd_expr, args);
if (client->last_cmd_len > 2)
{
client->last_cmd_len -= 2; /* "\r\n" */
}
va_end(args);
if (resp != RT_NULL)
{
if (rt_event_recv(&client->event, at_client_resp_notice_event, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, resp->timeout, NULL) != RT_EOK)
{
LOG_W("execute command (%.*s) timeout (%d ticks)!", client->last_cmd_len, client->send_buf, resp->timeout);
client->resp_status = AT_RESP_TIMEOUT;
result = -RT_ETIMEOUT;
}
else if (client->resp_status != AT_RESP_OK)
{
LOG_E("execute command (%.*s) failed!", client->last_cmd_len, client->send_buf);
result = -RT_ERROR;
}
}
client->resp = RT_NULL;
rt_mutex_release(&client->lock);
return result;
}
/**
* Send commands through custom formatting to AT server and wait response.
*
* @param client current AT client object
* @param resp AT response object, using RT_NULL when you don't care response
* @param format formatting macro, it can be one of these values: AT_END_CR_LF, AT_END_RAW, AT_END_CR, AT_END_LF.
* Behavior of AT_END_CR_LF is same as at_obj_exec_cmd, and it will add \r\n symnbol behind message.
* AT_END_RAW means frame work won't modify anything of message. AT_END_CR will add \r for Carriage
* Return. AT_END_LF means add \\n for Line Feed.
* @param cmd_expr AT commands expression
*
* @return 0 : success
* -1 : response status error
* -2 : wait timeout
* -7 : enter AT CLI mode
*/
int at_obj_exec_cmd_format(at_client_t client, at_response_t resp, const char *format, const char *cmd_expr, ...)
{
va_list args;
rt_err_t result = RT_EOK;
RT_ASSERT(cmd_expr);
if (client == RT_NULL)
{
LOG_E("input AT Client object is NULL, please create or get AT Client object!");
return -RT_ERROR;
}
/* check AT CLI mode */
if (client->status == AT_STATUS_CLI && resp)
{
return -RT_EBUSY;
}
rt_mutex_take(&client->lock, RT_WAITING_FOREVER);
client->resp_status = AT_RESP_OK;
if (resp != RT_NULL)
{
resp->buf_len = 0;
resp->line_counts = 0;
}
client->resp = resp;
rt_event_recv(&client->event, at_client_resp_notice_event, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 0, NULL);
va_start(args, cmd_expr);
if (strcmp(format, AT_END_CR_LF) == 0)
{
client->last_cmd_len = at_vprintfln(client->device, client->send_buf, client->send_bufsz, cmd_expr, args);
}
else if (strcmp(format, AT_END_RAW) == 0)
{
client->last_cmd_len = at_vprintf(client->device, client->send_buf, client->send_bufsz, cmd_expr, args);
}
else if (strcmp(format, AT_END_CR) == 0)
{
client->last_cmd_len = at_vprintfcr(client->device, client->send_buf, client->send_bufsz, cmd_expr, args);
}
else if (strcmp(format, AT_END_LF) == 0)
{
client->last_cmd_len = at_vprintflf(client->device, client->send_buf, client->send_bufsz, cmd_expr, args);
}
va_end(args);
if (resp != RT_NULL)
{
if (rt_event_recv(&client->event, at_client_resp_notice_event, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, resp->timeout, NULL) != RT_EOK)
{
LOG_W("execute command (%.*s) timeout (%d ticks)!", client->last_cmd_len, client->send_buf, resp->timeout);
client->resp_status = AT_RESP_TIMEOUT;
result = -RT_ETIMEOUT;
}
else if (client->resp_status != AT_RESP_OK)
{
LOG_E("execute command (%.*s) failed!", client->last_cmd_len, client->send_buf);
result = -RT_ERROR;
}
}
client->resp = RT_NULL;
rt_mutex_release(&client->lock);
return result;
}
/**
* Waiting for connection to external devices.
*
* @param client current AT client object
* @param timeout millisecond for timeout
*
* @return 0 : success
* -2 : timeout
* -5 : no memory
*/
int at_client_obj_wait_connect(at_client_t client, rt_uint32_t timeout)
{
rt_err_t result = RT_EOK;
at_response_t resp = RT_NULL;
rt_tick_t start_time = 0;
if (client == RT_NULL)
{
LOG_E("input AT client object is NULL, please create or get AT Client object!");
return -RT_ERROR;
}
resp = at_create_resp(64, 0, rt_tick_from_millisecond(300));
if (resp == RT_NULL)
{
LOG_E("no memory for AT client(%s) response object.", client->device->parent.name);
return -RT_ENOMEM;
}
start_time = rt_tick_get();
while (1)
{
/* Check whether it is timeout */
if (rt_tick_get() - start_time > rt_tick_from_millisecond(timeout))
{
LOG_E("wait AT client(%s) connect timeout(%d tick).", client->device->parent.name, timeout);
result = -RT_ETIMEOUT;
break;
}
if (at_obj_exec_cmd(client, resp, "AT") == RT_EOK)
{
break;
}
}
at_delete_resp(resp);
return result;
}
/**
* Send data to AT server, send data don't have end sign(eg: \r\n).
*
* @param client current AT client object
* @param buf send data buffer
* @param size send fixed data size
*
* @return >0: send data size
* =0: send failed
*/
rt_size_t at_client_obj_send(at_client_t client, const char *buf, rt_size_t size)
{
rt_size_t len;
RT_ASSERT(buf);
if (client == RT_NULL)
{
LOG_E("input AT Client object is NULL, please create or get AT Client object!");
return 0;
}
#ifdef AT_PRINT_RAW_CMD
at_print_raw_cmd("sendline", buf, size);
#endif
rt_mutex_take(&client->lock, RT_WAITING_FOREVER);
len = at_utils_send(client->device, 0, buf, size);
rt_mutex_release(&client->lock);
return len;
}
/**
* AT client receive fixed-length data.
*
* @param client current AT client 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 URC data
*
* @return >0: receive data size
* =0: receive failed
*/
rt_size_t at_client_obj_recv(at_client_t client, char *buf, rt_size_t size, rt_int32_t timeout)
{
rt_size_t read_idx = 0;
RT_ASSERT(buf);
if (client == RT_NULL)
{
LOG_E("input AT Client object is NULL, please create or get AT Client object!");
return 0;
}
#ifndef RT_USING_SERIAL_V2
while (size)
{
rt_size_t read_len;
rt_event_recv(&client->event, at_client_rx_notice_event, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 0, NULL);
read_len = rt_device_read(client->device, 0, buf + read_idx, size);
if (read_len > 0)
{
read_idx += read_len;
size -= read_len;
}
else
{
if (rt_event_recv(&client->event, at_client_rx_notice_event, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, rt_tick_from_millisecond(timeout), NULL) != RT_EOK)
break;
}
}
#else
rt_int32_t rx_timeout = rt_tick_from_millisecond(timeout);
rt_device_control(client->device, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&rx_timeout);
read_idx = rt_device_read(client->device, 0, buf, size);
rx_timeout = RT_WAITING_NO;
rt_device_control(client->device, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&rx_timeout);
#endif
#ifdef AT_PRINT_RAW_CMD
at_print_raw_cmd("urc_recv", buf, read_idx);
#endif
return read_idx;
}
/**
* AT client set end sign.
*
* @param client current AT client object
* @param ch the end sign, can not be used when it is '\0'
*/
void at_obj_set_end_sign(at_client_t client, char ch)
{
if (client == RT_NULL)
{
LOG_E("input AT Client object is NULL, please create or get AT Client object!");
return;
}
client->end_sign = ch;
}
/**
* set URC(Unsolicited Result Code) table
*
* @param client current AT client object
* @param table URC table
* @param size table size
*/
int at_obj_set_urc_table(at_client_t client, const struct at_urc *urc_table, rt_size_t table_sz)
{
rt_size_t idx;
if (client == RT_NULL)
{
LOG_E("input AT Client object is NULL, please create or get AT Client object!");
return -RT_ERROR;
}
for (idx = 0; idx < table_sz; idx++)
{
RT_ASSERT(urc_table[idx].cmd_prefix);
RT_ASSERT(urc_table[idx].cmd_suffix);
}
if (client->urc_table_size == 0)
{
client->urc_table = (struct at_urc_table *)rt_calloc(1, sizeof(struct at_urc_table));
if (client->urc_table == RT_NULL)
{
return -RT_ENOMEM;
}
client->urc_table[0].urc = urc_table;
client->urc_table[0].urc_size = table_sz;
client->urc_table_size++;
}
else
{
struct at_urc_table *new_urc_table = RT_NULL;
/* realloc urc table space */
new_urc_table = (struct at_urc_table *)rt_realloc(client->urc_table, client->urc_table_size * sizeof(struct at_urc_table) + sizeof(struct at_urc_table));
if (new_urc_table == RT_NULL)
{
return -RT_ENOMEM;
}
client->urc_table = new_urc_table;
client->urc_table[client->urc_table_size].urc = urc_table;
client->urc_table[client->urc_table_size].urc_size = table_sz;
client->urc_table_size++;
}
return RT_EOK;
}
/**
* get AT client object by AT device name.
*
* @dev_name AT client device name
*
* @return AT client object
*/
at_client_t at_client_get(const char *dev_name)
{
RT_ASSERT(dev_name);
rt_slist_t *node;
at_client_t client;
rt_base_t level = rt_hw_interrupt_disable();
rt_slist_for_each(node, &g_at_client_list)
{
client = rt_slist_entry(node, struct at_client, list);
if (rt_strcmp(client->device->parent.name, dev_name) == 0)
{
rt_hw_interrupt_enable(level);
return client;
}
}
rt_hw_interrupt_enable(level);
return RT_NULL;
}
/**
* get first AT client object in the table.
*
* @return AT client object
*/
at_client_t at_client_get_first(void)
{
at_client_t client = RT_NULL;
rt_base_t level = rt_hw_interrupt_disable();
if (!rt_slist_isempty(&g_at_client_list))
{
client = rt_slist_first_entry(&g_at_client_list, struct at_client, list);
}
rt_hw_interrupt_enable(level);
return client;
}
static const struct at_urc *get_urc_obj(at_client_t client)
{
rt_size_t i, j, prefix_len, suffix_len;
rt_size_t bufsz;
char *buffer = RT_NULL;
const struct at_urc *urc = RT_NULL;
struct at_urc_table *urc_table = RT_NULL;
if (client->urc_table == RT_NULL)
{
return RT_NULL;
}
buffer = client->recv_line_buf;
bufsz = client->recv_line_len;
for (i = 0; i < client->urc_table_size; i++)
{
for (j = 0; j < client->urc_table[i].urc_size; j++)
{
urc_table = client->urc_table + i;
urc = urc_table->urc + j;
prefix_len = rt_strlen(urc->cmd_prefix);
suffix_len = rt_strlen(urc->cmd_suffix);
if (bufsz < prefix_len + suffix_len)
{
continue;
}
if ((prefix_len ? !rt_strncmp(buffer, urc->cmd_prefix, prefix_len) : 1)
&& (suffix_len ? !rt_strncmp(buffer + bufsz - suffix_len, urc->cmd_suffix, suffix_len) : 1))
{
return urc;
}
}
}
return RT_NULL;
}
static rt_err_t at_client_getchar(at_client_t client, char *ch)
{
rt_err_t result = RT_EOK;
rt_ssize_t recvLen = 0;
/* Temporarily retain the distinction */
#ifndef RT_USING_SERIAL_V2
recvLen = rt_device_read(client->device, 0, ch, 1);
if (recvLen <= 0)
{
result = -RT_ERROR;
}
#else
recvLen = rt_device_read(client->device, 0, ch, 1);
if (recvLen != 1)
{
result = -RT_ERROR;
}
#endif
return result;
}
static int at_recv_readline(at_client_t client)
{
char ch = 0, last_ch = 0;
rt_bool_t is_full = RT_FALSE;
rt_uint32_t event;
rt_memset(client->recv_line_buf, 0x00, client->recv_bufsz);
client->recv_line_len = 0;
while (1)
{
event = 0;
rt_event_recv(&client->event, at_client_rx_notice_event | at_client_deInit_event,
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &event);
if (event & at_client_deInit_event)
{
rt_event_send(&client->event, at_client_deInit_over_event);
rt_thread_delete(rt_thread_self());
}
if (event & at_client_rx_notice_event)
{
while (RT_EOK == at_client_getchar(client, &ch))
{
if (client->recv_line_len < client->recv_bufsz)
{
client->recv_line_buf[client->recv_line_len++] = ch;
}
else
{
is_full = RT_TRUE;
}
/* is newline or URC data */
client->urc = get_urc_obj(client);
if (client->urc != RT_NULL || (ch == '\n' && last_ch == '\r')
|| (client->end_sign != 0 && ch == client->end_sign))
{
if (is_full)
{
LOG_E("read line failed. The line data length is out of buffer size(%d)!", client->recv_bufsz);
rt_memset(client->recv_line_buf, 0x00, client->recv_bufsz);
client->recv_line_len = 0;
return -RT_EFULL;
}
/* Since the buffer state is uncertain, we proactively clear it; the overhead is negligible. */
rt_event_send(&client->event, at_client_rx_notice_event);
goto __next;
}
last_ch = ch;
}
}
}
__next:
#ifdef AT_PRINT_RAW_CMD
at_print_raw_cmd("recvline", client->recv_line_buf, client->recv_line_len);
#endif
return client->recv_line_len;
}
static void client_parser(at_client_t client)
{
while (1)
{
if (at_recv_readline(client) > 0)
{
if (client->urc != RT_NULL)
{
/* current receive is request, try to execute related operations */
if (client->urc->func != RT_NULL)
{
client->urc->func(client, client->recv_line_buf, client->recv_line_len);
}
client->urc = RT_NULL;
}
else if (client->resp != RT_NULL)
{
at_response_t resp = client->resp;
char end_ch = client->recv_line_buf[client->recv_line_len - 1];
/* current receive is response */
client->recv_line_buf[client->recv_line_len - 1] = '\0';
if (resp->buf_len + client->recv_line_len < resp->buf_size)
{
/* copy response lines, separated by '\0' */
rt_memcpy(resp->buf + resp->buf_len, client->recv_line_buf, client->recv_line_len);
/* update the current response information */
resp->buf_len += client->recv_line_len;
resp->line_counts++;
}
else
{
client->resp_status = AT_RESP_BUFF_FULL;
LOG_E("Read response buffer failed. The Response buffer size is out of buffer size(%d)!", resp->buf_size);
}
/* check response result */
if ((client->end_sign != 0) && (end_ch == client->end_sign) && (resp->line_num == 0))
{
/* get the end sign, return response state END_OK.*/
client->resp_status = AT_RESP_OK;
}
else if (rt_memcmp(client->recv_line_buf, AT_RESP_END_OK, rt_strlen(AT_RESP_END_OK)) == 0
&& resp->line_num == 0)
{
/* get the end data by response result, return response state END_OK. */
client->resp_status = AT_RESP_OK;
}
else if (rt_strstr(client->recv_line_buf, AT_RESP_END_ERROR)
|| (rt_memcmp(client->recv_line_buf, AT_RESP_END_FAIL, rt_strlen(AT_RESP_END_FAIL)) == 0))
{
client->resp_status = AT_RESP_ERROR;
}
else if (resp->line_counts == resp->line_num && resp->line_num)
{
/* get the end data by response line, return response state END_OK.*/
client->resp_status = AT_RESP_OK;
}
else
{
continue;
}
client->resp = RT_NULL;
rt_event_send(&client->event, at_client_resp_notice_event);
}
else
{
LOG_D("unrecognized line: %.*s", client->recv_line_len, client->recv_line_buf);
}
}
}
}
static rt_err_t at_client_rx_ind(rt_device_t dev, rt_size_t size)
{
rt_slist_t *node;
at_client_t client;
if (size <= 0)
{
return RT_EOK;
}
rt_base_t level = rt_hw_interrupt_disable();
rt_slist_for_each(node, &g_at_client_list)
{
client = rt_slist_entry(node, struct at_client, list);
if (client->device == dev)
{
rt_event_send(&client->event, at_client_rx_notice_event);
break;
}
}
rt_hw_interrupt_enable(level);
return RT_EOK;
}
/* initialize the client object parameters */
static int at_client_para_init(at_client_t client)
{
#define AT_CLIENT_LOCK_NAME "at_c"
#define AT_CLIENT_EVENT_NAME "at_ce"
#define AT_CLIENT_THREAD_NAME "at_clnt"
int result = RT_EOK;
char name[RT_NAME_MAX];
rt_base_t level = rt_hw_interrupt_disable();
unsigned int at_client_num = rt_slist_len(&g_at_client_list);
rt_hw_interrupt_enable(level);
rt_snprintf(name, RT_NAME_MAX, "%s%d", AT_CLIENT_THREAD_NAME, at_client_num);
client->parser = rt_thread_create(name,
(void (*)(void *parameter))client_parser,
client,
1024 + 512,
RT_THREAD_PRIORITY_MAX / 3 - 1,
5);
if (client->parser == RT_NULL)
{
result = -RT_ENOMEM;
goto __exit;
}
rt_snprintf(name, RT_NAME_MAX, "%s%d", AT_CLIENT_LOCK_NAME, at_client_num);
rt_mutex_init(&client->lock, name, RT_IPC_FLAG_PRIO);
rt_snprintf(name, RT_NAME_MAX, "%s%d", AT_CLIENT_EVENT_NAME, at_client_num);
rt_event_init(&client->event, name, RT_IPC_FLAG_FIFO);
__exit:
return result;
}
/**
* AT client initialize.
*
* @param dev_name AT client device name
* @param recv_bufsz the maximum number of receive buffer length
* @param send_bufsz the maximum number of send command length
*
* @return 0 : initialize success
* -1 : initialize failed
* -5 : no memory
*/
int at_client_init(const char *dev_name, rt_size_t recv_bufsz, rt_size_t send_bufsz)
{
int result = RT_EOK;
rt_err_t open_result = RT_EOK;
at_client_t client = RT_NULL;
RT_ASSERT(dev_name);
RT_ASSERT(recv_bufsz > 0);
RT_ASSERT(send_bufsz > 0);
if (at_client_get(dev_name) != RT_NULL)
{
return result;
}
client = rt_malloc(sizeof(struct at_client) + recv_bufsz + send_bufsz);
if (client == RT_NULL)
{
result = -RT_ENOMEM;
goto __exit;
}
rt_memset(client, 0, sizeof(struct at_client) + recv_bufsz + send_bufsz);
client->status = AT_STATUS_UNINITIALIZED;
client->recv_bufsz = recv_bufsz;
client->recv_line_buf = ((char *)client) + sizeof(struct at_client);
client->send_bufsz = send_bufsz;
client->send_buf = ((char *)client) + sizeof(struct at_client) + client->recv_bufsz;
result = at_client_para_init(client);
if (result != RT_EOK)
{
goto __exit;
}
/* find and open command device */
client->device = rt_device_find(dev_name);
if (client->device)
{
RT_ASSERT(client->device->type == RT_Device_Class_Char);
#ifndef RT_USING_SERIAL_V2
/* using DMA mode first */
open_result = rt_device_open(client->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(client->device, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
}
RT_ASSERT(open_result == RT_EOK);
#else
open_result = rt_device_open(client->device, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
RT_ASSERT(open_result == RT_EOK);
rt_int32_t rx_timeout = RT_WAITING_NO;
rt_device_control(client->device, RT_SERIAL_CTRL_SET_RX_TIMEOUT, (void *)&rx_timeout);
#endif
}
else
{
LOG_E("AT client initialize failed! Not find the device(%s).", dev_name);
result = -RT_ERROR;
}
__exit:
if (result == RT_EOK)
{
rt_slist_init(&client->list);
rt_base_t level = rt_hw_interrupt_disable();
rt_slist_append(&g_at_client_list, &client->list);
rt_hw_interrupt_enable(level);
rt_device_set_rx_indicate(client->device, at_client_rx_ind);
client->status = AT_STATUS_INITIALIZED;
rt_thread_startup(client->parser);
LOG_I("AT client(V%s) on device %s initialize success.", AT_SW_VERSION, dev_name);
}
else
{
if (RT_NULL != client->parser)
{
rt_thread_delete(client->parser);
}
if (RT_NULL != client)
{
rt_free(client);
}
LOG_E("AT client(V%s) on device %s initialize failed(%d).", AT_SW_VERSION, dev_name, result);
}
return result;
}
int at_client_deInit(const char *dev_name)
{
int result = RT_EOK;
at_client_t client = RT_NULL;
RT_ASSERT(dev_name);
client = at_client_get(dev_name);
if (client == RT_NULL)
{
return RT_EOK;
}
rt_base_t level = rt_hw_interrupt_disable();
rt_slist_remove(&g_at_client_list, &client->list);
rt_hw_interrupt_enable(level);
rt_event_send(&client->event, at_client_deInit_event);
rt_event_recv(&client->event, at_client_deInit_over_event, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, NULL);
rt_event_detach(&client->event);
rt_mutex_detach(&client->lock);
result = rt_device_close(client->device);
rt_free(client);
return result;
}
#endif /* AT_USING_CLIENT */
View Git Blame Copy Permalink