add uart driver

Signed-off-by: huhui <huhui@sharkgulf.com>

Applications/bsp/icm20602.c

@@ -1,39 +0,0 @@
-#include "libs/os.h"
-#include "bsp/bsp.h"
-#include "bsp/icm20602.h"
-#include "libs/logger.h"
-
-#define i2c_addr		0xD0
-
-#define ICM_WHO_AM_I 0x75
-
-static void icm_check_device(void);
-static int icm_i2c_read_bytes(u8 reg, u8* data, u8 length);
-
-void icm20602_init(void){
-	icm_check_device();
-}
-
-static void icm_check_device(void)
-{
-	u8 data = 0;
-	icm_i2c_read_bytes(ICM_WHO_AM_I, &data,1);
-	sys_debug("%d\n", data);
-}
-
-#if 0
-int icm_i2c_write_byte(u8 reg, u8 data)
-{ 
-   return shark_i2c_write_byte(1, i2c_addr, reg, data);
-}
-
-int icm_i2c_write_nbytes(u8 reg, u8* data, u8 length)
-{
-	return shark_i2c_write_nbytes(1 ,i2c_addr, reg, data, length);
-}
-#endif
-static int icm_i2c_read_bytes(u8 reg, u8* data, u8 length)
-{
-	return shark_i2c_read_nbytes(1 ,i2c_addr, reg, data, length);
-}
-

Applications/bsp/uart.c

