CC2530 串口驱动

[cpp] view plaincopy
/************************************************************************************************************* 
 * 文件名: uart.c 
 * 功能:  CC2530 串口相关函数 
 * 作者:  cp1300@139.com 
* 创建时间: 2013-06-07 21:33 
 * 最后修改时间:2013-06-07 
 * 详细:  串口相关函数 
            串口最大时钟为系统时钟的1/16 
*************************************************************************************************************/  
#include "system.h"  
#include "uart.h"  
  
  
  
//相关UART状态结构  
typedef struct  
{  
    u8          BuffFull;   //接收Buff满  
    u8          *RxBuff;    //接收Buff指针  
    u16         RxBuffSize; //接收缓冲区大小,一帧数据大小  
    u16         UartRxCnt;  //接收数据计数器  
} UartRx_TypeDef;  
  
static UartRx_TypeDef   UART_RX[2];  
  
  
  
  
static const u8 BAUD_M[11] = {59, 59, 59, 216, 59, 216, 59, 216, 59, 216, 216};     //32MHZ系统时钟对应的分频器小数部分  
static const u8 BAUD_E[11] = {6, 7 ,8, 8, 9, 9, 10, 10, 11, 11, 12};                //32MHZ系统时钟对应的分频器指数部分  
  
  
/************************************************************************************************************************* 
*函数        :        void UART_Init(UART_CH ch, USART_BAUD Baud, FunctionalState RxIntEn) 
*功能        :        串口初始化 
*参数        :        ch:通道选择,UART_CH0,UART_CH1 
                    Baud:波特率控制,见USART_BAUD 
                    RxIntEn:ENABLE:使能串口接收中断 
*返回        :       无 
*依赖        :        底层宏定义 
*作者        :        cp1300@139.com 
*时间        :        2013-05-20 
*最后修改时间:        2013-06-11 
*说明        :        一个起始位,8个数据位,一个停止位,无奇偶校验 
                    需要开启全局中断 
*************************************************************************************************************************/  
void UART_Init(UART_CH ch, USART_BAUD Baud, FunctionalState RxIntEn)  
{  
    switch(ch)  
    {  
        case UART_CH0:  
        {  
            U0CSR = BIT7 + BIT6;    //UART模式,使能接收     
            U0UCR = BIT1;           //无流控,无奇偶校验,8bit,1个停止位,停止位高电平,起始低电平  
            U0GCR =  BAUD_E[Baud];  //波特率分频器指数部分  
            U0BAUD =  BAUD_M[Baud]; //波特率分频器小数部分  
            P0SEL |= BIT2 + BIT3;   //P0.3 TXD,P0.2 RXD  
            IEN2 &= ~(1 << 3);        //关闭发送中断  
            URX0IF = 0;             //清除串口接收中断标志  
            UTX0IF = 0;             //清除串口发送中断标志  
            URX0IE = (RxIntEn == ENABLE) ? 1 : 0;           //使能串口接收中断  
        }break;  
        case UART_CH1:  
        {  
            U1CSR = BIT7 + BIT6;    //UART模式,使能接收     
            U1UCR = BIT1;           //无流控,无奇偶校验,8bit,1个停止位,停止位高电平,起始低电平  
            U1GCR =  BAUD_E[Baud];  //波特率分频器指数部分  
            U1BAUD =  BAUD_M[Baud]; //波特率分频器小数部分  
            P1SEL |= BIT4 + BIT5;   //P0.5 TXD,P0.4 RXD  
            URX1IF = 0;             //清除串口接收中断标志  
            UTX1IF = 0;             //清除串口发送中断标志  
            URX1IE = (RxIntEn == ENABLE) ? 1 : 0;           //使能串口接收中断  
        }break;  
        default : return;  
    }  
    UART_SetRxBuff(ch, NULL, 0);    //初始化串口缓冲区无效  
}  
  
  
  
