//USART.c
#include "usart.h"
#include "stdarg.h"
#include "string.h"
#include "stdio.h"
#include "headfile.h"
//P1.2  UART0RXD,收
//P1.3  UART0TXD,发

//P2.2  UART1RXD,收
//P2.3  UART1TXD,发

//P3.2  UART2RXD,收
//P3.3  UART2TXD,发

//P9.6  UART3RXD,收
//P9.7  UART3TXD,发
/********************************************/
//波特率计算公式：
// N=时钟主频/波特率
// 如果 N<16  UCBRx=INT(N),UCBRF=0;
// 如果 N>16  UCBRx=INT(N/16),UCBRF=INT{[(N/16)-INT(N/16)]*16}
// UCBRS 取值见MSP432 USER'S GUIDE P731
// 或者 使用计算器 
// software-dl.ti.com/msp430/msp430_public_sw/mcu/msp430/MSP430BaudRateConverter/index.html
/********************************************/


u8 USART0_RX_BUF[USART0_MAX_RECV_LEN]; 				//接收缓冲,最大USART0_MAX_RECV_LEN个字节.
u8 USART0_TX_BUF[USART0_MAX_SEND_LEN]; 			    //发送缓冲,最大USART0_MAX_SEND_LEN字节.

u16 U0_len=0;
u16 Datalength0=0;//接受的数据长度

u8 USART1_RX_BUF[USART1_MAX_RECV_LEN]; 				//接收缓冲,最大USART1_MAX_RECV_LEN个字节.
u8 USART1_TX_BUF[USART1_MAX_SEND_LEN]; 			    //发送缓冲,最大USART1_MAX_SEND_LEN字节.

u16 U1_len=0;
u16 Datalength1=0;//接受的数据长度

u8 USART2_RX_BUF[USART2_MAX_RECV_LEN]; 				//接收缓冲,最大USART2_MAX_RECV_LEN个字节.
u8 USART2_TX_BUF[USART2_MAX_SEND_LEN]; 			    //发送缓冲,最大USART2_MAX_SEND_LEN字节.

u16 U2_len=0;
u16 Datalength2=0;//接受的数据长度

u8 USART3_RX_BUF[USART3_MAX_RECV_LEN]; 				//接收缓冲,最大USART2_MAX_RECV_LEN个字节.
u8 USART3_TX_BUF[USART3_MAX_SEND_LEN]; 			    //发送缓冲,最大USART2_MAX_SEND_LEN字节.

u16 U3_len=0;
u16 Datalength3=0;//接受的数据长度

void clean_BuffU0(void)
{
	u16 i;
	Datalength0=U0_len&0x3fff;//得到此次接收到的数据长度
	for(i=0;i<Datalength0;i++)
	USART0_RX_BUF[i]=0;
}

void clean_BuffU1(void)
{
	u16 i;
	Datalength1=U1_len&0x3fff;//得到此次接收到的数据长度
	for(i=0;i<Datalength1;i++)
	USART1_RX_BUF[i]=0;
}

void clean_BuffU2(void)
{
	u16 i;
	Datalength2=U2_len&0x3fff;//得到此次接收到的数据长度
	for(i=0;i<Datalength2;i++)
	USART2_RX_BUF[i]=0;
}

void clean_BuffU3(void)
{
	u16 i;
	Datalength3=U3_len&0x3fff;//得到此次接收到的数据长度
	for(i=0;i<Datalength3;i++)
	USART3_RX_BUF[i]=0;
}
 
//////////////////////////////////////////////////////
                /* 串口0 115200*/
//frequency  48M
//定义一个常量uartConfig0，用于配置eUSCI_UART模块的参数，用于配置串口通信的工作方式

/*****************************************************************************************************
EUSCI_A_UART_CLOCKSOURCE_SMCLK：表示UART模块时钟源采用SMCLK（主系统时钟）；
26：表示波特率分频器的分频系数BRDIV，用来计算波特率的，通常是根据主系统时钟频率和波特率来计算得到；
0：表示波特率修正因子UCxBRF，用来微调波特率，一般设置为0；
111：表示波特率修正因子UCxBRS，用来微调波特率，一般设置为0；
EUSCI_A_UART_NO_PARITY：表示不进行任何奇偶校验；
EUSCI_A_UART_LSB_FIRST：表示数据的LSB位在前，因为UART通信是先发送最低有效位；
EUSCI_A_UART_ONE_STOP_BIT：表示传输一个停止位；
EUSCI_A_UART_MODE：表示UART模式，通常选择UART模式以进行异步串口通信；
EUSCI_A_UART_OVERSAMPLING_BAUDRATE_GENERATION：表示波特率的过采样倍数，通常为1。
****************************************************************************************************/
const eUSCI_UART_ConfigV1 uartConfig0 =
{
        EUSCI_A_UART_CLOCKSOURCE_SMCLK,          // SMCLK Clock Source
        26,                                      // BRDIV = 26
        0,                                       // UCxBRF = 0
        111,                                       // UCxBRS = 111
        EUSCI_A_UART_NO_PARITY,                  // 无奇偶校验
        EUSCI_A_UART_LSB_FIRST,                  // LSB First
        EUSCI_A_UART_ONE_STOP_BIT,               // One stop bit
        EUSCI_A_UART_MODE,                       // UART mode
        EUSCI_A_UART_OVERSAMPLING_BAUDRATE_GENERATION  // Oversampling
};

