STM32F103串口2DMA

#include “ex232.h”

//#include “PC_485.h”

#include <misc.h>
#include <stm32f10x.h>
#include <stm32f10x_usart.h>
#include <stm32f10x_gpio.h>
#include <stm32f10x_dma.h>
#include <stm32f10x_rcc.h>

//#include “CRC.h”

#include “LDF15000Control.h”

uint32_t rx_flag;

void NVIC_USART2_Configuration(void) //

{

NVIC_InitTypeDef NVIC_InitStructure;

NVIC_InitStructure.NVIC_IRQChannel =USART2_IRQn; //中断通道名
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; //抢占优先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; //相应优先级
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //启动此通道的中断
NVIC_Init(&NVIC_InitStructure); //中断初始化

    USART_ITConfig(USART2, USART_IT_IDLE, ENABLE);//空闲中断

USART_ITConfig(USART2, USART_IT_TC, ENABLE); //发送完成

}

uint8_t uart_send_to_EX232[Max_232_Frame_Length];
uint8_t uart_receive_from_EX232[Max_232_Frame_Length];

uint32_t rx_length_send_out;

void USART2_INIT()
{
//GPIO???
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
DMA_InitTypeDef DMA_InitStructure;

RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE); //??USART1,GPIOA??
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); //??DMA??

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    //RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

    //USART_DeInit(USART4);  //????1

      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
            GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
            GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;            //定义TX引脚
            GPIO_Init(GPIOA, &GPIO_InitStructure);

            GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
            GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;     //定义RX引脚
            GPIO_Init(GPIOA, &GPIO_InitStructure);

            //GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
            //GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;     
            //GPIO_Init(GPIOA, &GPIO_InitStructure);       
      //GPIO_SetBits(GPIOA, GPIO_Pin_4);//485的接收/发送控制引脚
//Set_Max485_Rx();
   
            //USART ?????
            USART_InitStructure.USART_BaudRate = 38400;//9600;//19200;//9600;//波特率9600;
            USART_InitStructure.USART_WordLength = USART_WordLength_8b;//8个字节
            USART_InitStructure.USART_StopBits = USART_StopBits_1;//1个停止位
            USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验
            USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//
            USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //

USART_Init(USART2, &USART_InitStructure); //
//USART3 -> BRR = 0x341;
           

            USART_Cmd(USART2, ENABLE);                    //???? 



            //USART_DMACmd(UART4,USART_DMAReq_Rx,ENABLE);   //????1 DMA?? 

//UART3的DMA接收 DMA1通道3
//DMA_DeInit(USART3_RX_DMA); //
//RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1 ,ENABLE);
DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&USART2->DR; //
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)(&uart_receive_from_EX232[0]);//(u32)(&lcd_tx_data.rxdata[0]);
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; //外设作为数据的来源
DMA_InitStructure.DMA_BufferSize = INIT_RX_DMA_CNTR ; //数据传输数量
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //???
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //???
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //数据宽度8bit
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //DMA数据宽度8bit
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular; //不执行循环操作
DMA_InitStructure.DMA_Priority = DMA_Priority_High; //DMA优先级高
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; //不启动存储器到存储器模式
//DMA_Init(DMA1_Channel3, &DMA_InitStructure);
DMA_Init(USART2_RX_DMA, &DMA_InitStructure);
USART_DMACmd(USART2,USART_DMAReq_Rx,ENABLE);//UART3的DMA接收 DMA1通道3
// DMA_Cmd(DMA1_Channel3, ENABLE); //
DMA_Cmd(USART2_RX_DMA, ENABLE); //

 //UART3的DMA发送  DMA1通道2
 //DMA_Cmd(DMA2_Channel5,DISABLE);
   //DMA_DeInit(USART3_TX_DMA);   //

 DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)(&USART2->DR);
 DMA_InitStructure.DMA_MemoryBaseAddr = (u32)(& uart_send_to_EX232[0]);
 DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;//外设作为数据的目的地 从内存读取到外设
 DMA_InitStructure.DMA_BufferSize = 0;//每次发送时候要重新设置 此处暂时设置值
 DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
 DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
 DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
 DMA_InitStructure.DMA_MemoryDataSize = DMA_PeripheralDataSize_Byte;
 DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
 DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
 DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
 DMA_Init(USART2_TX_DMA/*DMA1_Channel2*/,&DMA_InitStructure);
 USART_DMACmd(USART2,USART_DMAReq_Tx,ENABLE);
            DMA_Cmd(USART2_TX_DMA/*DMA1_Channel2*/, DISABLE);
             
            USART_ClearITPendingBit(USART2, USART_IT_TC);
            NVIC_USART2_Configuration();

}