/************************************************************************************************************************* 
*函数         :   void UART_SendByte(UART_CH ch, u8 data) 
*功能         :   UART字节发送函数 
*参数         :   ch:通道选择,UART_CH0,UART_CH1 
                    data:需要发送的数据 
*返回         :   无 
*依赖         :   底层宏定义 
*作者         :   cp1300@139.com 
*时间         :   2013-06-11 
*最后修改时间 :   2013-06-11 
*说明         :   无 
*************************************************************************************************************************/  
void UART_SendByte(UART_CH ch, u8 data)  
{  
    switch(ch)  
    {  
        case UART_CH0:  
        {  
            U0DBUF = data;                  //发送字节数据  
            while(!(U0CSR & BIT1));         //等待发送数据寄存器为空                 
            U0CSR &= ~BIT1;  
        }break;  
        case UART_CH1:  
        {  
            U1DBUF = data;                  //发送字节数据  
            while(!(U1CSR & BIT1));         //等待发送数据寄存器为空                 
            U1CSR &= ~BIT1;  
        }break;  
        default : break;  
    }  
}  
  
  
  
  
/************************************************************************************************************************* 
*函数         :   void UART2_SendData(u8 *pbuff, u16 len) 
*功能         :   串口发送任意长度数据 
*参数         :   ch:通道选择,UART_CH0,UART_CH1 
                    pbuff:数据缓冲区指针,len:数据长度 
*返回         :   无 
*依赖         :   底层宏定义 
*作者         :   cp1300@139.com 
*时间         :   2013-06-11 
*最后修改时间 :   2013-06-11 
*说明         :   无 
*************************************************************************************************************************/  
void UART_SendData(UART_CH ch, u8 *pbuff, u16 len)  
{  
    u16 i;  
      
    switch(ch)  
    {  
        case UART_CH0:  
        {  
            for(i = 0;i < len;i ++)  
            {  
                U0DBUF = pbuff[i];                  //发送字节数据  
                while(!(U0CSR & BIT1));         //等待发送数据寄存器为空                 
                U0CSR &= ~BIT1;  
            }  
        }break;  
        case UART_CH1:  
        {  
            for(i = 0;i < len;i ++)  
            {  
                U1DBUF = pbuff[i];                  //发送字节数据  
                while(!(U1CSR & BIT1));         //等待发送数据寄存器为空                 
                U1CSR &= ~BIT1;  
            }  
        }break;  
        default : break;  
    }  
}  
  
  
  
/************************************************************************************************************************* 
* 函数            :   void UART2_SendString(UART_CH ch, const char *pStr) 
* 功能            :   UART发送字符串 
* 参数            :   ch:通道选择,UART_CH0,UART_CH1 
                    pStr:字符串指针 
* 返回            :   无 
* 依赖            :   底层宏定义 
* 作者            :   cp1300@139.com 
* 时间            :   2013-06-11 
* 最后修改时间    :   2013-06-11 
* 说明            :   遇到'0\'后停止发送 
*************************************************************************************************************************/  
void UART_SendString(UART_CH ch, const char *pStr)  
{  
    while(*pStr != '\0')  
    {  
        UART_SendByte(ch, *pStr ++);  
    }  
}  
  
  
/************************************************************************************************************************* 
* 函数            :   void UART_RxEnable(UART_CH ch, FunctionalState Enable) 
* 功能            :   UART接收使能 
* 参数            :   ch:通道选择,UART_CH0,UART_CH1 
                    Enable:ENABLE:使能接收,DISABLE:取消接收 
* 返回            :   无 
* 依赖            :   底层宏定义 
* 作者            :   cp1300@139.com 
* 时间            :   2013-06-11 
* 最后修改时间    :   2013-06-11 
* 说明            :   无 
*************************************************************************************************************************/  
void UART_RxEnable(UART_CH ch, FunctionalState Enable)  
{  
    switch(ch)  
    {  
        case UART_CH0:  
        {  
            U0CSR = (Enable == ENABLE) ? (U0CSR|BIT6) : (U0CSR&(~BIT6));    //使能接收  
        }break;  
        case UART_CH1:  
        {  
            U1CSR = (Enable == ENABLE) ? (U1CSR|BIT6) : (U1CSR&(~BIT6));    //使能接收  
        }break;  
        default : break;  
    }  
}  
  
  
  
  
//UART0中断服务程序  
#pragma vector=URX0_VECTOR  
__interrupt void UART0_IRQHandler(void)  
{  
    if(UART_RX[0].RxBuffSize > 0)                                          
    {  
        UART_RX[0].RxBuff[UART_RX[0].UartRxCnt ++] = U0DBUF;          
        if(UART_RX[0].UartRxCnt == UART_RX[0].RxBuffSize)                 
        {  
             UART_RX[0].UartRxCnt = 0;                            
             UART_RX[0].BuffFull = 1;                                     
        }  
    }  
    else  
    {  
        URX0IF = 0;             //清除串口接收中断标志  
    }  
}  
  
  
  
  
//UART1中断服务程序  
#pragma vector=URX1_VECTOR  
__interrupt void UART1_IRQHandler(void)  
{  
    if(UART_RX[1].RxBuffSize > 0)                                          
    {  
        UART_RX[1].RxBuff[UART_RX[1].UartRxCnt ++] = U1DBUF;          
        if(UART_RX[1].UartRxCnt == UART_RX[1].RxBuffSize)                 
        {  
             UART_RX[1].UartRxCnt = 0;                            
             UART_RX[1].BuffFull = 1;                                     
        }  
    }  
    else  
    {  
        URX1IF = 0;             //清除串口接收中断标志  
    }  
}  
  
  
  
  
  