@@ -0,0 +1,472 @@
+#include "uart.h"
+#include "libs/os.h"
+#include "libs/task.h"
+#include "libs/crc16.h"
+#include "libs/logger.h"
+
+#define SHARK_UART_BAUDRATE				38400
+
+#define SHARK_UART0_com					UART3
+#define SHARK_UART0_tx_port				GPIOB
+#define SHARK_UART0_tx_pin				GPIO_PIN_10
+#define SHARK_UART0_rx_port				GPIOB
+#define SHARK_UART0_rx_pin				GPIO_PIN_11
+#define SHARK_UART0_irq					UART3_IRQn
+#define SHARK_UART0_clk					RCU_USART0
+#define SHARK_UART0_tx_gpio_clk			RCU_GPIOB
+#define SHARK_UART0_rx_gpio_clk			RCU_GPIOB
+#define SHARK_UART0_tx_dma				DMA1
+#define SHARK_UART0_tx_dma_ch			DMA_CH4
+#define SHARK_UART0_tx_dma_clk			RCU_DMA1
+#define SHARK_UART0_rx_dma				DMA1
+#define SHARK_UART0_rx_dma_ch			DMA_CH2
+#define SHARK_UART0_rx_dma_clk			RCU_DMA1
+
+
+// ================================================================================
+#define ENABLE_RX_DMA 1
+#define UART_NUM 1
+static u8 shark_uart0_tx_cache[SHARK_UART_TX_MEM_SIZE];
+#if UART_NUM==2
+static u8 shark_uart1_tx_cache[SHARK_UART_TX_MEM_SIZE];
+#endif
+
+static u8 shark_uart0_rx_cache[SHARK_UART_RX_MEM_SIZE];
+#if UART_NUM==2
+static u8 shark_uart1_rx_cache[SHARK_UART_RX_MEM_SIZE];
+#endif
+
+static shark_uart_t _shark_uart[1];
+static task_t _uart_task;
+///static bool uart_no_data = false;
+#if ENABLE_RX_DMA==1
+#define update_dma_w_pos(uart) circle_update_write_position(&uart->rx_queue, SHARK_UART_RX_MEM_SIZE - DMA_CHCNT(SHARK_UART0_rx_dma, uart->rx_dma_ch))
+#else
+#define update_dma_w_pos(uart){}
+#endif
+
+// ================================================================================
+static uart_enum_t _uart_index(uint32_t com){
+	return com == SHARK_UART0_com?SHARK_UART0:SHARK_UART1;
+}
+static bool shark_uart_on_rx_frame(shark_uart_t *uart)
+{
+	u16 crc0 = DECODE_U16(uart->rx_frame + uart->rx_length);
+	u16 crc1 = crc16_get(uart->rx_frame, uart->rx_length);
+
+	if (crc0 != crc1) {
+		return false;
+	}
+	//protocol_recv_frame(_uart_index(uart->uart_com), (char *)uart->rx_frame, uart->rx_length);
+	return true;
+}
+
+static void shark_uart_rx(shark_uart_t *uart){
+	while(1) {
+		u8 data;
+		update_dma_w_pos(uart);
+		if (circle_get_one_data(&uart->rx_queue, &data) != 1) {
+			break;
+		}
+		switch(data){
+			case CH_START:
+				uart->rx_length = 0;
+				uart->escape = false;
+				uart->start = true;
+				break;
+			case CH_END:
+				if (uart->rx_length > 2 && uart->rx_length != 0xFFFF){
+					uart->rx_length -= 2; //skip crc
+					shark_uart_on_rx_frame(uart);
+				}
+				uart->rx_length = 0xFFFF;
+				uart->start = false;
+				break;
+			case CH_ESC:
+				uart->escape = true;
+				break;
+			default:
+				if (uart->escape) {
+					uart->escape = false;
+					switch (data) {
+						case CH_ESC_START:
+							data = CH_START;
+							break;
+
+						case CH_ESC_END:
+							data = CH_END;
+							break;
+
+						case CH_ESC_ESC:
+							data = CH_ESC;
+							break;
+
+						default:
+							data = 0xFF;
+					}
+				}
+
+				if (uart->rx_length < sizeof(uart->rx_frame)) {
+					uart->rx_frame[uart->rx_length] = data;
+					uart->rx_length++;
+				} else {
+					uart->rx_length = 0xFFFF;
+				}			
+		}
+	}
+}
+
+
+static void shark_uart_dma_tx(shark_uart_t *uart)
+{
+	u32 value = DMA_CHCTL(SHARK_UART0_tx_dma, uart->tx_dma_ch);
+
+	if (value & DMA_CHXCTL_CHEN) {
+		if (SET != dma_flag_get(SHARK_UART0_tx_dma, uart->tx_dma_ch, DMA_FLAG_FTF)) {
+			return;
+		}
+
+		byte_queue_skip(&uart->tx_queue, uart->tx_length);
+		DMA_CHCTL(SHARK_UART0_tx_dma, uart->tx_dma_ch) = value & (~DMA_CHXCTL_CHEN);
+	}
+
+	uart->tx_length = byte_queue_peek(&uart->tx_queue);
+	if (uart->tx_length > 0) {
+		DMA_CHCNT(SHARK_UART0_tx_dma, uart->tx_dma_ch) = uart->tx_length;
+		DMA_CHMADDR(SHARK_UART0_tx_dma, uart->tx_dma_ch) = (u32) byte_queue_head(&uart->tx_queue);
+
+		dma_flag_clear(SHARK_UART0_tx_dma, uart->tx_dma_ch, DMA_FLAG_FTF);
+		DMA_CHCTL(SHARK_UART0_tx_dma, uart->tx_dma_ch) = value | DMA_CHXCTL_CHEN;
+	}
+}
+
+
+
+static void shark_uart_write(shark_uart_t *uart, const u8 *buff, u16 size)
+{
+	while (size > 0) {
+		u16 length = byte_queue_write(&uart->tx_queue, buff, size);
+
+		if (length == size) {
+			shark_uart_dma_tx(uart);
+			break;
+		}
+
+		shark_uart_dma_tx(uart);
+		buff += length;
+		size -= length;
+	}
+}
+
+static void shark_uart_write_byte(shark_uart_t *uart, u8 value)
+{
+	shark_uart_write(uart, &value, 1);
+}
+
+
+static void shark_uart_tx_dma_init(shark_uart_t *uart){
+	dma_parameter_struct dma_init_struct;
+	rcu_periph_clock_enable(_uart_index(uart->uart_com)== SHARK_UART0?SHARK_UART0_tx_dma_clk:SHARK_UART0_tx_dma_clk);
+	dma_deinit(SHARK_UART0_tx_dma, uart->tx_dma_ch);
+	dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
+	dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
+	dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
+	dma_init_struct.periph_addr = (u32) &USART_DATA(uart->uart_com);
+	dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
+	dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
+	dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
+	dma_init(SHARK_UART0_tx_dma, uart->tx_dma_ch, &dma_init_struct);
+	dma_circulation_disable(SHARK_UART0_tx_dma, uart->tx_dma_ch);
+	dma_memory_to_memory_disable(SHARK_UART0_tx_dma, uart->tx_dma_ch);
+	usart_dma_transmit_config(uart->uart_com, USART_DENT_ENABLE);
+#if 0
+	if (uart->tx_dma_ch == DMA_CH1) {
+		nvic_irq_enable(DMA_Channel1_2_IRQn ,4, 0);
+	}else {
+		nvic_irq_enable(DMA_Channel3_4_IRQn ,4, 0);
+	}
+	dma_interrupt_enable(uart->tx_dma_ch, DMA_INT_FTF);
+#endif
+}
+
+#if ENABLE_RX_DMA==1
+static void shark_uart_rx_dma_init(shark_uart_t *uart){
+	dma_parameter_struct dma_init_struct;
+	rcu_periph_clock_enable(_uart_index(uart->uart_com)== SHARK_UART0?SHARK_UART0_rx_dma_clk:SHARK_UART0_rx_dma_clk);
+	dma_deinit(SHARK_UART0_rx_dma, uart->rx_dma_ch);
+	dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
+	dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
+	dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
+	dma_init_struct.memory_addr = (u32)uart->rx_queue.buffer;
+	dma_init_struct.number = uart->rx_queue.buffer_len;
+	dma_init_struct.periph_addr = (u32) &USART_DATA(uart->uart_com);
+	dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
+	dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
+	dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
+	dma_init(SHARK_UART0_rx_dma, uart->rx_dma_ch, &dma_init_struct);
+	dma_circulation_enable(SHARK_UART0_rx_dma, uart->rx_dma_ch);
+	dma_memory_to_memory_disable(SHARK_UART0_rx_dma, uart->rx_dma_ch);
+	dma_channel_enable(SHARK_UART0_rx_dma, uart->rx_dma_ch);
+	usart_dma_receive_config(uart->uart_com, USART_DENR_ENABLE);
+}
+#endif
+static void shark_uart_pin_init(shark_uart_t *uart){
+	rcu_periph_clock_enable(SHARK_UART0_clk);
+	rcu_periph_clock_enable(SHARK_UART0_rx_gpio_clk);
+	rcu_periph_clock_enable(SHARK_UART0_tx_gpio_clk);
+	gpio_init(SHARK_UART0_tx_port, GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,SHARK_UART0_tx_pin);
+	gpio_init(SHARK_UART0_rx_port, GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,SHARK_UART0_rx_pin);
+}
+
+static void shark_uart_pin_deinit(shark_uart_t *uart){
+	if (_uart_index(uart->uart_com) == SHARK_UART0) {
+		gpio_init(SHARK_UART0_tx_port, GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,SHARK_UART0_tx_pin);
+		gpio_init(SHARK_UART0_rx_port, GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,SHARK_UART0_rx_pin);
+	}
+}
+
+
+static void shark_uart_device_init(shark_uart_t *uart){
+	usart_deinit(uart->uart_com);
+	usart_baudrate_set(uart->uart_com, SHARK_UART_BAUDRATE);
+
+	usart_word_length_set(uart->uart_com, USART_WL_8BIT);
+	usart_stop_bit_set(uart->uart_com, USART_STB_1BIT);
+	usart_parity_config(uart->uart_com, USART_PM_NONE);
+	usart_hardware_flow_rts_config(uart->uart_com, USART_RTS_DISABLE);
+	usart_hardware_flow_cts_config(uart->uart_com, USART_CTS_DISABLE);
+	usart_receive_config(uart->uart_com, USART_RECEIVE_ENABLE);
+	usart_transmit_config(uart->uart_com, USART_TRANSMIT_ENABLE);
+
+#if ENABLE_RX_DMA==0
+	usart_lin_mode_disable(uart->uart_com);
+	usart_receiver_timeout_disable(uart->uart_com);
+	usart_interrupt_enable(uart->uart_com,USART_INT_RBNE);
+#endif
+}
+
+static u32 shark_uart_handler(void)
+{
+	shark_uart_t *uart = _shark_uart + SHARK_UART0;
+	if (uart->uart_com != 0) {
+		shark_uart_rx(uart);
+		shark_uart_dma_tx(uart);
+	}
+#if UART_NUM==2	
+	uart = _shark_uart + SHARK_UART1;
+	if (uart->uart_com != 0) {
+		shark_uart_rx(uart);
+		shark_uart_dma_tx(uart);
+	}
+#endif	
+	return 0;
+}
+
+
+void shark_uart_flush(void){
+	shark_uart_t *uart = _shark_uart + SHARK_UART0;
+	if (uart->uart_com != 0) {
+		while(!byte_queue_empty(&uart->tx_queue)) {
+			shark_uart_dma_tx(uart);
+		}
+	}
+#if UART_NUM==2	
+	uart = _shark_uart + SHARK_UART1;
+	if (uart->uart_com != 0) {
+		while(!byte_queue_empty(&uart->tx_queue)) {
+			shark_uart_dma_tx(uart);
+		}
+	}
+#endif	
+}
+
+
+#if 0
+void DMA_Channel1_2_IRQHandler(void){
+	shark_uart_t *uart = _shark_uart + SHARK_UART0;
+	if (dma_interrupt_flag_get(uart->tx_dma_ch, DMA_INT_FLAG_FTF) != RESET){
+		shark_uart_dma_tx(uart);
+		dma_interrupt_flag_clear(uart->tx_dma_ch, DMA_INT_FLAG_FTF);
+	}
+}
+
+void DMA_Channel3_4_IRQHandler(void){
+	shark_uart_t *uart = _shark_uart + SHARK_UART1;
+	if (dma_interrupt_flag_get(uart->tx_dma_ch, DMA_INT_FLAG_FTF) != RESET){
+		shark_uart_dma_tx(uart);
+		dma_interrupt_flag_clear(uart->tx_dma_ch, DMA_INT_FLAG_FTF);
+	}
+}
+#endif
+
+static u8 *tx_cache_addr(uart_enum_t uart_no){
+#if UART_NUM==2
+	return (uart_no == SHARK_UART0)?shark_uart0_tx_cache:shark_uart1_tx_cache;
+#else
+	return shark_uart0_tx_cache;
+#endif
+}
+
+static u8 *rx_cache_addr(uart_enum_t uart_no){
+#if UART_NUM==2
+	return (uart_no == SHARK_UART0)?shark_uart0_rx_cache:shark_uart1_rx_cache;
+#else
+	return shark_uart0_rx_cache;
+#endif
+}
+
+
+void shark_uart_deinit(uart_enum_t uart_no){
+	shark_uart_t *uart = _shark_uart + uart_no;
+	if (uart->uart_com != 0) {
+		usart_disable(uart->uart_com);
+		usart_deinit(uart->uart_com);
+		rcu_periph_clock_disable(uart_no == SHARK_UART0?SHARK_UART0_clk:SHARK_UART0_clk);
+		dma_channel_disable(SHARK_UART0_rx_dma, uart->rx_dma_ch);
+		dma_channel_disable(SHARK_UART0_tx_dma, uart->tx_dma_ch);
+		rcu_periph_clock_disable(uart_no == SHARK_UART0?SHARK_UART0_tx_dma_clk:SHARK_UART0_tx_dma_clk);
+		rcu_periph_clock_disable(uart_no == SHARK_UART0?SHARK_UART0_rx_dma_clk:SHARK_UART0_rx_dma_clk);
+		shark_uart_pin_deinit(uart);
+	}
+	if (uart_no == SHARK_UART0) {
+#if ENABLE_RX_DMA==0
+		nvic_irq_disable(USART0_IRQn);
+#endif
+	}else {
+#if ENABLE_RX_DMA==0
+		nvic_irq_disable(USART1_IRQn);
+#endif
+	}
+}
+
+
+bool shark_uart_timeout(void){
+#if UART_NUM==2	
+	return (_shark_uart[0].uart_no_data && _shark_uart[1].uart_no_data)?TRUE:FALSE;
+#else
+	return (_shark_uart[0].uart_no_data)?TRUE:FALSE;
+#endif
+}
+void shark_uart_init(uart_enum_t uart_no)
+{
+	shark_uart_t *uart = _shark_uart + uart_no;
+	uart->escape = false;
+	uart->rx_length = 0;
+	uart->tx_length = 0;
+	uart->uart_com = (uart_no == SHARK_UART0)?SHARK_UART0_com:SHARK_UART0_com;
+
+	circle_buffer_init(&uart->rx_queue, rx_cache_addr(uart_no), SHARK_UART_RX_MEM_SIZE);
+	byte_queue_init(&uart->tx_queue,tx_cache_addr(uart_no), SHARK_UART_TX_MEM_SIZE);
+
+	uart->rx_dma_ch = (uart_no == SHARK_UART0)?SHARK_UART0_rx_dma_ch:SHARK_UART0_rx_dma_ch;
+	uart->tx_dma_ch = (uart_no == SHARK_UART0)?SHARK_UART0_tx_dma_ch:SHARK_UART0_tx_dma_ch;
+
+	shark_uart_pin_init(uart);
+	shark_uart_device_init(uart);
+#if ENABLE_RX_DMA==1
+	shark_uart_rx_dma_init(uart);
+#endif
+	shark_uart_tx_dma_init(uart);
+	usart_enable(uart->uart_com);
+	
+	if (_uart_task.handler == NULL) {
+		_uart_task.handler = shark_uart_handler;
+		task_add(&_uart_task);
+	}
+	if (uart_no == SHARK_UART0) {
+#if ENABLE_RX_DMA==0
+		nvic_irq_enable(UART3_IRQn, 3, 0);
+#endif
+	}else {
+#if ENABLE_RX_DMA==0
+		nvic_irq_enable(USART1_IRQn, 3, 0);
+#endif
+	}
+	uart->uart_no_data = false;
+}
+
+#if ENABLE_RX_DMA==0
+void USART3_IRQHandler(void){
+	if(usart_flag_get(USART0, USART_FLAG_RBNE) == SET){
+		shark_uart_t *uart = _shark_uart + SHARK_UART0;
+		u8 c = usart_data_receive(USART0);
+		circle_put_one_data(&uart->rx_queue, c);
+	}
+}
+#endif
+
+static void shark_uart_write_byte_esc(shark_uart_t *uart, u8 value)
+{
+	switch (value) {
+	case CH_START:
+		shark_uart_write_byte(uart, CH_ESC);
+		value = CH_ESC_START;
+		break;
+
+	case CH_END:
+		shark_uart_write_byte(uart, CH_ESC);
+		value = CH_ESC_END;
+		break;
+
+	case CH_ESC:
+		shark_uart_write_byte(uart, CH_ESC);
+		value = CH_ESC_ESC;
+		break;
+	}
+
+	shark_uart_write_byte(uart, value);
+}
+
+static void shark_uart_write_esc(shark_uart_t *uart, const u8 *buff, u16 length)
+{
+	const u8 *buff_end;
+
+	for (buff_end = buff + length; buff < buff_end; buff++) {
+		shark_uart_write_byte_esc(uart, *buff);
+	}
+}
+
+static void shark_uart_tx_start(shark_uart_t *uart)
+{
+	shark_uart_write_byte(uart, CH_START);
+	uart->tx_crc16 = 0;
+}
+
+static void shark_uart_tx_continue(shark_uart_t *uart, const void *buff, u16 length)
+{
+	shark_uart_write_esc(uart, (const u8 *) buff, length);
+	uart->tx_crc16 = crc16_update(uart->tx_crc16, (const u8 *) buff, length);
+}
+
+static void shark_uart_tx_end(shark_uart_t *uart)
+{
+	shark_uart_write_esc(uart, (u8 *)&uart->tx_crc16, sizeof(uart->tx_crc16));
+	shark_uart_write_byte(uart, CH_END);
+}
+
+void shark_uart_write_frame(uart_enum_t uart_no, uint8_t *bytes, int len){
+	shark_uart_t *uart = _shark_uart + uart_no;
+	shark_uart_tx_start(uart);
+	shark_uart_tx_continue(uart, bytes, len);
+	shark_uart_tx_end(uart);
+}
+
+void shark_uart_frame_start(uart_enum_t uart_no, uint8_t *bytes, int len){
+	shark_uart_t *uart = _shark_uart + uart_no;
+	shark_uart_tx_start(uart);
+	shark_uart_tx_continue(uart, bytes, len);
+}
+
+void shark_uart_frame_continue(uart_enum_t uart_no, uint8_t *bytes, int len){
+	shark_uart_t *uart = _shark_uart + uart_no;
+	shark_uart_tx_continue(uart, bytes, len);
+}
+
+void shark_uart_frame_end(uart_enum_t uart_no){
+	shark_uart_tx_end(_shark_uart + uart_no);
+}
+
+void shark_uart_write_bytes(uart_enum_t uart_no, u8 *buff, u16 size){
+	shark_uart_write(_shark_uart + uart_no, buff, size);
+}
+