void Uart2_Send_Data(uint8_t length)
{

DMA_Cmd(USART2_TX_DMA/DMA2_Channel5/, DISABLE);
//DMA2_Channel5->CNDTR = length;// 发送数据长度
USART2_TX_DMA->CNDTR=length;
DMA_Cmd(USART2_TX_DMA/DMA2_Channel5/, ENABLE); // 启动发送

}

void analyse_the_RS232_frame(uint32_t length ,uint8_t *RxBuffer)
{
uint32_t i,sum,getted_sum;

    if(RxBuffer[0] != 0xa5 || RxBuffer[1] != 0xaa)
            return;
    if(length<5)
            return;
    if(length>=INIT_RX_DMA_CNTR)
            return;
   
    if(length < (RxBuffer[2] + 3))//帧头2字节 +长度1个字节+命令码+数据+累加和（2字节），其中长度=命令码+数据+累加和
            return ;

sum=0;
for(i=0;i<length-2;i++)
{
sum+=RxBuffer[i];
}

getted_sum=RxBuffer[length-2];
getted_sum<<=8;
getted_sum+=RxBuffer[length-1];

    if(sum!=getted_sum)
 return;
   
    save_data_into_Ethernet_RX_buffer(length,RxBuffer);//读取的数据直接放到接收缓存

}

void test_send(void)
{
uart_send_to_EX232[0]=0;
uart_send_to_EX232[1]=1;
uart_send_to_EX232[2]=2;
uart_send_to_EX232[3]=3;

    Uart2_Send_Data(4);        

}

struct Ethernet_data sendout_to_Ethernet_buffer;

struct Ethernet_data receive_from_Ethernet_buffer;

void save_data_into_Ethernet_RX_buffer(uint32_t length,uint8_t *point)
{
uint32_t id,i;
id=receive_from_Ethernet_buffer.write_point;

receive_from_Ethernet_buffer.array[id].length=length;
for(i=0;i<length;i++)
{
receive_from_Ethernet_buffer.array[id].data[i]=point[i];
}
receive_from_Ethernet_buffer.write_point++;

            if(receive_from_Ethernet_buffer.write_point>=Buffer_Frame_Num)
  receive_from_Ethernet_buffer.write_point=0;                 

}

/*void save_data_into_Ethernet_TX_buffer(uint32_t length,uint8_t *point)
{
uint32_t id,i;
id=sendout_to_Ethernet_buffer.write_point;

sendout_to_Ethernet_buffer.array[id].length=length;
for(i=0;i<length;i++)
{
sendout_to_Ethernet_buffer.array[id].data[i]=point[i];
}
sendout_to_Ethernet_buffer.write_point++;
if(sendout_to_Ethernet_buffer.write_point>=Max_232_Frame_Length)
sendout_to_Ethernet_buffer.write_point=0;

}*/

void check_if_have_frame_sent_to_the_network()
{
uint32_t i, id,length;

    if(receive_from_Ethernet_buffer.write_point==receive_from_Ethernet_buffer.read_point)//接收命令缓存查看是否有数据
            return;
   
    id=receive_from_Ethernet_buffer.read_point;
    receive_from_Ethernet_buffer.read_point++;

if(receive_from_Ethernet_buffer.read_point>=Buffer_Frame_Num)
receive_from_Ethernet_buffer.read_point=0;

length=receive_from_Ethernet_buffer.array[id].length;//接收到命令帧的长度

    for(i=0;i<length;i++)
        {
                    Ex232.RxBuffer[i]=receive_from_Ethernet_buffer.array[id].data[i];
                    }
     
    Ex232.TxLength=0;  //清零发送标志
    DataHandle(&Ex232,0);//原有函数解析处理报文
     
                    if(Ex232.TxLength==0)//没有发送数据则直接返回
  return;                 
                   
    //save_data_into_Ethernet_TX_buffer(Ex232.TxLength,&Ex232.TxBuffer[0]);

length=Ex232.TxLength;

    for(i=0;i<length;i++)
        {
                    uart_send_to_EX232[i]=Ex232.TxBuffer[i];
                   
                    }

Uart2_Send_Data(length);

}