/*初始化串口0*/
void Usart0tInit(void)
{
		//GPIO配置，将P1.2和P1.3两个引脚配置为GPIO的主要模块功能输入引脚，以便作为外设模块的输入引脚使用
    MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,GPIO_PIN2|GPIO_PIN3,GPIO_PRIMARY_MODULE_FUNCTION);
    //配置UART，使用EUSCI_A0模块作为UART串口通信模块
    MAP_UART_initModule(EUSCI_A0_BASE,&uartConfig0);
    MAP_UART_enableModule(EUSCI_A0_BASE); //模块使能
	
    /* 串口中断 */
    MAP_UART_enableInterrupt(EUSCI_A0_BASE, EUSCI_A_UART_RECEIVE_INTERRUPT); //
    MAP_Interrupt_enableInterrupt(INT_EUSCIA0); //使能EUSCIA0模块的中断，在使用EUSCI之前必须先启用所需的EUSCIA中断
    MAP_Interrupt_enableMaster();    //使能全局中断，总开关
}

/*输出格式化的字符串*/
/*u0_printf("Integer:d%, Float:f%, String:s%", num, fnum, str)*/
void u0_printf(char* fmt,...)  
{  
	u16 i,j; 
	va_list ap;
	va_start(ap,fmt);
	vsprintf((char*)USART0_TX_BUF,fmt,ap); //vsprintf()将格式化的字符串和参数写入USART0_TX_BUF数组中
	va_end(ap);
	i=strlen((const char*)USART0_TX_BUF);		//此次发送数据的长度
	for(j=0;j<i;j++)							//循环发送数据
	{
		UART_transmitData(EUSCI_A0_BASE, USART0_TX_BUF[j]); //发送数据
	} 
}  

void u0_SendData(unsigned char *string)
{
	do
	{
		UART_transmitData(EUSCI_A0_BASE, *string); //发送数据
		string++;
	}while(*string!=0);
}
  
/* EUSCI A0 UART ISR - Echoes data back to PC host，中断服务函数 */
void EUSCIA0_IRQHandler(void)
{
	u8  rev ;
    uint32_t status = UART_getEnabledInterruptStatus(EUSCI_A0_BASE);//中断接收标志，获取中断状态
    UART_clearInterruptFlag(EUSCI_A0_BASE, status);//清除中断标志
    if(status & EUSCI_A_UART_RECEIVE_INTERRUPT_FLAG)  //说明接收到数据
    {
		rev=UART_receiveData(EUSCI_A0_BASE);
		
		if(U0_len&0x8000)
		{
			clean_BuffU0();
			U0_len=0;	
		}
		
		if((U0_len&0x8000)==0)//接收未完成
		{
			if(U0_len&0x4000)//接收到了0x0d
			{
				if(rev!=0x0a)U0_len=0;//接收错误,重新开始
				else U0_len|=0x8000;	//接收完成了 
			}
			else //还没收到0X0D
			{	
				if(rev==0x0d)U0_len|=0x4000;
				else
				{
					USART0_RX_BUF[U0_len&0X3FFF]=rev ;
					U0_len++;
					if(U0_len>(USART0_MAX_RECV_LEN-1))U0_len=0;//接收数据错误,重新开始接收	  
				}		 
			}
		} 
     }
}

//////////////////////////////////////////////////////
             /*  串口1  115200*/
   //frequency  48M 
const eUSCI_UART_ConfigV1 uartConfig1 =
{
        EUSCI_A_UART_CLOCKSOURCE_SMCLK,          // SMCLK Clock Source
        26,                                      // BRDIV = 26
        0,                                       // UCxBRF = 0
        111,                                       // UCxBRS = 111
        EUSCI_A_UART_NO_PARITY,                  // 无奇偶校验
        EUSCI_A_UART_LSB_FIRST,                  // LSB First
        EUSCI_A_UART_ONE_STOP_BIT,               // One stop bit
        EUSCI_A_UART_MODE,                       // UART mode
        EUSCI_A_UART_OVERSAMPLING_BAUDRATE_GENERATION  // Oversampling
};