/************************************************************************************************************************* 
* 函数            :   bool UART_GetNewData(UART_CH ch, u8 *pData) 
* 功能            :   获取串口新数据 
* 参数            :   ch:通道选择,UART_CH0,UART_CH1 
                    pData:数据缓冲区指针 
* 返回            :   TRUE:有新数据,FALSE:无新数据 
* 依赖            :   底层宏定义 
* 作者            :   cp1300@139.com 
* 时间            :   2013-06-11 
* 最后修改时间    :   2013-06-11 
* 说明            :   用于非中断模式下获取串口新数据 
*************************************************************************************************************************/  
bool UART_GetNewData(UART_CH ch, u8 *pData)  
{  
    switch(ch)  
    {  
        case UART_CH0:  
        {  
            if(U0CSR & BIT2)  
            {  
                *pData = U0DBUF;  
                return TRUE;  
            }  
            return FALSE;  
        }break;  
        case UART_CH1:  
        {  
            if(U1CSR & BIT2)  
            {  
                *pData = U1DBUF;  
                return TRUE;  
            }  
            return FALSE;  
        }break;  
        default : return FALSE;  
    }  
}  
  
  
/************************************************************************************************************************* 
* 函数            :   bool UART_GetRxBuffFullFlag(UART_CH ch) 
* 功能            :   获取串口接收缓冲区满标志 
* 参数            :   ch:通道选择,UART_CH0,UART_CH1 
* 返回            :   TRUE:满,FALSE:没有满 
* 依赖            :   底层宏定义 
* 作者            :   cp1300@139.com 
* 时间            :   2013-06-11 
* 最后修改时间    :   2013-06-11 
* 说明    :           用于判断接收缓冲区是否满,会清除标志 
*************************************************************************************************************************/  
bool UART_GetRxBuffFullFlag(UART_CH ch)  
{  
    if(UART_RX[ch].BuffFull)                //缓冲区已满  
    {  
        UART_RX[ch].BuffFull = 0;           //清除满标志  
        return TRUE;  
    }  
    return FALSE;  
}  
  
  
  
  
/************************************************************************************************************************* 
* 函数            :   void UART_SetRxBuff(UART_CH ch, u8 *pRxBuff, u16 BuffSize) 
* 功能            :   设置串口接收缓冲区 
* 参数            :   ch:通道选择,UART_CH0,UART_CH1 
                    pRxBuff:缓冲区指针,BuffSize:缓冲区大小 
* 返回            :   无 
* 依赖            :   底层宏定义 
* 作者            :   cp1300@139.com 
* 时间            :   2013-06-11 
* 最后修改时间    :   2013-06-11 
* 说明            :   用于中断接收 
*************************************************************************************************************************/  
void UART_SetRxBuff(UART_CH ch, u8 *pRxBuff, u16 BuffSize)  
{  
    UART_RX[ch].RxBuffSize = BuffSize;              //设置缓冲区大小  
    UART_RX[ch].RxBuff = pRxBuff;                   //设置缓冲区指针  
    UART_RX[ch].UartRxCnt = 0;                      //计数器清零  
}  
  
  
  
  
  
