hpw422移植新的sdk
This commit is contained in:
xushaoxiang
@@ -0,0 +1,200 @@
|
||||
#include "useruart.h"
|
||||
#include "xc_drv_uart.h"
|
||||
#include "xc_ring_buffer.h"
|
||||
|
||||
#if 1
|
||||
#define UART_RX_DATA_SIZE 1024
|
||||
#define UART_RX_IO GPIO_21
|
||||
static uint8_t uart_rx_data[UART_RX_DATA_SIZE] = {0x00};
|
||||
static xc_ring_buffer_t uart_rx_ring_buffer;
|
||||
uint8_t uart_handle = UART1_IDX;
|
||||
static unsigned int count_1 = 0;
|
||||
static unsigned int count_2 = 0;
|
||||
|
||||
void count_1_add(unsigned char add_len)
|
||||
{
|
||||
count_1 += add_len;
|
||||
}
|
||||
void count_2_add(unsigned char add_len)
|
||||
{
|
||||
count_2 += add_len;
|
||||
}
|
||||
|
||||
__RAM_CODE void uart1_Handler(uint8_t *buff, uint16_t len)
|
||||
{
|
||||
if (xc_ring_buffer_bytes_free(&uart_rx_ring_buffer))
|
||||
{
|
||||
xc_ring_buffer_write(&uart_rx_ring_buffer, buff, 1);
|
||||
count_1_add(1);
|
||||
}
|
||||
else
|
||||
{
|
||||
}
|
||||
count_2_add(1);
|
||||
}
|
||||
#endif
|
||||
|
||||
unsigned int hal_console_init(unsigned long baud_rate)
|
||||
{
|
||||
GPIO_InitCfg_t gpio_cfg = {0};
|
||||
|
||||
unsigned long xc_baud_rate = UART_BAUDRATE_115200; /*default baud rate 115200*/
|
||||
|
||||
switch (baud_rate)
|
||||
{
|
||||
case 2400:
|
||||
xc_baud_rate = UART_BAUDRATE_2400;
|
||||
break;
|
||||
case 4800:
|
||||
xc_baud_rate = UART_BAUDRATE_4800;
|
||||
break;
|
||||
case 9600:
|
||||
xc_baud_rate = UART_BAUDRATE_9600;
|
||||
break;
|
||||
case 12800:
|
||||
xc_baud_rate = UART_BAUDRATE_12800;
|
||||
break;
|
||||
case 14400:
|
||||
xc_baud_rate = UART_BAUDRATE_14400;
|
||||
break;
|
||||
case 19200:
|
||||
xc_baud_rate = UART_BAUDRATE_19200;
|
||||
break;
|
||||
case 23040:
|
||||
xc_baud_rate = UART_BAUDRATE_23040;
|
||||
break;
|
||||
case 38400:
|
||||
xc_baud_rate = UART_BAUDRATE_38400;
|
||||
break;
|
||||
case 57600:
|
||||
xc_baud_rate = UART_BAUDRATE_57600;
|
||||
break;
|
||||
case 115200:
|
||||
xc_baud_rate = UART_BAUDRATE_115200;
|
||||
break;
|
||||
case 128000:
|
||||
xc_baud_rate = UART_BAUDRATE_128000;
|
||||
break;
|
||||
case 230400:
|
||||
xc_baud_rate = UART_BAUDRATE_230400;
|
||||
break;
|
||||
case 256000:
|
||||
xc_baud_rate = UART_BAUDRATE_256000;
|
||||
break;
|
||||
case 460800:
|
||||
xc_baud_rate = UART_BAUDRATE_460800;
|
||||
break;
|
||||
case 921600:
|
||||
xc_baud_rate = UART_BAUDRATE_921600;
|
||||
break;
|
||||
case 1000000:
|
||||
xc_baud_rate = UART_BAUDRATE_1M;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
gpio_cfg.Mux = GPIO_Mux0;
|
||||
gpio_cfg.Pull = GPIO_PULLUP;
|
||||
gpio_cfg.Int = NOT_INT;
|
||||
|
||||
gpio_cfg.Pin = GPIO_20;
|
||||
gpio_cfg.Dir = GPIO_DIR_OUTPUT;
|
||||
gpio_cfg.FunSel = UART1_TX;
|
||||
xc_gpio_init(&gpio_cfg);
|
||||
|
||||
gpio_cfg.Pin = UART_RX_IO;
|
||||
gpio_cfg.Dir = GPIO_DIR_INPUT;
|
||||
gpio_cfg.FunSel = UART1_RX;
|
||||
xc_gpio_init(&gpio_cfg);
|
||||
|
||||
UART_InitCfg_t uart_cfg = {0};
|
||||
|
||||
uart_cfg.Parity = UART_PARITY_DISABLE;
|
||||
uart_cfg.StopBits = UART_TCR_STOP_1BITS;
|
||||
uart_cfg.WordLength = UART_DATA_8_BITS;
|
||||
uart_cfg.BaudRate = xc_baud_rate;
|
||||
uart_cfg.HardwareFlowControl = UART_HWFC_ENABLE;
|
||||
|
||||
xc_uart_init(uart_handle, &uart_cfg);
|
||||
|
||||
xc_uart_enable_rx_it(uart_handle);
|
||||
|
||||
if (uart_handle == UART0_IDX)
|
||||
{
|
||||
NVIC_EnableIRQ(UART0_IRQn);
|
||||
}
|
||||
else if (uart_handle == UART1_IDX)
|
||||
{
|
||||
NVIC_EnableIRQ(UART1_IRQn);
|
||||
}
|
||||
else if (uart_handle == UART2_IDX)
|
||||
{
|
||||
NVIC_EnableIRQ(UART2_IRQn);
|
||||
}
|
||||
|
||||
xc_ring_buffer_init(&uart_rx_ring_buffer, uart_rx_data, UART_RX_DATA_SIZE);
|
||||
xc_uart_register_receive_cb(UART1_IDX, uart1_Handler);
|
||||
|
||||
return (0);
|
||||
}
|
||||
unsigned int hal_console_get_rx_space(void)
|
||||
{
|
||||
return xc_ring_buffer_bytes_free(&uart_rx_ring_buffer);
|
||||
}
|
||||
|
||||
unsigned int hal_console_get_rx_data_length(void)
|
||||
{
|
||||
return xc_ring_buffer_bytes_available(&uart_rx_ring_buffer);
|
||||
}
|
||||
|
||||
void hal_console_clear_rx_fifo(void)
|
||||
{
|
||||
xc_ring_buffer_reset(&uart_rx_ring_buffer);
|
||||
}
|
||||
|
||||
unsigned int hal_console_write(unsigned char *buffer, unsigned int length)
|
||||
{
|
||||
unsigned int ret_val;
|
||||
|
||||
if ((length) && (buffer))
|
||||
{
|
||||
xc_uart_send_data(uart_handle, buffer, length);
|
||||
ret_val = length;
|
||||
}
|
||||
else
|
||||
ret_val = 0;
|
||||
|
||||
return (ret_val);
|
||||
}
|
||||
|
||||
unsigned int hal_console_read(unsigned int length, unsigned char *buffer)
|
||||
{
|
||||
unsigned int ret_val;
|
||||
|
||||
unsigned int read_number = 0;
|
||||
|
||||
unsigned int need_read_number = 0;
|
||||
|
||||
if ((length) && (buffer))
|
||||
{
|
||||
need_read_number = xc_ring_buffer_bytes_available(&uart_rx_ring_buffer);
|
||||
|
||||
if (need_read_number)
|
||||
{
|
||||
need_read_number = need_read_number < length ? need_read_number : length;
|
||||
|
||||
xc_ring_buffer_read(&uart_rx_ring_buffer, buffer, need_read_number, &read_number);
|
||||
|
||||
ret_val = read_number;
|
||||
}
|
||||
else
|
||||
{
|
||||
ret_val = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
ret_val = 0;
|
||||
|
||||
return (ret_val);
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
#ifndef _USER_UART_H
|
||||
#define _USER_UART_H
|
||||
|
||||
// int User_Uart_Init(unsigned long baud_rate);
|
||||
// int HAL_ConsoleWrite(int Length, unsigned char *Buffer);
|
||||
// int HAL_ConsoleRead(int Length, unsigned char *Buffer);
|
||||
// void HAL_UART_Int_Init(unsigned long baud_rate);
|
||||
// unsigned short HAL_UART_Int_Send(unsigned char *Data, unsigned short Length);
|
||||
// unsigned short HAL_UART_Int_Recv(unsigned char *Data, unsigned short Length);
|
||||
// unsigned short HAL_UART_Int_GetRxCount(void);
|
||||
// unsigned short HAL_UART_Int_GetRxFree(void);
|
||||
// void HAL_UART_Int_ClearRxFifo(void);
|
||||
|
||||
unsigned int hal_console_init(unsigned long baud_rate);
|
||||
unsigned int hal_console_write(unsigned char *buffer, unsigned int length);
|
||||
unsigned int hal_console_read(unsigned int length, unsigned char *buffer);
|
||||
unsigned int hal_console_get_rx_space(void);
|
||||
unsigned int hal_console_get_rx_data_length(void);
|
||||
void hal_console_clear_rx_fifo(void);
|
||||
|
||||
#define UART_BAUD_SET 115200
|
||||
#endif
|
||||
@@ -0,0 +1,139 @@
|
||||
|
||||
#define BTSTACK_FILE__ "xc_ring_buffer.h"
|
||||
#include "usr_server.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include "xc_ring_buffer.h"
|
||||
|
||||
#define ERROR_CODE_MEMORY_CAPACITY_EXCEEDED 0x07
|
||||
|
||||
uint32_t xc_min(uint32_t a, uint32_t b)
|
||||
{
|
||||
return a < b ? a : b;
|
||||
}
|
||||
|
||||
uint32_t xc_max(uint32_t a, uint32_t b)
|
||||
{
|
||||
return a > b ? a : b;
|
||||
}
|
||||
|
||||
// init ring buffer
|
||||
void xc_ring_buffer_init(xc_ring_buffer_t *ring_buffer, uint8_t *storage, uint32_t storage_size)
|
||||
{
|
||||
ring_buffer->storage = storage;
|
||||
ring_buffer->size = storage_size;
|
||||
xc_ring_buffer_reset(ring_buffer);
|
||||
}
|
||||
|
||||
void xc_ring_buffer_reset(xc_ring_buffer_t *ring_buffer)
|
||||
{
|
||||
ring_buffer->last_read_index = 0;
|
||||
ring_buffer->last_written_index = 0;
|
||||
ring_buffer->full = 0;
|
||||
}
|
||||
|
||||
uint32_t xc_ring_buffer_bytes_available(xc_ring_buffer_t *ring_buffer)
|
||||
{
|
||||
if (ring_buffer->full)
|
||||
return ring_buffer->size;
|
||||
int diff = ring_buffer->last_written_index - ring_buffer->last_read_index;
|
||||
if (diff >= 0)
|
||||
return diff;
|
||||
return diff + ring_buffer->size;
|
||||
}
|
||||
|
||||
// test if ring buffer is empty
|
||||
int xc_ring_buffer_empty(xc_ring_buffer_t *ring_buffer)
|
||||
{
|
||||
return xc_ring_buffer_bytes_available(ring_buffer) == 0u;
|
||||
}
|
||||
|
||||
//
|
||||
__RAM_CODE uint32_t xc_ring_buffer_bytes_free(xc_ring_buffer_t *ring_buffer)
|
||||
{
|
||||
return ring_buffer->size - xc_ring_buffer_bytes_available(ring_buffer);
|
||||
}
|
||||
|
||||
// add byte block to ring buffer,
|
||||
__RAM_CODE int xc_ring_buffer_write(xc_ring_buffer_t *ring_buffer, uint8_t *data, uint32_t data_length)
|
||||
{
|
||||
if (xc_ring_buffer_bytes_free(ring_buffer) < data_length)
|
||||
{
|
||||
return ERROR_CODE_MEMORY_CAPACITY_EXCEEDED;
|
||||
}
|
||||
|
||||
// simplify logic below by asserting data_length > 0
|
||||
if (data_length == 0u)
|
||||
return 0u;
|
||||
|
||||
uint32_t remaining_data_length = data_length;
|
||||
const uint8_t *remaining_data = data;
|
||||
|
||||
// copy first chunk
|
||||
unsigned int bytes_until_end = ring_buffer->size - ring_buffer->last_written_index;
|
||||
unsigned int bytes_to_copy = xc_min(bytes_until_end, remaining_data_length);
|
||||
(void)memcpy(&ring_buffer->storage[ring_buffer->last_written_index], remaining_data, bytes_to_copy);
|
||||
remaining_data_length -= bytes_to_copy;
|
||||
remaining_data += bytes_to_copy;
|
||||
|
||||
// update last written index
|
||||
ring_buffer->last_written_index += bytes_to_copy;
|
||||
if (ring_buffer->last_written_index == ring_buffer->size)
|
||||
{
|
||||
ring_buffer->last_written_index = 0;
|
||||
}
|
||||
|
||||
// copy second chunk
|
||||
if (remaining_data_length != 0)
|
||||
{
|
||||
(void)memcpy(&ring_buffer->storage[0], remaining_data, remaining_data_length);
|
||||
ring_buffer->last_written_index += remaining_data_length;
|
||||
}
|
||||
|
||||
// mark buffer as full
|
||||
if (ring_buffer->last_written_index == ring_buffer->last_read_index)
|
||||
{
|
||||
ring_buffer->full = 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// fetch data_length bytes from ring buffer
|
||||
__RAM_CODE void xc_ring_buffer_read(xc_ring_buffer_t *ring_buffer, uint8_t *data, uint32_t data_length, uint32_t *number_of_bytes_read)
|
||||
{
|
||||
// limit data to get and report
|
||||
uint32_t remaining_data_length = xc_min(data_length, xc_ring_buffer_bytes_available(ring_buffer));
|
||||
*number_of_bytes_read = remaining_data_length;
|
||||
|
||||
// simplify logic below by asserting remaining_data_length > 0
|
||||
if (remaining_data_length == 0u)
|
||||
return;
|
||||
|
||||
uint8_t *remaining_data = data;
|
||||
|
||||
// copy first chunk
|
||||
unsigned int bytes_until_end = ring_buffer->size - ring_buffer->last_read_index;
|
||||
unsigned int bytes_to_copy = xc_min(bytes_until_end, remaining_data_length);
|
||||
(void)memcpy(remaining_data, &ring_buffer->storage[ring_buffer->last_read_index],
|
||||
bytes_to_copy);
|
||||
remaining_data_length -= bytes_to_copy;
|
||||
remaining_data += bytes_to_copy;
|
||||
|
||||
// update last read index
|
||||
ring_buffer->last_read_index += bytes_to_copy;
|
||||
if (ring_buffer->last_read_index == ring_buffer->size)
|
||||
{
|
||||
ring_buffer->last_read_index = 0;
|
||||
}
|
||||
|
||||
// copy second chunk
|
||||
if (remaining_data_length != 0)
|
||||
{
|
||||
(void)memcpy(remaining_data, &ring_buffer->storage[0], remaining_data_length);
|
||||
ring_buffer->last_read_index += remaining_data_length;
|
||||
}
|
||||
|
||||
// clear full flag
|
||||
ring_buffer->full = 0;
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
#ifndef XC_RING_BUFFER_H
|
||||
#define XC_RING_BUFFER_H
|
||||
|
||||
#if defined __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
typedef struct xc_ring_buffer
|
||||
{
|
||||
uint8_t *storage;
|
||||
uint32_t size;
|
||||
uint32_t last_read_index;
|
||||
uint32_t last_written_index;
|
||||
uint8_t full;
|
||||
} xc_ring_buffer_t;
|
||||
|
||||
/* API_START */
|
||||
|
||||
/**
|
||||
* Init ring buffer
|
||||
* @param ring_buffer object
|
||||
* @param storage
|
||||
* @param storage_size in bytes
|
||||
*/
|
||||
void xc_ring_buffer_init(xc_ring_buffer_t *ring_buffer, uint8_t *storage, uint32_t storage_size);
|
||||
|
||||
/**
|
||||
* Reset ring buffer to initial state (empty)
|
||||
* @param ring_buffer object
|
||||
*/
|
||||
void xc_ring_buffer_reset(xc_ring_buffer_t *ring_buffer);
|
||||
|
||||
/**
|
||||
* Check if ring buffer is empty
|
||||
* @param ring_buffer object
|
||||
* @return TRUE if empty
|
||||
*/
|
||||
int xc_ring_buffer_empty(xc_ring_buffer_t *ring_buffer);
|
||||
|
||||
/**
|
||||
* Get number of bytes available for read
|
||||
* @param ring_buffer object
|
||||
* @return number of bytes available for read
|
||||
*/
|
||||
uint32_t xc_ring_buffer_bytes_available(xc_ring_buffer_t *ring_buffer);
|
||||
|
||||
/**
|
||||
* Get free space available for write
|
||||
* @param ring_buffer object
|
||||
* @return number of bytes available for write
|
||||
*/
|
||||
uint32_t xc_ring_buffer_bytes_free(xc_ring_buffer_t *ring_buffer);
|
||||
|
||||
/**
|
||||
* Write bytes into ring buffer
|
||||
* @param ring_buffer object
|
||||
* @param data to store
|
||||
* @param data_length
|
||||
* @return 0 if ok, ERROR_CODE_MEMORY_CAPACITY_EXCEEDED if not enough space in buffer
|
||||
*/
|
||||
int xc_ring_buffer_write(xc_ring_buffer_t *ring_buffer, uint8_t *data, uint32_t data_length);
|
||||
|
||||
/**
|
||||
* Read from ring buffer
|
||||
* @param ring_buffer object
|
||||
* @param buffer to store read data
|
||||
* @param length to read
|
||||
* @param number_of_bytes_read
|
||||
*/
|
||||
void xc_ring_buffer_read(xc_ring_buffer_t *ring_buffer, uint8_t *buffer, uint32_t length, uint32_t *number_of_bytes_read);
|
||||
|
||||
/* API_END */
|
||||
|
||||
#if defined __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user