如何做一个简单的分层设计？

以前在使用串口的时候都是直接使用中断，每收发一个字节都要进一次中断，然后直接在中断进行封包，现在做了一个简单的分层设计，其实这个设计还是驱动设计，后期将逻辑层划分再细致一点，争取做到和linux的shell类似的分层。
软件分层如下





驱动层：串口、DMA、初始化，串口只开启接收空闲中断，DMA中断不开启。
缓冲区：利用malloc和free函数创建的链表，缓冲区管理有两个，一个是接收缓冲区，每次进入接收空闲中断就把数据扔到接收缓冲队列里面去；另一个是发送缓冲区，发送缓冲区无逻辑，这只是一个数据结构。






示意图中的数据指针实际上用的是uint8 数组，当然，第一个数据完全可以塞到第二个数据里面，但是如果使用的是M0芯片的时候，会有一个指针地址的对齐问题，这个就不展开说了，只要是问题都有规避办法的。
逻辑层：逻辑里面关于串口接收队列，因为无法保证发送方的数据连续，所以需要将接收缓冲队列的数据重新打包，打包函数主要检测接收队列是否有数据，如果有，进行数据打包，如果能保证数据帧的完整性，无粘包、无断包，数据打包函数可以去除。串口发送函数，串口发送函数定时10ms检测DMA发送通道是否为空，如果通道空，延时10ms启动DMA发送，发送数据在发送队列缓冲中获取，发送的帧间隔范围在10~20ms之间，延时10ms保证了发送帧间隔至少10ms。






设计一个发送函数的接口，有数据发送时，应用只管往里面扔数据，然后再用一个封包函数封起来，再加一个封包函数，对于用户而言只有一个发送函数的api，用户层只管发送数据，底层逻辑不要管，也不允许动。发送函数只管定时从发送队列里面取数据，取一帧，然后调用dma，然后等待帧间隔，进行下一帧数据获取，发送，做到软件层面的分层，责任划分明确，一个函数只干一件事。


软件设计思想说完，下面直接放代码。

软件设计思想说完，下面直接放代码。


usart.h


#ifndef _USART_H
#define _USART_H
#include "stm32f10x.h"

#define SEND_BUSY 1
#define SEND_IDLE 0
#define BOUND_RATE        38400                        //串口通信波特率
#define SENDBUFF_SIZE 50
#define SENDBUFF_SIZE_INTIT 0
#define RECEBUFF_SIZE 200
#define USART1_DR_Base  0x40013804
#define COMM_SEND_INTERNAL_20MS        20

struct COM_DATA_ST
{
        uint8_t SendBuff[SENDBUFF_SIZE];
        uint8_t ReceBuff[RECEBUFF_SIZE];
        uint8_t Send_Complete_Flag;
        uint8_t Bus_Idle_Count;
};

void usart1_init(void);
void usart1_rev_irq(void);
void usart1_send_irq(void);
void DMA_Config(void);
void Send_data(uint8_t *ptr,uint8_t length);
void usart1_dma_send_irq(void);
void Check_Send_Quene(void);
void usart1_send_interval_deal(void);

#endif
usart.c
#include "stm32f10x.h"
#include "string.h"
#include "usart.h"
#include "quene.h"


struct COM_DATA_ST Com_Data;

struct node Rece_Quene;                        /*接收的数据队列*/
struct node Send_Quene;                        /*发送数据的队列*/
struct node Send_Ack_Quene;                /*发送应答数据的队列*/

uint8_t Get_DMA_State(void);

/*
* Description:串口初始化
* input:none
* output:none
* author:
* date:2018-2-7
*/
void usart1_init(void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
        USART_InitTypeDef USART_InitStructure;
        NVIC_InitTypeDef NVIC_InitStructure;

        NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;                                                        //配置定时器中断通道
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
        NVIC_Init(&NVIC_InitStructure);

        RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);                //使能afio时钟
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);                //使能GPIOA时钟
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);                //使能串口1时钟
               
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;                                                        //串口1输入脚浮空
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
        GPIO_Init(GPIOA, &GPIO_InitStructure);

        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;                                                                //串口1输出脚配成多功能上下拉
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                                        //多功能推挽输出
        GPIO_Init(GPIOA, &GPIO_InitStructure);

        USART_InitStructure.USART_BaudRate = BOUND_RATE;                                //初始化串口参数
        USART_InitStructure.USART_WordLength = USART_WordLength_8b;
        USART_InitStructure.USART_StopBits = USART_StopBits_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(USART1, &USART_InitStructure);                                                                //初始化串口
        USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);                                                        //空闲中断
        USART_Cmd(USART1, ENABLE);
       
       
}

