PowLu/TencentOS-tiny
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add frame input type of at,update version to 2.4.0

Browse Source
This commit is contained in:
mculover666
2021-06-24 10:39:54 +08:00
parent a1cdea5741
commit 3aaafde714
7 changed files with 2346 additions and 2221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
board/BearPi_STM32L431RC/BSP/Src/stm32l4xx_it_module.c
View File

@@ -44,7 +44,11 @@
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
#if AT_INPUT_TYPE_FRAME_EN
#define UART_FRAME_BUFFER_MAX 1024
uint8_t uart_frame_buffer[UART_FRAME_BUFFER_MAX];
uint16_t uart_frame_buffer_index;
#endif /* AT_INPUT_TYPE_FRAME_EN */
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
@@ -290,6 +294,18 @@ void LPUART1_IRQHandler(void)
HAL_UART_IRQHandler(&hlpuart1);
tos_knl_irq_leave();
/* USER CODE BEGIN LPUART1_IRQn 1 */
#if AT_INPUT_TYPE_FRAME_EN
if (__HAL_UART_GET_FLAG(&hlpuart1, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&hlpuart1);
if (uart_frame_buffer_index != 0) {
tos_at_uart_input_frame(uart_frame_buffer, uart_frame_buffer_index);
uart_frame_buffer_index = 0;
memset(uart_frame_buffer, 0, sizeof(uart_frame_buffer));
}
}
#endif /* AT_INPUT_TYPE_FRAME_EN */
/* USER CODE END LPUART1_IRQn 1 */
}
@@ -300,7 +316,11 @@ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
extern uint8_t data;
if (huart->Instance == LPUART1) {
HAL_UART_Receive_IT(&hlpuart1, &data, 1);
#if AT_INPUT_TYPE_FRAME_EN
uart_frame_buffer[uart_frame_buffer_index++] = data;
#else
tos_at_uart_input_byte(data);
#endif /* AT_INPUT_TYPE_FRAME_EN */
}
}
/* USER CODE END 1 */

4
board/BearPi_STM32L431RC/BSP/Src/usart.c
View File

@@ -19,6 +19,7 @@
/* Includes ------------------------------------------------------------------*/
#include "usart.h"
#include "tos_at.h"
/* USER CODE BEGIN 0 */
uint8_t data;
@@ -48,6 +49,9 @@ void MX_LPUART1_UART_Init(void)
Error_Handler();
}
HAL_UART_Receive_IT(&hlpuart1, &data, 1);
#if AT_INPUT_TYPE_FRAME_EN
__HAL_UART_ENABLE_IT(&hlpuart1, UART_IT_IDLE);
#endif
}
/* USART1 init function */

2
board/BearPi_STM32L431RC/TOS-CONFIG/tos_config.h
View File

@@ -41,5 +41,7 @@
#define TOS_CFG_TIMER_AS_PROC 1u
#define TOS_CFG_MAIL_QUEUE_EN 1u
#endif

6
kernel/core/include/tos_version.h
View File

@@ -24,9 +24,9 @@
// patch is updated for patch changes/bug fixes that should not need user code changes
#define TOS_VERSION_MAJOR 0x02
#define TOS_VERSION_MINOR 0x03
#define TOS_VERSION_PATCH 0x01
#define TOS_VERSION "2.3.1"
#define TOS_VERSION_MINOR 0x04
#define TOS_VERSION_PATCH 0x00
#define TOS_VERSION "2.4.0"
#endif /* _TOS_VERSION_H_ */

30
net/at/include/tos_at.h
View File