#include <stdint.h>

#ifndef ex232_h
#define ex232_h

#define USART2_TX_DMA DMA1_Channel7
#define USART2_RX_DMA DMA1_Channel6

#define Max_232_Frame_Length 80
#define INIT_RX_DMA_CNTR Max_232_Frame_Length

#define Buffer_Frame_Num 10

struct Ethernet_data
{

    uint32_t write_point;
    uint32_t read_point;
    struct
    {
    uint8_t length;       
    uint8_t data[Max_232_Frame_Length];
    }array[Buffer_Frame_Num];

};

extern uint8_t uart_send_to_EX232[Max_232_Frame_Length];
extern uint8_t uart_receive_from_EX232[Max_232_Frame_Length];

void USART2_INIT(void);

void test_send(void);

void analyse_the_RS232_frame(uint32_t length ,uint8_t *RxBuffer);

void check_if_have_frame_into_Ethernet(void);

void save_data_into_Ethernet_RX_buffer(uint32_t length,uint8_t *point);

void check_if_have_frame_sent_to_the_network(void);

#endif

uint32_t usart2_int;
uint32_t rx_usart2_int;
uint32_t tx_usart2_int;
uint32_t rx_length;
#include “ex232.h”

void USART2_IRQHandler(void) //用于和液晶
{
uint32_t dma_rx_length;
/*
#define USART3_TX_DMA DMA1_Channel2
#define USART3_RX_DMA DMA1_Channel3
usart3_int++;
*/
usart2_int++;
//lcd_tx_data.int_num++;
//lcd_rx_data.intt_num++;

      if(USART_GetITStatus(USART2, USART_IT_IDLE) != RESET)  //串口3的空闲中断
  { //uint8_t err;  
                              //lcd_tx_data.int_rx_num++;
      //lcd_rx_data.rx_num++;
                              rx_usart2_int++;
                              //rx_flag=1;
                              USART_ReceiveData(USART2);//先读取SR再读取DR是为了清除IDLE标志

                              DMA_Cmd(USART2_RX_DMA,DISABLE);//DMA3_channel3是串口4的DMA接收通道                          
                              
                              //rx_length_send_out=DMA_GetCurrDataCounter(USART3_RX_DMA);
                              
                              dma_rx_length= INIT_RX_DMA_CNTR -DMA_GetCurrDataCounter(USART2_RX_DMA); //?????????
      //rx_length_send_out= dma_rx_length; 
                           
                              if(dma_rx_length>0 && dma_rx_length<INIT_RX_DMA_CNTR)
          analyse_the_RS232_frame(dma_rx_length ,&uart_receive_from_EX232[0]);

                                   
      USART2_RX_DMA->CNDTR=INIT_RX_DMA_CNTR; 
                             
                            DMA_Cmd(USART2_RX_DMA,ENABLE);
     //if(analyse_lcd_tx_data())        
                       //   OSFlagPost(uart4_FLAG,NEW_CMD_FLAG,OS_FLAG_SET,&err);
                   
                    } 


            if(USART_GetITStatus(USART2,USART_IT_TC)!= RESET) //串口4发送完成
                    {
                            //lcd_tx_data.int_tx_num++;
                            //lcd_tx_data.tx_num++;
                            tx_usart2_int++;
                            USART_ClearITPendingBit(USART2, USART_IT_TC);   //
                            DMA_Cmd(USART2_TX_DMA, DISABLE); //
                            USART2_TX_DMA->CNDTR=0;          //

                           
                            //lcd_tx_data.flag.tx_busy=0;
                    }                       

}