Applications/bsp/uart.h

@@ -0,0 +1,53 @@
+#pragma once
+#include "bsp/bsp.h"
+#include "libs/os.h"
+#include "libs/byte_queue.h"
+#include "libs/circle_buffer.h"
+
+#define CH_START						0xF5
+#define CH_END							0xF6
+#define CH_ESC							0xF7
+#define CH_ESC_START					0x05
+#define CH_ESC_END						0x06
+#define CH_ESC_ESC						0x07
+
+#define SHARK_UART_TX_MEM_SIZE			512
+#define SHARK_UART_RX_MEM_SIZE			512
+#define RX_FRAME_MAX_LEN 260
+#define RX_OLD_FRAME_MAX_LEN 256
+
+typedef enum {
+	SHARK_UART0 = 0,
+	SHARK_UART1,
+	SHARK_UART2,
+	SHARK_UART3,
+	SHARK_UART4,
+	SHARK_UART_COUNT
+} uart_enum_t;
+
+typedef struct {
+	byte_queue_t tx_queue;
+	c_buffer_t rx_queue;
+	dma_channel_enum rx_dma_ch;
+	dma_channel_enum tx_dma_ch;
+	uint16_t tx_length;
+	uint16_t tx_crc16;
+	uint32_t uart_com;//uart device
+	uint8_t rx_frame[RX_FRAME_MAX_LEN];
+	uint16_t rx_length;
+	bool escape;
+	bool start;
+	bool uart_no_data;
+}shark_uart_t;
+
+void shark_uart_init(uart_enum_t uart_no);
+void shark_uart_deinit(uart_enum_t uart_no);
+void shark_uart_write_frame(uart_enum_t uart_no, uint8_t *bytes, int len);
+void shark_uart_frame_start(uart_enum_t uart_no, uint8_t *bytes, int len);
+void shark_uart_frame_continue(uart_enum_t uart_no, uint8_t *bytes, int len);
+void shark_uart_frame_end(uart_enum_t uart_no);
+void shark_uart_write_bytes(uart_enum_t uart_no, u8 *buff, u16 size);
+void shark_uart_flush(void);
+bool shark_uart_timeout(void);
+void shark_uart_log(void);
+