@@ -32,6 +32,9 @@
#define AT_PARSER_TASK_STACK_SIZE 2048
#define AT_PARSER_TASK_PRIO 2
#define AT_INPUT_TYPE_FRAME_EN 0
#define AT_FRAME_LEN_MAIL_MAX 5
typedef enum at_status_en {
AT_STATUS_OK,
AT_STATUS_ERROR,
@@ -97,6 +100,10 @@ typedef struct at_echo_st {
int __is_fuzzy_match;
} at_echo_t;
typedef struct at_frame_len_mail_st {
uint16_t frame_len;
} at_frame_len_mail_t;
typedef void (*at_event_callback_t)(void);
typedef struct at_event_st {
@@ -123,7 +130,14 @@ typedef struct at_agent_st {
hal_uart_t uart;
k_mutex_t uart_tx_lock;
// k_mutex_t uart_rx_lock;
#if AT_INPUT_TYPE_FRAME_EN
k_mail_q_t uart_rx_frame_mail;
uint8_t *uart_rx_frame_mail_buffer;
uint16_t fifo_available_len;
#else
k_sem_t uart_rx_sem;
#endif /* AT_INPUT_TYPE_FRAME_EN */
k_chr_fifo_t uart_rx_fifo;
uint8_t *uart_rx_fifo_buffer;
} at_agent_t;
@@ -386,6 +400,20 @@ __API__ int tos_at_raw_data_send(at_echo_t *echo, uint32_t timeout, const uint8_
*/
__API__ int tos_at_raw_data_send_until(at_echo_t *echo, uint32_t timeout, const uint8_t *buf, size_t size);
#if AT_INPUT_TYPE_FRAME_EN
/**
* @brief Write amount bytes to the at uart.
* The function called by the uart interrupt, to put the data from the uart to the at framework.
*
* @attention None
*
* @param[in] pdata pointer of the uart received data.
* @param[in] len length of the uart received data.
*
* @return None
*/
__API__ void tos_at_uart_input_frame(uint8_t *pdata, uint16_t len);
#else
/**
* @brief Write byte to the at uart.
* The function called by the uart interrupt, to put the data from the uart to the at framework.
@@ -397,7 +425,7 @@ __API__ int tos_at_raw_data_send_until(at_echo_t *echo, uint32_t timeout, const
* @return None
*/
__API__ void tos_at_uart_input_byte(uint8_t data);
#endif
/**
* @brief A global lock provided by at framework.
* The lock usually used to make a atomic function.

145
net/at/src/tos_at.c
View File

@@ -46,11 +46,38 @@ __API__ int tos_at_global_lock_post(void)
return 0;
}
__STATIC__ int at_uart_getchar(uint8_t *data, k_tick_t timeout)
__STATIC__ int at_uart_getchar_from_fifo(uint8_t *data)
{
TOS_CPU_CPSR_ALLOC();
k_err_t err;
TOS_CPU_INT_DISABLE();
err = tos_chr_fifo_pop(&AT_AGENT->uart_rx_fifo, data);
TOS_CPU_INT_ENABLE();
return err;
}
__STATIC__ int at_uart_getchar(uint8_t *data, k_tick_t timeout)
{
#if AT_INPUT_TYPE_FRAME_EN
at_frame_len_mail_t frame_len_mail;
size_t mail_size;
if (AT_AGENT->fifo_available_len == 0) {
if (tos_mail_q_pend(&AT_AGENT->uart_rx_frame_mail, &frame_len_mail, &mail_size, timeout) != K_ERR_NONE) {
return -1;
}
AT_AGENT->fifo_available_len = frame_len_mail.frame_len;
}
if (at_uart_getchar_from_fifo(data) != K_ERR_NONE) {
return -1;
}
AT_AGENT->fifo_available_len -= 1;
return 0;
#else
tos_stopwatch_delay(1);
if (tos_sem_pend(&AT_AGENT->uart_rx_sem, timeout) != K_ERR_NONE) {
@@ -67,15 +94,14 @@ __STATIC__ int at_uart_getchar(uint8_t *data, k_tick_t timeout)
// return -1;
// }
TOS_CPU_INT_DISABLE();
err = tos_chr_fifo_pop(&AT_AGENT->uart_rx_fifo, data);
TOS_CPU_INT_ENABLE();
if (at_uart_getchar_from_fifo(data) != K_ERR_NONE) {
return -1;
}
// tos_mutex_post(&AT_AGENT->uart_rx_lock);
return err == K_ERR_NONE ? 0 : -1;
return 0;
#endif /* AT_INPUT_TYPE_FRAME_EN */
}
__STATIC__ at_event_t *at_event_do_get(char *buffer, size_t buffer_len)
@@ -228,9 +254,9 @@ __STATIC__ at_parse_status_t at_uart_line_parse(void)
continue;
}
if (data == '\0') {
continue;
}
// if (data == '\0') {
// continue;
// }
if (curr_len < recv_cache->buffer_size) {
recv_cache->buffer[curr_len++] = data;
@@ -257,11 +283,11 @@ __STATIC__ at_parse_status_t at_uart_line_parse(void)
}
if (data == '\n' && last_data == '\r') { // 0xd 0xa
curr_len -= 1;
recv_cache->buffer[curr_len - 1] = '\n';
recv_cache->recv_len = curr_len;
// curr_len -= 1;
// recv_cache->buffer[curr_len - 1] = '\n';
// recv_cache->recv_len = curr_len;
if (curr_len == 1) { // only a blank newline, ignore
if (curr_len == 2) { // only a blank newline, ignore
last_data = 0;
curr_len = 0;
recv_cache->recv_len = 0;
@@ -475,7 +501,7 @@ __STATIC__ int at_cmd_do_exec(const char *format, va_list args)
cmd_len = vsnprintf(AT_AGENT->cmd_buf, AT_CMD_BUFFER_SIZE, format, args);
printf("AT CMD:\n%s\n", AT_AGENT->cmd_buf);
tos_kprintln("AT CMD:\n%s\n", AT_AGENT->cmd_buf);
at_uart_send((uint8_t *)AT_AGENT->cmd_buf, cmd_len, 0xFFFF);
@@ -927,48 +953,70 @@ __API__ int tos_at_init(hal_uart_port_t uart_port, at_event_t *event_table, size
goto errout2;
}
if (tos_sem_create(&AT_AGENT->uart_rx_sem, (k_sem_cnt_t)0u) != K_ERR_NONE) {
#if AT_INPUT_TYPE_FRAME_EN
buffer = tos_mmheap_alloc(AT_FRAME_LEN_MAIL_MAX * sizeof(at_frame_len_mail_t));
if (!buffer) {
goto errout3;
}
AT_AGENT->uart_rx_frame_mail_buffer = (uint8_t *)buffer;
if (tos_mail_q_create(&AT_AGENT->uart_rx_frame_mail, buffer, AT_FRAME_LEN_MAIL_MAX, sizeof(at_frame_len_mail_t)) != K_ERR_NONE) {
goto errout4;
}
#else
if (tos_sem_create(&AT_AGENT->uart_rx_sem, (k_sem_cnt_t)0u) != K_ERR_NONE) {
goto errout3;
}
#endif /* AT_INPUT_TYPE_FRAME_EN */
// if (tos_mutex_create(&AT_AGENT->uart_rx_lock) != K_ERR_NONE) {
// goto errout4;
// goto errout5;
// }
if (tos_mutex_create(&AT_AGENT->uart_tx_lock) != K_ERR_NONE) {
goto errout5;
goto errout6;
}
if (tos_mutex_create(&AT_AGENT->global_lock) != K_ERR_NONE) {
goto errout7;
}
if (tos_hal_uart_init(&AT_AGENT->uart, uart_port) != 0) {
goto errout8;
}
if (tos_task_create(&AT_AGENT->parser, "at_parser", at_parser,
K_NULL, AT_PARSER_TASK_PRIO, at_parser_task_stack,
AT_PARSER_TASK_STACK_SIZE, 0) != K_ERR_NONE) {
goto errout6;
}
if (tos_hal_uart_init(&AT_AGENT->uart, uart_port) != 0) {
goto errout7;
}
if (tos_mutex_create(&AT_AGENT->global_lock) != K_ERR_NONE) {
goto errout8;
goto errout9;
}
return 0;
errout8:
errout9:
tos_hal_uart_deinit(&AT_AGENT->uart);
errout7:
tos_task_destroy(&AT_AGENT->parser);
errout8:
tos_mutex_destroy(&AT_AGENT->global_lock);
errout6:
errout7:
tos_mutex_destroy(&AT_AGENT->uart_tx_lock);
errout5:
errout6:
// tos_mutex_destroy(&AT_AGENT->uart_rx_lock);
//errout4:
//errout5:
#if AT_INPUT_TYPE_FRAME_EN
tos_mail_q_destroy(&AT_AGENT->uart_rx_frame_mail);
#else
tos_sem_destroy(&AT_AGENT->uart_rx_sem);
#endif /* AT_INPUT_TYPE_FRAME_EN */
#if AT_INPUT_TYPE_FRAME_EN
errout4:
tos_mmheap_free(AT_AGENT->uart_rx_frame_mail_buffer);
AT_AGENT->uart_rx_frame_mail_buffer = K_NULL;
#endif /* AT_INPUT_TYPE_FRAME_EN */
errout3:
at_recv_cache_deinit();
@@ -990,15 +1038,23 @@ errout0:
__API__ void tos_at_deinit(void)
{
tos_mutex_destroy(&AT_AGENT->global_lock);
tos_task_destroy(&AT_AGENT->parser);
tos_hal_uart_deinit(&AT_AGENT->uart);
tos_task_destroy(&AT_AGENT->parser);
tos_mutex_destroy(&AT_AGENT->global_lock);
tos_mutex_destroy(&AT_AGENT->uart_tx_lock);
//tos_mutex_destroy(&AT_AGENT->uart_tx_lock);
#if AT_INPUT_TYPE_FRAME_EN
tos_mail_q_destroy(&AT_AGENT->uart_rx_frame_mail);
tos_mmheap_free(AT_AGENT->uart_rx_frame_mail_buffer);
AT_AGENT->uart_rx_frame_mail_buffer = K_NULL;
#else
tos_sem_destroy(&AT_AGENT->uart_rx_sem);
#endif /* AT_INPUT_TYPE_FRAME_EN */
at_recv_cache_deinit();
@@ -1017,10 +1073,25 @@ __API__ void tos_at_deinit(void)
/* To completely decouple the uart intterupt and at agent, we need a more powerful
hal(driver framework), that would be a huge work, we place it in future plans. */
#if AT_INPUT_TYPE_FRAME_EN
__API__ void tos_at_uart_input_frame(uint8_t *pdata, uint16_t len)
{
int ret;
at_frame_len_mail_t at_frame_len_mail;
ret = tos_chr_fifo_push_stream(&AT_AGENT->uart_rx_fifo, pdata, len);
if (ret != len) {
return;
}
at_frame_len_mail.frame_len = len;
tos_mail_q_post(&AT_AGENT->uart_rx_frame_mail, &at_frame_len_mail, sizeof(at_frame_len_mail_t));
}
#else
__API__ void tos_at_uart_input_byte(uint8_t data)
{
if (tos_chr_fifo_push(&AT_AGENT->uart_rx_fifo, data) == K_ERR_NONE) {
tos_sem_post(&AT_AGENT->uart_rx_sem);
}
}
#endif /* AT_INPUT_TYPE_FRAME_EN */