/*
* 函数名：DMA_Config
* 描述  ：DMA 串口的初始化配置
* 输入  ：无
* 输出  : 无
* 调用  ：外部调用
*/
void DMA_Config(void)
{
    DMA_InitTypeDef DMA_InitStructure;
        NVIC_InitTypeDef NVIC_InitStructure;
       
        RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);                                                                /*开启DMA时钟*/

        NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn;
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
        NVIC_Init(&NVIC_InitStructure);
       
    DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;                                                   /*设置DMA源：内存地址&串口数据寄存器地址*/
    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)Com_Data.SendBuff;                                                        /*内存地址(要传输的变量的指针)*/
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;                                                                /*方向：从内存到外设*/               
    DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE_INTIT;                                                                /*传输大小DMA_BufferSize=SENDBUFF_SIZE*/
    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_MemoryDataSize_Byte;                                         /*内存数据单位 8bit*/
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal ;                                                                         /*DMA模式：一次传输，循环*/
    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;                                                          /*优先级：中*/
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;                                                                        /*禁止内存到内存的传输        */
    DMA_Init(DMA1_Channel4, &DMA_InitStructure);                                                                         /*配置DMA1的4通道*/                          
        DMA_Cmd (DMA1_Channel4,ENABLE);                                                                                                        /*使能DMA*/
//        DMA_ITConfig(DMA1_Channel4,DMA_IT_TC,ENABLE);                                                                          /*配置DMA发送完成后产生中断*/
       
    DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;                                                   /*设置DMA源：内存地址&串口数据寄存器地址*/
    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)Com_Data.ReceBuff;                                                        /*内存地址(要传输的变量的指针)*/
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;                                                                /*方向：从外设到内存*/               
    DMA_InitStructure.DMA_BufferSize = RECEBUFF_SIZE;                                                                /*传输大小DMA_BufferSize=SENDBUFF_SIZE*/
    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_MemoryDataSize_Byte;                                         /*内存数据单位 8bit*/
    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular ;                                                                 /*DMA模式：一次传输，循环*/
    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;                                                          /*优先级：中*/
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;                                                                        /*禁止内存到内存的传输        */
    DMA_Init(DMA1_Channel5, &DMA_InitStructure);                                                                         /*配置DMA1的5通道*/                          
        DMA_Cmd (DMA1_Channel5,ENABLE);                                                                                                        /*使能DMA*/
        USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
}

/*
* Description:串口1接收中断
* input:none
* output:none
* author:
* date:2018-2-7
*/
void usart1_rev_irq(void)
{
        char data_length;
        data_length = USART1->SR;
        data_length = USART1->DR;
        DMA_Cmd(DMA1_Channel5,DISABLE);
        data_length = RECEBUFF_SIZE - DMA_GetCurrDataCounter(DMA1_Channel5);
        InsertNode(&Rece_Quene,Com_Data.ReceBuff,data_length);
        DMA_SetCurrDataCounter(DMA1_Channel5,RECEBUFF_SIZE);
        DMA_Cmd(DMA1_Channel5,ENABLE);
}

/*
* Description:串口1发送完成中断
* input:none
* output:none
* author:
* date:2018-2-7
*/
void usart1_dma_send_irq(void)
{
        Com_Data.Send_Complete_Flag = 1;
}

/*
* Description:串口1发送完成间隔处理
* input:none
* output:none
* author:
* date:2018-2-28
*/
void usart1_send_interval_deal(void)
{
        if(0 == Get_DMA_State()){
                if(Com_Data.Bus_Idle_Count<0xff)
                        Com_Data.Bus_Idle_Count++;
        }else{
                Com_Data.Bus_Idle_Count=0;
        }
}

/*
* Description:串口1发送数据api
* input:*ptr:发送数据缓冲区指针，length：发送长度
* output:none
* author:
* date:2018-2-28
*/
void Send_data(uint8_t *ptr,uint8_t length)
{
        memcpy(Com_Data.SendBuff,ptr,length);                                                /*拷贝数据到发送缓冲区中*/
        DMA_Cmd(DMA1_Channel4,DISABLE);                                                /*在发送数据之前必须关闭dma通道，否则无法修改发送的buffer长度*/
        DMA_SetCurrDataCounter(DMA1_Channel4,length);                /*修改发送数据长度*/
        DMA_Cmd(DMA1_Channel4,ENABLE);                                                /*启动dma通道*/
        USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);                /*启动串口发送*/
}

