SmartPDCode/GD32F427/hardware/sensor/bsp_sensor.c

#include "bsp_sensor.h"
#include "gd32f4xx_libopt.h"
#include "string.h"
#include "FreeRTOS.h"
#include "task.h"




static uint8_t sensor_dma_send[20] = {0};
static uint8_t sensor_dma_recive[2][20] = {0};

static usart_t sensor={0};


static int usart_recive(uint8_t *recive);
static int usart_dma_send(uint8_t *send,uint16_t len);


usart_t* get_bsp_sensor()
{
	return &sensor;
}

static void sensor_gpio(void)
{
	rcu_periph_clock_enable(RCU_GPIOB);  

  gpio_af_set(GPIOB, GPIO_AF_7, GPIO_PIN_10);
  gpio_af_set(GPIOB, GPIO_AF_7, GPIO_PIN_11);
  
	gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_10);
  gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_10);

	gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_11);
  gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_11);
}


static void sensor_dma(void)
{
	rcu_periph_clock_enable(RCU_DMA0);
	dma_single_data_parameter_struct dma_init_struct;

  dma_single_data_para_struct_init(&dma_init_struct);
  dma_deinit(DMA0, DMA_CH3);
  dma_init_struct.direction = DMA_MEMORY_TO_PERIPH;
  dma_init_struct.memory0_addr = (uint32_t)(&sensor_dma_send);
  dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
  dma_init_struct.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;
  dma_init_struct.number = (uint32_t)(20);
  dma_init_struct.periph_addr = ((uint32_t)&USART_DATA(USART2));
  dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
  dma_init_struct.priority = DMA_PRIORITY_LOW;
  dma_single_data_mode_init(DMA0, DMA_CH3, &dma_init_struct);	
	
	
	dma_deinit(DMA0, DMA_CH1);
  dma_init_struct.direction = DMA_PERIPH_TO_MEMORY;
  dma_init_struct.memory0_addr = (uint32_t)(&sensor_dma_recive[0][0]);
  dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
  dma_init_struct.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;
  dma_init_struct.number = (20);
  dma_init_struct.periph_addr = ((uint32_t)&USART_DATA(USART2));
  dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
  dma_init_struct.priority = DMA_PRIORITY_MEDIUM;
	dma_single_data_mode_init(DMA0, DMA_CH1, &dma_init_struct);	
	
	
	dma_circulation_disable(DMA0, DMA_CH1);
  dma_channel_subperipheral_select(DMA0, DMA_CH1, DMA_SUBPERI4);
	usart_dma_receive_config(USART2,USART_RECEIVE_DMA_ENABLE);
	
	dma_circulation_disable(DMA0, DMA_CH3);
  dma_channel_subperipheral_select(DMA0, DMA_CH3, DMA_SUBPERI4);
	usart_dma_transmit_config(USART2,USART_TRANSMIT_DMA_ENABLE);
	
//	dma_flag_clear(DMA0,DMA_CH5,DMA_FLAG_FTF);
//	dma_flag_clear(DMA0,DMA_CH6,DMA_FLAG_FTF);
	
	//dma_channel_enable(DMA0, DMA_CH6);
	dma_channel_enable(DMA0, DMA_CH1);
}

static void sensor_usart(uint32_t baund)
{
	rcu_periph_clock_enable(RCU_USART2);
	usart_deinit(USART2);
	usart_baudrate_set(USART2, baund);         
  usart_word_length_set(USART2, USART_WL_8BIT); 
  usart_stop_bit_set(USART2, USART_STB_1BIT);   
  usart_parity_config(USART2, USART_PM_NONE);  
  usart_transmit_config(USART2, USART_TRANSMIT_ENABLE);
	usart_receive_config(USART2,USART_RECEIVE_ENABLE);
  usart_interrupt_enable(USART2,USART_INT_IDLE);
	usart_interrupt_flag_clear(USART2,USART_INT_FLAG_IDLE);
	nvic_irq_enable(USART2_IRQn, 5, 4);
  usart_enable(USART2);
}	




void bsp_sensor_init(void)
{
	sensor_gpio();
	sensor_usart(9600);
	sensor_dma();
	sensor.recive = usart_recive;
	sensor.send = usart_dma_send;
}


void USART2_IRQHandler(void)
{
	uint16_t len= 0;
	if(usart_interrupt_flag_get(USART2, USART_INT_FLAG_IDLE)) {
		USART_STAT0(USART2);
		USART_DATA(USART2);
		//fr_printf("???????\r\n");
		dma_channel_disable(DMA0, DMA_CH1);
		sensor.recive_len = 20 - dma_transfer_number_get(DMA0, DMA_CH1);
		sensor.recive_complete = SET;
		sensor.curent_recive_id = (sensor.curent_recive_id == 0) ? 1 : 0;
		dma_memory_address_config(DMA0, DMA_CH1,DMA_MEMORY_0,(uint32_t)(&sensor_dma_recive[sensor.curent_recive_id][0]));
    dma_transfer_number_config(DMA0, DMA_CH1, 20);
		usart_dma_receive_config(USART2, USART_RECEIVE_DMA_ENABLE);
		dma_flag_clear(DMA0,DMA_CH1,DMA_FLAG_FTF);
    dma_channel_enable(DMA0, DMA_CH1);
	}
}




static int usart_recive(uint8_t *recive)
{
	
	uint8_t id = sensor.curent_recive_id == 1 ? 0 : 1;
	memcpy(recive,&sensor_dma_recive[id][0],sensor.recive_len);
	sensor.recive_complete = RESET;
	
	//fr_printf("recive!!!!!!!!   recive_len = %d\r\n",sensor.recive_len);
	
//	for(int i = 0; i < sensor.recive_len;i++)
//	{
//		fr_printf("[%02x] ",recive[i]);
//	}
//	fr_printf("\r\n");
	return sensor.recive_len;
}
static int usart_dma_send(uint8_t *send,uint16_t len)
{
	//fr_printf("send!!!!!!!!\n");
	
//	for(int i = 0; i < len;i++)
//	{
//		fr_printf("<%02x> ",send[i]);
//	}
//	fr_printf("\r\n");
	dma_channel_disable(DMA0,DMA_CH3);
	memcpy(sensor_dma_send,send,len);
	dma_transfer_number_config(DMA0, DMA_CH3,len);
	dma_channel_enable(DMA0,DMA_CH3);
	while(!dma_flag_get(DMA0, DMA_CH3, DMA_FLAG_FTF)){
		vTaskDelay(1);
	}
	dma_flag_clear(DMA0, DMA_CH3, DMA_FLAG_FTF);
	sensor.recive_complete = RESET;	
}