/************************************************************************************************************************* 
* 函数            :   u16 UART_GetRxCnt(UART_CH ch) 
* 功能            :   获取串口接收数据计数器 
* 参数            :   ch:通道选择,UART_CH0,UART_CH1 
* 返回            :   接收到的数据数量 
* 依赖            :   底层宏定义 
* 作者            :   cp1300@139.com 
* 时间            :   2013-06-11 
* 最后修改时间    :   2013-06-11 
* 说明            :   无 
*************************************************************************************************************************/  
u16 UART_GetRxCnt(UART_CH ch)  
{  
    return UART_RX[ch].UartRxCnt;               //返回计数值  
}  
  
  
  
  
/************************************************************************************************************************* 
* 函数            :   void UART_ClearRxCnt(UART_CH ch) 
* 功能            :   清除串口接收数据计数器 
* 参数            :   ch:通道选择,UART_CH0,UART_CH1 
* 返回            :   无 
* 依赖            :   底层宏定义 
* 作者            :   cp1300@139.com 
* 时间            :   2013-06-11 
* 最后修改时间    :   2013-06-11 
* 说明            :   无 
*************************************************************************************************************************/  
void UART_ClearRxCnt(UART_CH ch)  
{  
    UART_RX[ch].UartRxCnt = 0;              //计数器清零  
}  






uart.h
[cpp] view plaincopy
/************************************************************************************************************* 
 * 文件名: uart.h 
 * 功能:  CC2530 串口相关函数 
 * 作者:  cp1300@139.com 
* 创建时间: 2013-06-07 21:33 
 * 最后修改时间:2013-06-07 
 * 详细:  串口相关函数 
*************************************************************************************************************/  
#ifndef _UART_H_  
#define _UART_H_  
  
#include "system.h"  
#include "stdio.h"  
  
//串口波特率定义  
typedef enum  
{  
    BAUD_2400   = 0,        //2400  
    BAUD_4800   = 1,        //4800  
    BAUD_9600   = 2,        //9600  
    BAUD_14400  = 3,        //14400  
    BAUD_19200  = 4,        //19200  
    BAUD_28800  = 5,        //28800  
    BAUD_38400  = 6,        //38400  
    BAUD_57600  = 7,        //57600  
    BAUD_76800  = 8,        //76800  
    BAUD_115200 = 9,        //115200  
    BAUD_230400 = 10,       //230400  
} USART_BAUD;  
  
  
  
  
//串口通道选择  
typedef enum  
{  
    UART_CH0    =   0,      //通道0,串口0  
    UART_CH1    =   1,      //通道1,串口1  
} UART_CH;  
  
  
  
//UAR  
void UART_Init(UART_CH ch, USART_BAUD Baud, FunctionalState RxIntEn);   //UART初始化  
void UART_SendByte(UART_CH ch, u8 data);  
void UART_SendData(UART_CH ch, u8 *pbuff, u16 len);                     //串口发送任意长度数据  
void UART_SendString(UART_CH ch, const char *pStr);                     //UART发送字符串  
void UART_RxEnable(UART_CH ch, FunctionalState Enable);                 //UART接收使能  
bool UART_GetNewData(UART_CH ch, u8 *pData);                            //获取串口新数据  
bool UART_GetRxBuffFullFlag(UART_CH ch);                                //获取串口接收缓冲区满标志  
void UART_SetRxBuff(UART_CH ch, u8 *pRxBuff, u16 BuffSize);             //设置串口接收缓冲区  
u16 UART_GetRxCnt(UART_CH ch);                                          //获取串口接收数据计数器  
void UART_ClearRxCnt(UART_CH ch);                                       //清除串口接收数据计数器  
  
    
  
  
  
  
  
  
#endif //_UART_H_  


//重定义printf到串口
[cpp] view plaincopy
#if _PRINTF_EN_  
#include "uart.h"  
#include "stdio.h"  
//#define __CODE_MODEL__ = __CM_BANKED__  
__near_func int putchar(int ch)  
{  
    UART_SendByte(UART_CH0, ch);  
    return ch;  
}  
#endif  






初始化
[cpp] view plaincopy
//主函数  
int main(void)  
{  
    SYS_ClockInit();  
    UART_Init(UART_CH0, BAUD_115200,ENABLE);  
    LED_Init();  
    clock_init();  
    SYS_EnableInt();  
    process_init();  
    process_start(&etimer_process, NULL);  
    autostart_start(autostart_processes);  
    printf("Processes running\n");  
    while(1)  
    {  
        do  
        {  
  
        } while(process_run()> 0);  
        SYS_PowerIdle();            //空闲模式  
    }  
}