void Usart1tInit(void)
{
	//GPIO配置
    MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P2,GPIO_PIN2|GPIO_PIN3,GPIO_PRIMARY_MODULE_FUNCTION);
    //配置UART
    MAP_UART_initModule(EUSCI_A1_BASE,&uartConfig1);
    MAP_UART_enableModule(EUSCI_A1_BASE);
	
    /* Enabling interrupts */
    MAP_UART_enableInterrupt(EUSCI_A1_BASE, EUSCI_A_UART_RECEIVE_INTERRUPT);
    MAP_Interrupt_enableInterrupt(INT_EUSCIA1);
    MAP_Interrupt_enableMaster();     
}
 
void u1_printf(char* fmt,...)  
{  
	u16 i,j; 
	va_list ap; 
	va_start(ap,fmt);
	vsprintf((char*)USART1_TX_BUF,fmt,ap);
	va_end(ap);
	i=strlen((const char*)USART1_TX_BUF);		//此次发送数据的长度
	for(j=0;j<i;j++)							//循环发送数据
	{
		UART_transmitData(EUSCI_A1_BASE, USART1_TX_BUF[j]); //发送数据
	} 
}  

void u1_SendData(unsigned char *string)
{
	do
	{
		UART_transmitData(EUSCI_A1_BASE, *string); //发送数据
		string++;
	}while(*string!=0);
}

/* EUSCI A0 UART ISR - Echoes data back to PC host */
void EUSCIA1_IRQHandler(void)
{
	u8  rev ;
    uint32_t status = UART_getEnabledInterruptStatus(EUSCI_A1_BASE);//中断接收标志
    UART_clearInterruptFlag(EUSCI_A1_BASE, status);//清除中断标志
    if(status & EUSCI_A_UART_RECEIVE_INTERRUPT_FLAG)  //说明接收到数据
    {
		rev=UART_receiveData(EUSCI_A1_BASE);
		
		if(U1_len&0x8000)
		{
			clean_BuffU1();
			U1_len=0;	
		}
		
		if((U1_len&0x8000)==0)//接收未完成
		{
			if(U1_len&0x4000)//接收到了0x0d
			{
				if(rev!=0x0a)U1_len=0;//接收错误,重新开始
				else U1_len|=0x8000;	//接收完成了 
			}
			else //还没收到0X0D
			{	
				if(rev==0x0d)U1_len|=0x4000;
				else
				{
					USART1_RX_BUF[U1_len&0X3FFF]=rev ;
					U1_len++;
					if(U1_len>(USART1_MAX_RECV_LEN-1))U1_len=0;//接收数据错误,重新开始接收	  
				}		 
			}
		} 
     }
}

//////////////////////////////////////////////////////
             /*  串口2  115200*/
   //frequency  48M 
const eUSCI_UART_ConfigV1 uartConfig2 =
{
        EUSCI_A_UART_CLOCKSOURCE_SMCLK,          // SMCLK Clock Source
        26,                                      // BRDIV = 26
        0,                                       // UCxBRF = 0
        111,                                       // UCxBRS = 111
        EUSCI_A_UART_NO_PARITY,                  // 无奇偶校验
        EUSCI_A_UART_LSB_FIRST,                  // LSB First
        EUSCI_A_UART_ONE_STOP_BIT,               // One stop bit
        EUSCI_A_UART_MODE,                       // UART mode
        EUSCI_A_UART_OVERSAMPLING_BAUDRATE_GENERATION  // Oversampling
};

void Usart2tInit(void)
{
	//GPIO配置
    MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P3,GPIO_PIN2|GPIO_PIN3,GPIO_PRIMARY_MODULE_FUNCTION);
    //配置UART
    MAP_UART_initModule(EUSCI_A2_BASE,&uartConfig2);
    MAP_UART_enableModule(EUSCI_A2_BASE);
	
    /* Enabling interrupts */
    MAP_UART_enableInterrupt(EUSCI_A2_BASE, EUSCI_A_UART_RECEIVE_INTERRUPT);
    MAP_Interrupt_enableInterrupt(INT_EUSCIA2);
    MAP_Interrupt_enableMaster();     
}
 