/*
* Description:DMA发送忙检测
* input:
* output: SEND_BUSY：发送忙 SEND_IDLE：空闲
* author:
* date:2018-2-28
*/
uint8_t Get_DMA_State(void)
{
        if(DMA_GetCurrDataCounter(DMA1_Channel4))                        /*检测dma是否发送完成*/
                return SEND_BUSY;
        else
                return SEND_IDLE;
}

/*
* Description:检测发送队列有没有数据
* input:
* output:  
* author:
* date:2018-2-28
*/
void Check_Send_Quene(void)
{
        uint8_t length;
        uint8_t send_data[50];
       
        if(Com_Data.Bus_Idle_Count>=COMM_SEND_INTERNAL_20MS){/*发送间隔20个毫秒*/
                Com_Data.Bus_Idle_Count=0;
                if(TURE == GetNodeData(&Send_Ack_Quene,send_data,&length)){/*优先发送ack队列*/
                        Send_data(send_data,length);
                        DeleNode(&Send_Ack_Quene);
                }else if(TURE == GetNodeData(&Rece_Quene,send_data,&length)){
                        Send_data(send_data,length);
                        DeleNode(&Rece_Quene);
                }
        }
               
}

/*
* Description:检测接收队列并进行数据封包
* input:
* output:
* author:
* date:2018-2-28
*/
void Check_Rece_Quene(void)
{
        uint8_t length;
        uint8_t Rece_data[50];
       
        if(TURE == GetNodeData(&Rece_Quene,Rece_data,&length)){
                DeleNode(&Rece_Quene);
                /*数据封包处理*/
        }
               
}

quene.h


#ifndef _QUENE_H
#define _QUENE_H
#include "stm32f10x.h"

#define TURE 1
#define FAULSE 0
#define TAIL_NODE 0xffff
#define HEAD_NODE 0

struct node
{
        uint8_t Length;                                                //有效数据
        uint8_t *Data;                                                //数据指针
        struct node *pNext;                                        //节点指针
};

uint8_t InsertNode(struct node *pHeader,uint8_t *data,uint8_t data_length);
uint8_t GetNodeData(struct node *pHeader,uint8_t *data,uint8_t *length);
uint8_t DeleNode(struct node *pHeader);
uint16_t  GetNodeNum(struct node *pHeader);

#endif
quene.c


#include "stdlib.h"
#include "string.h"
#include "quene.h"

/*
* Description:插入节点
* input:*pHeader:头结点地址 *data：数据 data_length：数据长度
* output:FAULSE：插入失败
* author:
* date:2018-2-7
*/
uint8_t InsertNode(struct node *pHeader,uint8_t *data,uint8_t data_length)
{
        struct node *p=NULL;
        struct node *p1=NULL;
       
        p = pHeader;
        p1 =(struct node*)malloc(sizeof(struct node));
       
        if(NULL == p1)
                return FAULSE;
       
        p1->pNext = NULL;
        p1->Data = (uint8_t *)malloc(data_length);
        if(NULL == p1->Data)
                return FAULSE;
        memcpy(p1->Data,data,data_length);
        p1->Length = data_length;

        while(p->pNext != NULL)
                p=p->pNext;
               
        p->pNext = p1;
       
       
        return TURE;
}

/*
* Description:删除节点
* input:*pHeader:头结点地址
* output:FAULSE：删除失败 TURE：删除成功
* author:
* date:2018-2-7
*/
uint8_t DeleNode(struct node *pHeader)
{
        struct node *p=pHeader,*p1;
       
        if(NULL == p)
        {
                return FAULSE;
        }
       
        p1 = p->pNext;
        p->pNext=p1->pNext;
        free(p1->Data);
        free(p1);
       
        return TURE;
}

/*
* Description:获取链表长度
* input:*pHeader:头结点地址
* output:长度
* author:
* date:2018-2-7
*/
uint16_t  GetNodeNum(struct node *pHeader)
{
        uint16_t i=0;
        struct node *p=pHeader;
       
        while(p->pNext != NULL){
                i++;
                p = p->pNext;
        }               
       
        return i;
}

/*
* Description:获取队列节电数据
* input:*pHeader:头结点地址
* output:FAULSE：
* author:
* date:2018-2-7
*/
uint8_t GetNodeData(struct node *pHeader,uint8_t *data,uint8_t *length)
{
        struct node *p=pHeader;
        if(p->pNext == NULL)/*节点空*/
                return FAULSE;
       
        p=p->pNext;
        memcpy(data,p->Data,p->Length);
        *length = p->Length;
       
        return TURE;
}