Applications/foc/hall_sensor.c

@@ -131,7 +131,6 @@ int hall_sensor_calibrate(float voltage, u16 *hall_table){
 	hall_sensor_set_theta(true, 0.0f);
 	foc_set_dq_command(0.0f, 0.0f);
 	foc_pwm_start(true);
-//	HAL_ADC1_InJ_StartConvert();
 	for (int i = 0;i < 1000;i++) {
 		foc_set_dq_command((float)i * voltage / 1000.0f, 0.0f);
 		task_udelay(1000);

Applications/libs/byte_queue.c

@@ -0,0 +1,174 @@
+#include "byte_queue.h"
+
+static u16 byte_queue_add(const byte_queue_t *queue, u16 value1, u16 value2)
+{
+	return (value1 + value2) % queue->size;
+}
+
+static u16 byte_queue_tail_add(const byte_queue_t *queue, u16 value)
+{
+	return byte_queue_add(queue, queue->tail, value);
+}
+
+static u16 byte_queue_head_add(const byte_queue_t *queue, u16 value)
+{
+	return byte_queue_add(queue, queue->head, value);
+}
+
+u8 *byte_queue_head(byte_queue_t *queue)
+{
+	return queue->buff + queue->head;
+}
+
+bool byte_queue_empty(const byte_queue_t *queue)
+{
+	return (bool) (queue->head == queue->tail);
+}
+
+bool byte_queue_readable(const byte_queue_t *queue)
+{
+	return (bool) (queue->head != queue->tail);
+}
+
+bool byte_queue_full(const byte_queue_t *queue)
+{
+	return (bool) (byte_queue_tail_add(queue, 1) == queue->head);
+}
+
+bool byte_queue_writeable(const byte_queue_t *queue)
+{
+	return (bool) (byte_queue_tail_add(queue, 1) != queue->head);
+}
+
+u16 byte_queue_get_used(const byte_queue_t *queue)
+{
+	if (queue->head <= queue->tail) {
+		return queue->tail - queue->head;
+	}
+
+	return queue->size - (queue->head - queue->tail) - 1;
+}
+
+u16 byte_queue_get_free(const byte_queue_t *queue)
+{
+	if (queue->tail < queue->head) {
+		return queue->head - queue->tail;
+	}
+
+	return queue->size - (queue->tail - queue->head) - 1;
+}
+
+void byte_queue_reset(byte_queue_t *queue)
+{
+	queue->head = queue->tail = 0;
+}
+
+void byte_queue_init(byte_queue_t *queue, u8 *buff, u16 size)
+{
+	queue->buff = buff;
+	queue->size = size;
+	queue->head = queue->tail = 0;
+}
+
+u16 byte_queue_write(byte_queue_t *queue, const u8 *buff, u16 size)
+{
+	const u8 *buff_bak = buff;
+	const u8 *buff_end;
+
+	for (buff_end = buff + size; buff < buff_end; buff++) {
+		u16 tail = byte_queue_tail_add(queue, 1);
+
+		if (tail == queue->head) {
+			return buff - buff_bak;
+		}
+
+		queue->buff[queue->tail] = *buff;
+		queue->tail = tail;
+	}
+
+	return size;
+}
+
+u16 byte_queue_write_byte(byte_queue_t *queue, u8 byte)
+{
+	return byte_queue_write(queue, &byte, 1);
+}
+
+u16 byte_queue_read(byte_queue_t *queue, u8 *buff, u16 size)
+{
+	u8 *buff_bak = buff;
+	u8 *buff_end;
+
+	for (buff_end = buff + size; buff < buff_end; buff++) {
+		if (queue->head == queue->tail) {
+			return buff - buff_bak;
+		}
+
+		*buff = queue->buff[queue->head];
+		queue->head = byte_queue_head_add(queue, 1);
+	}
+
+	return size;
+}
+
+void byte_queue_fill(byte_queue_t *queue, u8 *buff, u16 size)
+{
+	while (size > 0) {
+		u16 length = byte_queue_read(queue, buff, size);
+		size -= length;
+		buff += size;
+	}
+}
+
+void byte_queue_skip(byte_queue_t *queue, u16 length)
+{
+	queue->head = byte_queue_head_add(queue, length);
+}
+
+u16 byte_queue_peek(byte_queue_t *queue)
+{
+	if (queue->tail < queue->head) {
+		return queue->size - queue->head;
+	} else {
+		return queue->tail - queue->head;
+	}
+}
+
+// ================================================================================
+
+void byte_queue_alloc_init(byte_queue_t *queue, u8 *buff, u8 size)
+{
+	queue->buff = buff;
+	queue->size = size;
+	byte_queue_alloc_reset(queue);
+}
+
+void byte_queue_alloc_reset(byte_queue_t *queue)
+{
+	u8 *buff = queue->buff;
+	u8 size = queue->size;
+	u8 index;
+
+	for (index = 0; index < size; index++) {
+		buff[index] = index;
+	}
+
+	queue->tail = size - 1;
+	queue->head = 0;
+}
+
+u8 byte_queue_alloc(byte_queue_t *queue)
+{
+	u8 index;
+
+	if (byte_queue_read(queue, &index, 1) > 0) {
+		return index;
+	}
+
+	return 0xFF;
+}
+
+void byte_queue_free(byte_queue_t *queue, u8 index)
+{
+	byte_queue_write(queue, &index, 1);
+}

Applications/libs/byte_queue.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "libs/os.h"
+#include "bsp/bsp.h"
+
+typedef struct {
+	u8 *buff;
+	u16 size;
+	u16 head;
+	u16 tail;
+} byte_queue_t;
+
+u8 *byte_queue_head(byte_queue_t *queue);
+bool byte_queue_empty(const byte_queue_t *queue);
+bool byte_queue_readable(const byte_queue_t *queue);
+bool byte_queue_full(const byte_queue_t *queue);
+bool byte_queue_writeable(const byte_queue_t *queue);
+u16 byte_queue_get_used(const byte_queue_t *queue);
+u16 byte_queue_get_free(const byte_queue_t *queue);
+
+void byte_queue_reset(byte_queue_t *queue);
+void byte_queue_init(byte_queue_t *queue, u8 *buff, u16 size);
+u16 byte_queue_write(byte_queue_t *queue, const u8 *buff, u16 size);
+u16 byte_queue_write_byte(byte_queue_t *queue, u8 byte);
+u16 byte_queue_read(byte_queue_t *queue, u8 *buff, u16 size);
+void byte_queue_fill(byte_queue_t *queue, u8 *buff, u16 size);
+void byte_queue_skip(byte_queue_t *queue, u16 length);
+u16 byte_queue_peek(byte_queue_t *queue);
+
+void byte_queue_alloc_init(byte_queue_t *queue, u8 *buff, u8 size);
+void byte_queue_alloc_reset(byte_queue_t *queue);
+u8 byte_queue_alloc(byte_queue_t *queue);
+void byte_queue_free(byte_queue_t *queue, u8 index);

Applications/libs/circle_buffer.c

@@ -3,9 +3,7 @@
 
 static int circle_get_write_space(c_buffer_t *cbuff);
 static int circle_get_read_space(c_buffer_t *cbuff);
-static c_buffer_t _g_cbuffer;
-c_buffer_t *circle_buffer_init(u8 *buffer, int16_t max_len){
-	c_buffer_t *cbuff = &_g_cbuffer;
+c_buffer_t *circle_buffer_init(c_buffer_t *cbuff, u8 *buffer, int16_t max_len){
 	memset(cbuff, 0, sizeof(c_buffer_t));
 	cbuff->buffer = buffer;
 	cbuff->buffer_len = max_len;

Applications/libs/circle_buffer.h

@@ -24,7 +24,7 @@ static __inline__ int circle_get_read_position(c_buffer_t *cbuff){
 	return cbuff->r_pos;
 }
 
-c_buffer_t *circle_buffer_init(u8 *buffer, int16_t max_len);
+c_buffer_t *circle_buffer_init(c_buffer_t *cbuff, u8 *buffer, int16_t max_len);
 void circle_reset(c_buffer_t *cbuff);
 int circle_put_one_data(c_buffer_t *cbuff, u8 data);
 int circle_put_data(c_buffer_t *cbuff, u8 *data, int16_t len);

Applications/libs/os.h

@@ -68,20 +68,24 @@ uint32_t get_timestamp_with_time_zone(int8_t tz);
 #define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
 #define min(a,b) (a>b?b:a)
 
-#define ms_2_ticks(ms) (ms/portTICK_PERIOD_MS + 1)
-
-#define Max_Delay (portMAX_DELAY)
-
-#define Priority_Lower 2
-#define Priority_Media 3
-#define Priority_Higher 4
-#define Priority_Super 5
-
 #define delay_us os_udelay
 
 static __inline__ void delay_ms(u32 ms) {
 	os_udelay(ms*1000);
 }
 
+static __inline__ u16 DECODE_U16(u8 *buff) {
+	return (((U16)(buff[1]) << 8) | buff[0]);
+}
+
+static __inline__ u32 DECODE_U24(u8 *buff) {
+	return ((U32)(buff[2]) << 16 | DECODE_U16(buff));
+}
+
+static __inline__ u16 DECODE_U32(u8 *buff) {
+	return ((U32)(buff[3]) << 24 | DECODE_U24(buff));
+}
+
+
 #endif /* _Shark_OS_H__ */
 

Project/MC100.uvoptx

@@ -471,6 +471,18 @@
       <RteFlg>0</RteFlg>
       <bShared>0</bShared>
     </File>
+    <File>
+      <GroupNumber>5</GroupNumber>
+      <FileNumber>23</FileNumber>
+      <FileType>1</FileType>
+      <tvExp>0</tvExp>
+      <tvExpOptDlg>0</tvExpOptDlg>
+      <bDave2>0</bDave2>
+      <PathWithFileName>..\Applications\libs\byte_queue.c</PathWithFileName>
+      <FilenameWithoutPath>byte_queue.c</FilenameWithoutPath>
+      <RteFlg>0</RteFlg>
+      <bShared>0</bShared>
+    </File>
   </Group>
 
   <Group>
@@ -481,7 +493,7 @@
     <RteFlg>0</RteFlg>
     <File>
       <GroupNumber>6</GroupNumber>
-      <FileNumber>23</FileNumber>
+      <FileNumber>24</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -493,7 +505,7 @@
     </File>
     <File>
       <GroupNumber>6</GroupNumber>
-      <FileNumber>24</FileNumber>
+      <FileNumber>25</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -505,7 +517,7 @@
     </File>
     <File>
       <GroupNumber>6</GroupNumber>
-      <FileNumber>25</FileNumber>
+      <FileNumber>26</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -517,7 +529,7 @@
     </File>
     <File>
       <GroupNumber>6</GroupNumber>
-      <FileNumber>26</FileNumber>
+      <FileNumber>27</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -529,7 +541,7 @@
     </File>
     <File>
       <GroupNumber>6</GroupNumber>
-      <FileNumber>27</FileNumber>
+      <FileNumber>28</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -541,7 +553,7 @@
     </File>
     <File>
       <GroupNumber>6</GroupNumber>
-      <FileNumber>28</FileNumber>
+      <FileNumber>29</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -553,7 +565,7 @@
     </File>
     <File>
       <GroupNumber>6</GroupNumber>
-      <FileNumber>29</FileNumber>
+      <FileNumber>30</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -565,7 +577,7 @@
     </File>
     <File>
       <GroupNumber>6</GroupNumber>
-      <FileNumber>30</FileNumber>
+      <FileNumber>31</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -577,7 +589,7 @@
     </File>
     <File>
       <GroupNumber>6</GroupNumber>
-      <FileNumber>31</FileNumber>
+      <FileNumber>32</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -589,7 +601,7 @@
     </File>
     <File>
       <GroupNumber>6</GroupNumber>
-      <FileNumber>32</FileNumber>
+      <FileNumber>33</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -601,7 +613,7 @@
     </File>
     <File>
       <GroupNumber>6</GroupNumber>
-      <FileNumber>33</FileNumber>
+      <FileNumber>34</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -613,7 +625,7 @@
     </File>
     <File>
       <GroupNumber>6</GroupNumber>
-      <FileNumber>34</FileNumber>
+      <FileNumber>35</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -623,6 +635,18 @@
       <RteFlg>0</RteFlg>
       <bShared>0</bShared>
     </File>
+    <File>
+      <GroupNumber>6</GroupNumber>
+      <FileNumber>36</FileNumber>
+      <FileType>1</FileType>
+      <tvExp>0</tvExp>
+      <tvExpOptDlg>0</tvExpOptDlg>
+      <bDave2>0</bDave2>
+      <PathWithFileName>..\Applications\bsp\uart.c</PathWithFileName>
+      <FilenameWithoutPath>uart.c</FilenameWithoutPath>
+      <RteFlg>0</RteFlg>
+      <bShared>0</bShared>
+    </File>
   </Group>
 
   <Group>
@@ -633,7 +657,7 @@
     <RteFlg>0</RteFlg>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>35</FileNumber>
+      <FileNumber>37</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -645,7 +669,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>36</FileNumber>
+      <FileNumber>38</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -657,7 +681,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>37</FileNumber>
+      <FileNumber>39</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -669,7 +693,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>38</FileNumber>
+      <FileNumber>40</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -681,7 +705,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>39</FileNumber>
+      <FileNumber>41</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -693,7 +717,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>40</FileNumber>
+      <FileNumber>42</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -705,7 +729,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>41</FileNumber>
+      <FileNumber>43</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -717,7 +741,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>42</FileNumber>
+      <FileNumber>44</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -729,7 +753,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>43</FileNumber>
+      <FileNumber>45</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -741,7 +765,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>44</FileNumber>
+      <FileNumber>46</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -753,7 +777,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>45</FileNumber>
+      <FileNumber>47</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -765,7 +789,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>46</FileNumber>
+      <FileNumber>48</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -777,7 +801,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>47</FileNumber>
+      <FileNumber>49</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -789,7 +813,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>48</FileNumber>
+      <FileNumber>50</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -801,7 +825,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>49</FileNumber>
+      <FileNumber>51</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -813,7 +837,7 @@
     </File>
     <File>
       <GroupNumber>7</GroupNumber>
-      <FileNumber>50</FileNumber>
+      <FileNumber>52</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -833,7 +857,7 @@
     <RteFlg>0</RteFlg>
     <File>
       <GroupNumber>8</GroupNumber>
-      <FileNumber>51</FileNumber>
+      <FileNumber>53</FileNumber>
       <FileType>1</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>
@@ -845,7 +869,7 @@
     </File>
     <File>
       <GroupNumber>8</GroupNumber>
-      <FileNumber>52</FileNumber>
+      <FileNumber>54</FileNumber>
       <FileType>2</FileType>
       <tvExp>0</tvExp>
       <tvExpOptDlg>0</tvExpOptDlg>

Project/MC100.uvprojx

@@ -513,6 +513,11 @@
               <FileType>1</FileType>
               <FilePath>..\Applications\libs\task.c</FilePath>
             </File>
+            <File>
+              <FileName>byte_queue.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\Applications\libs\byte_queue.c</FilePath>
+            </File>
           </Files>
         </Group>
         <Group>
@@ -578,6 +583,11 @@
               <FileType>1</FileType>
               <FilePath>..\Applications\bsp\adc.c</FilePath>
             </File>
+            <File>
+              <FileName>uart.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\Applications\bsp\uart.c</FilePath>
+            </File>
           </Files>
         </Group>
         <Group>