void u2_printf(char* fmt,...)  
{  
	u16 i,j; 
	va_list ap; 
	va_start(ap,fmt);
	vsprintf((char*)USART2_TX_BUF,fmt,ap);
	va_end(ap);
	i=strlen((const char*)USART2_TX_BUF);		//此次发送数据的长度
	for(j=0;j<i;j++)							//循环发送数据
	{
		UART_transmitData(EUSCI_A2_BASE, USART2_TX_BUF[j]); //发送数据
	} 
}  

void u2_SendData(unsigned char *string)
{
	do
	{
		UART_transmitData(EUSCI_A2_BASE, *string); //发送数据
		string++;
	}while(*string!=0);
}

/* EUSCI A0 UART ISR - Echoes data back to PC host */
void EUSCIA2_IRQHandler(void)
{
	u8  rev ;
    uint32_t status = UART_getEnabledInterruptStatus(EUSCI_A2_BASE);//中断接收标志
    UART_clearInterruptFlag(EUSCI_A2_BASE, status);//清除中断标志
    if(status & EUSCI_A_UART_RECEIVE_INTERRUPT_FLAG)  //说明接收到数据
    {
		rev=UART_receiveData(EUSCI_A2_BASE);
		CopeSerial2Data(rev);
     }
}

//////////////////////////////////////////////////////
             /*  串口3  115200*/
   //frequency  48M 
const eUSCI_UART_ConfigV1 uartConfig3 =
{
        EUSCI_A_UART_CLOCKSOURCE_SMCLK,          // SMCLK Clock Source
        26,                                      // BRDIV = 26
        0,                                       // UCxBRF = 0
        111,                                       // UCxBRS = 111
        EUSCI_A_UART_NO_PARITY,                  // 无奇偶校验
        EUSCI_A_UART_LSB_FIRST,                  // LSB First
        EUSCI_A_UART_ONE_STOP_BIT,               // One stop bit
        EUSCI_A_UART_MODE,                       // UART mode
        EUSCI_A_UART_OVERSAMPLING_BAUDRATE_GENERATION  // Oversampling
};

void Usart3tInit(void)
{
	//GPIO配置
    MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P9,GPIO_PIN6|GPIO_PIN7,GPIO_PRIMARY_MODULE_FUNCTION);
    //配置DCO频率
    CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_12);
    //配置UART
    MAP_UART_initModule(EUSCI_A3_BASE,&uartConfig3);
    MAP_UART_enableModule(EUSCI_A3_BASE);
	
    /* Enabling interrupts */
    MAP_UART_enableInterrupt(EUSCI_A3_BASE, EUSCI_A_UART_RECEIVE_INTERRUPT);
    MAP_Interrupt_enableInterrupt(INT_EUSCIA3);
    MAP_Interrupt_enableMaster();     
}
 
void u3_printf(char* fmt,...)  
{  
	u16 i,j; 
	va_list ap; 
	va_start(ap,fmt);
	vsprintf((char*)USART3_TX_BUF,fmt,ap);
	va_end(ap);
	i=strlen((const char*)USART3_TX_BUF);		//此次发送数据的长度
	for(j=0;j<i;j++)							//循环发送数据
	{
		UART_transmitData(EUSCI_A3_BASE, USART3_TX_BUF[j]); //发送数据
	} 
}  

void u3_SendData(unsigned char *string)
{
	do
	{
		UART_transmitData(EUSCI_A3_BASE, *string); //发送数据
		string++;
	}while(*string!=0);
}

/* EUSCI A0 UART ISR - Echoes data back to PC host */
void EUSCIA3_IRQHandler(void)
{
	u8  rev ;
    uint32_t status = UART_getEnabledInterruptStatus(EUSCI_A3_BASE);//中断接收标志
    UART_clearInterruptFlag(EUSCI_A3_BASE, status);//清除中断标志
    if(status & EUSCI_A_UART_RECEIVE_INTERRUPT_FLAG)  //说明接收到数据
    {
		rev=UART_receiveData(EUSCI_A3_BASE);
		
		if(U3_len&0x8000)
		{
			clean_BuffU3();
			U3_len=0;	
		}
		
		if((U3_len&0x8000)==0)//接收未完成
		{
			if(U3_len&0x4000)//接收到了0x0d
			{
				if(rev!=0x0a)U3_len=0;//接收错误,重新开始
				else U3_len|=0x8000;	//接收完成了 
			}
			else //还没收到0X0D
			{	
				if(rev==0x0d)U3_len|=0x4000;
				else
				{
					USART3_RX_BUF[U3_len&0X3FFF]=rev ;
					U3_len++;
					if(U3_len>(USART3_MAX_RECV_LEN-1))U3_len=0;//接收数据错误,重新开始接收	  
				}		 
			}
		} 
     }
}