//USART0
void Usart0Init(uint32_t baud) //PA10 RX PA9 TX //
{
uint32_t Udiv = 0;
RCU_APB2EN |= 0x00000001<<2; //使能GPIOA时钟
RCU_APB2EN |= 0x00000001<<14; //使能USART0时钟
GPIO_CTL1(GPIOA) &= 0xfffff0ff; //设置RX引脚浮空输入 PA10
GPIO_CTL1(GPIOA) |= (0x00000004<<(4*2));
GPIO_CTL1(GPIOA) &= 0xffffff0f; //设置TX引脚复用推完输出 50M PA9
GPIO_CTL1(GPIOA) |= (0x0000000B<<(4*1));
RCU_APB2RST |= (0x00000001 <<14); //复位USART0
RCU_APB2RST &= ~(0x00000001 <<14); //停止复位
//计算波特率分频比 udiv = UART0_CLK/(16*baud) 但寄存器中中小数点后面有四位，则需要扩大16倍 则 = UART0_CLK/baud
//时钟频率为APB2(系统初始化时已设定APB2等于APB等于系统时钟108M)
Udiv = (APB2_CLK+baud/2)/baud; //参考库函数比用户手册上大一些，是不是因为经验不稳定而加大一点
USART_BAUD(USART0) = (Udiv) & 0x0000ffff; //分频比 共16位 12位整数 4位小数
USART_CTL0(USART0) &= ~(0x00000001 <<12); //12位设置为0 表示8位数据位
USART_CTL1(USART0) &= ~(0x00000003 <<12); //12-13位设置为0 表示1位停止位
USART_CTL0(USART0) &= ~(0x00000003 <<9); //9-10位设置为0 表示无效验位
USART_CTL2(USART0) &= ~(0x00000003 <<8); //8-9位设置为0 表示禁用RTS CTS
USART_CTL0(USART0) &= ~(0x00000003 <<2); //第2位 设置为1 使能接收 3位设置为1 使能发送
USART_CTL0(USART0) |= (0x00000003 <<2);
USART_CTL0(USART0) |= (0x00000003 <<5); //5位置1 接收缓冲器清空中断 6位置1 发送完成中断
nvic_irq_enable(USART0_IRQn, 0, 0); //设置中断优先级
USART_CTL0(USART0) |= (0x00000001 <<13); //使能USART0
}
void USART0_IRQHandler(void)
{
uint32_t tmp = 0;
if(USART_STAT(USART0) &(0x00000001 <<6)) //发送完成
{
USART_STAT(USART0) &= ~(0x00000001 <<6);
if(mUsart0.TX.OntPtr != mUsart0.TX.InPtr)
{
USART_DATA(USART0) = mUsart0.TX.Buffer[mUsart0.TX.OntPtr];
mUsart0.TX.OntPtr++;
if(mUsart0.TX.OntPtr >=USART0_TX_BUFFER_SIZE)
{
mUsart0.TX.OntPtr = 0;
}
}
else
{
mUsart0.IsSending = 0;
}
}
if(USART_STAT(USART0) &(0x00000001 <<5)) //接收到数据
{
tmp = USART_STAT(USART0);
mUsart0.RX.Buffer[mUsart0.RX.InPtr] = USART_DATA(USART0);
mUsart0.RX.InPtr++;
if(mUsart0.RX.InPtr >= USART0_RX_BUFFER_SIZE)
{
mUsart0.RX.InPtr = 0;
}
}
if(USART_STAT(USART0) &(0x00000001 <<3)) //溢出中断
{
tmp = USART_STAT(USART0);
tmp = (USART_DATA(USART0)&0x000000ff);
}
}
void Usart0Send(unsigned char *dta,unsigned char lg)
{
unsigned char i;
for(i=0;i<lg;i++)
{
mUsart0.TX.Buffer[mUsart0.TX.InPtr] = dta[ i];
mUsart0.TX.InPtr++;
if(mUsart0.TX.InPtr >=USART0_TX_BUFFER_SIZE)
{
mUsart0.TX.InPtr = 0;
}
}
if(mUsart0.IsSending == 0)
{
mUsart0.IsSending = 1;
USART_DATA(USART0) = mUsart0.TX.Buffer[mUsart0.TX.OntPtr];
mUsart0.TX.OntPtr++;
if(mUsart0.TX.OntPtr >=USART0_TX_BUFFER_SIZE)
{
mUsart0.TX.OntPtr = 0;
}
}
}
void ResetUsart0DataBuffer(void)
{
unsigned int i;
for(i=0;i<USART0_TX_BUFFER_SIZE;i++)
{
mUsart0.TX.Buffer[ i] = 0;
}
for(i=0;i<USART0_RX_BUFFER_SIZE;i++)
{
mUsart0.RX.Buffer[ i] = 0;
}
mUsart0.TX.OntPtr = 0;
mUsart0.TX.InPtr = 0;
mUsart0.RX.OntPtr = 0;
mUsart0.RX.InPtr = 0;
}
//USART1
void Usart1Init(uint32_t baud) //PA3 RX PA2 TX
{
uint32_t Udiv = 0;
RCU_APB2EN |= 0x00000001<<2; //使能GPIOA时钟
RCU_APB1EN |= 0x00000001<<17; //使能USART1时钟
GPIO_CTL0(GPIOA) &= 0xffff0fff; //设置RX引脚浮空输入 PA3
GPIO_CTL0(GPIOA) |= (0x00000004<<(4*3));
GPIO_CTL0(GPIOA) &= 0xfffff0ff; //设置TX引脚复用推完输出 50M PA2
GPIO_CTL0(GPIOA) |= (0x0000000B<<(4*2));
RCU_APB1RST |= (0x00000001 <<17); //复位USART1
RCU_APB1RST &= ~(0x00000001 <<17); //停止复位
//计算波特率分频比 udiv = UART0_CLK/(16*baud) 但寄存器中中小数点后面有四位，则需要扩大16倍 则 = UART0_CLK/baud
//时钟频率为APB1(系统初始化时已设定APB2等于APB/2等于系统时钟108M/2)
Udiv = (APB1_CLK+baud/2)/baud; //参考库函数比用户手册上大一些，是不是因为经验不稳定而加大一点
USART_BAUD(USART1) = (Udiv) & 0x0000ffff; //分频比 共16位 12位整数 4位小数
USART_CTL0(USART1) &= ~(0x00000001 <<12); //12位设置为0 表示8位数据位
USART_CTL1(USART1) &= ~(0x00000003 <<12); //12-13位设置为0 表示1位停止位
USART_CTL0(USART1) &= ~(0x00000003 <<9); //9-10位设置为0 表示无效验位
USART_CTL2(USART1) &= ~(0x00000003 <<8); //8-9位设置为0 表示禁用RTS CTS
USART_CTL0(USART1) &= ~(0x00000003 <<2); //第2位 设置为1 使能接收 3位设置为1 使能发送
USART_CTL0(USART1) |= (0x00000003 <<2);
USART_CTL0(USART1) |= (0x00000003 <<5); //5位置1 接收缓冲器清空中断 6位置1 发送完成中断
nvic_irq_enable(USART1_IRQn, 0, 0); //设置中断优先级
USART_CTL0(USART1) |= (0x00000001 <<13); //使能USART0
}
void USART1_IRQHandler(void)
{
uint32_t tmp = 0;
if(USART_STAT(USART1) &(0x00000001 <<6)) //发送完成
{
USART_STAT(USART1) &= ~(0x00000001 <<6);
if(mUsart1.TX.OntPtr != mUsart1.TX.InPtr)
{
USART_DATA(USART1) = mUsart1.TX.Buffer[mUsart1.TX.OntPtr];
mUsart1.TX.OntPtr++;
if(mUsart1.TX.OntPtr >=USART1_TX_BUFFER_SIZE)
{
mUsart1.TX.OntPtr = 0;
}
}
else
{
mUsart1.IsSending = 0;
}
}
if(USART_STAT(USART1) &(0x00000001 <<5)) //接收到数据
{
tmp = USART_STAT(USART1);
mUsart1.RX.Buffer[mUsart1.RX.InPtr] = USART_DATA(USART1);
mUsart1.RX.InPtr++;
if(mUsart1.RX.InPtr >= USART1_RX_BUFFER_SIZE)
{
mUsart1.RX.InPtr = 0;
}
}
if(USART_STAT(USART1) &(0x00000001 <<3)) //溢出中断
{
tmp = USART_STAT(USART1);
tmp = (USART_DATA(USART1)&0x000000ff);
}
}
void Usart1Send(unsigned char *dta,unsigned char lg)
{
unsigned char i;
for(i=0;i<lg;i++)
{
mUsart1.TX.Buffer[mUsart1.TX.InPtr] = dta[ i];
mUsart1.TX.InPtr++;
if(mUsart1.TX.InPtr >=USART1_TX_BUFFER_SIZE)
{
mUsart1.TX.InPtr = 0;
}
}
if(mUsart1.IsSending == 0)
{
mUsart1.IsSending = 1;
USART_DATA(USART1) = mUsart1.TX.Buffer[mUsart1.TX.OntPtr];
mUsart1.TX.OntPtr++;
if(mUsart1.TX.OntPtr >=USART1_TX_BUFFER_SIZE)
{
mUsart1.TX.OntPtr = 0;
}
}
}
void ResetUsart1DataBuffer(void)
{
unsigned int i;
for(i=0;i<USART1_TX_BUFFER_SIZE;i++)
{
mUsart1.TX.Buffer[ i] = 0;
}
for(i=0;i<USART1_RX_BUFFER_SIZE;i++)
{
mUsart1.RX.Buffer[ i] = 0;
}
mUsart1.TX.OntPtr = 0;
mUsart1.TX.InPtr = 0;
mUsart1.RX.OntPtr = 0;
mUsart1.RX.InPtr = 0;
}
//
void Usart2Init(uint32_t baud) //PB11 RX PB10 TX
{
uint32_t Udiv = 0;
RCU_APB2EN |= 0x00000001<<3; //使能GPIOB时钟
RCU_APB1EN |= 0x00000001<<18; //使能USART2时钟
GPIO_CTL1(GPIOB) &= 0xffff0fff; //设置RX引脚浮空输入 PA10
GPIO_CTL1(GPIOB) |= (0x00000004<<(4*3));
GPIO_CTL1(GPIOB) &= 0xfffff0ff; //设置TX引脚复用推完输出 50M PB10
GPIO_CTL1(GPIOB) |= (0x0000000B<<(4*2));
RCU_APB1RST |= (0x00000001 <<18); //复位USART2
RCU_APB1RST &= ~(0x00000001 <<18); //停止复位
//计算波特率分频比 udiv = UART0_CLK/(16*baud) 但寄存器中中小数点后面有四位，则需要扩大16倍 则 = UART0_CLK/baud
//时钟频率为APB1(系统初始化时已设定APB2等于APB/2等于系统时钟108M/2)
Udiv = (APB1_CLK+baud/2)/baud; //参考库函数比用户手册上大一些，是不是因为经验不稳定而加大一点
USART_BAUD(USART2) = (Udiv) & 0x0000ffff; //分频比 共16位 12位整数 4位小数
USART_CTL0(USART2) &= ~(0x00000001 <<12); //12位设置为0 表示8位数据位
USART_CTL1(USART2) &= ~(0x00000003 <<12); //12-13位设置为0 表示1位停止位
USART_CTL0(USART2) &= ~(0x00000003 <<9); //9-10位设置为0 表示无效验位
USART_CTL2(USART2) &= ~(0x00000003 <<8); //8-9位设置为0 表示禁用RTS CTS
USART_CTL0(USART2) &= ~(0x00000003 <<2); //第2位 设置为1 使能接收 3位设置为1 使能发送
USART_CTL0(USART2) |= (0x00000003 <<2);
USART_CTL0(USART2) |= (0x00000003 <<5); //5位置1 接收缓冲器清空中断 6位置1 发送完成中断
nvic_irq_enable(USART2_IRQn, 0, 0); //设置中断优先级
USART_CTL0(USART2) |= (0x00000001 <<13); //使能USART0
}
void USART2_IRQHandler(void)
{
uint32_t tmp = 0;
if(USART_STAT(USART2) &(0x00000001 <<6)) //发送完成
{
USART_STAT(USART2) &= ~(0x00000001 <<6);
if(mUsart2.TX.OntPtr != mUsart2.TX.InPtr)
{
USART_DATA(USART2) = mUsart2.TX.Buffer[mUsart2.TX.OntPtr];
mUsart2.TX.OntPtr++;
if(mUsart2.TX.OntPtr >=USART2_TX_BUFFER_SIZE)
{
mUsart2.TX.OntPtr = 0;
}
}
else
{
mUsart2.IsSending = 0;
}
}
if(USART_STAT(USART2) &(0x00000001 <<5)) //接收到数据
{
tmp = USART_STAT(USART2);
mUsart2.RX.Buffer[mUsart2.RX.InPtr] = USART_DATA(USART2);
mUsart2.RX.InPtr++;
if(mUsart2.RX.InPtr >= USART2_RX_BUFFER_SIZE)
{
mUsart2.RX.InPtr = 0;
}
}
if(USART_STAT(USART2) &(0x00000001 <<3)) //溢出中断
{
tmp = USART_STAT(USART2);
tmp = (USART_DATA(USART2)&0x000000ff);
}
}
void Usart2Send(unsigned char *dta,unsigned char lg)
{
unsigned char i;
for(i=0;i<lg;i++)
{
mUsart2.TX.Buffer[mUsart2.TX.InPtr] = dta[ i];
mUsart2.TX.InPtr++;
if(mUsart2.TX.InPtr >=USART2_TX_BUFFER_SIZE)
{
mUsart2.TX.InPtr = 0;
}
}
if(mUsart2.IsSending == 0)
{
mUsart2.IsSending = 1;
USART_DATA(USART2) = mUsart2.TX.Buffer[mUsart2.TX.OntPtr];
mUsart2.TX.OntPtr++;
if(mUsart2.TX.OntPtr >=USART2_TX_BUFFER_SIZE)
{
mUsart2.TX.OntPtr = 0;
}
}
}
void ResetUsart2DataBuffer(void)
{
unsigned int i;
for(i=0;i<USART2_TX_BUFFER_SIZE;i++)
{
mUsart2.TX.Buffer[ i] = 0;
}
for(i=0;i<USART2_RX_BUFFER_SIZE;i++)
{
mUsart2.RX.Buffer[ i] = 0;
}
mUsart2.TX.OntPtr = 0;
mUsart2.TX.InPtr = 0;
mUsart2.RX.OntPtr = 0;
mUsart2.RX.InPtr = 0;
}
void Usart3Init(uint32_t baud) //PC11 RX PC10 TX
{
uint32_t Udiv = 0;
RCU_APB2EN |= 0x00000001<<4; //使能GPIOC时钟
RCU_APB1EN |= 0x00000001<<19; //使能USART2时钟
GPIO_CTL1(GPIOC) &= 0xffff0fff; //设置RX引脚浮空输入 PC11
GPIO_CTL1(GPIOC) |= (0x00000004<<(4*3));
GPIO_CTL1(GPIOC) &= 0xfffff0ff; //设置TX引脚复用推完输出 50M PC10
GPIO_CTL1(GPIOC) |= (0x0000000B<<(4*2));
RCU_APB1RST |= (0x00000001 <<19); //复位USART2
RCU_APB1RST &= ~(0x00000001 <<19); //停止复位
//计算波特率分频比 udiv = UART0_CLK/(16*baud) 但寄存器中中小数点后面有四位，则需要扩大16倍 则 = UART0_CLK/baud
//时钟频率为APB1(系统初始化时已设定APB2等于APB/2等于系统时钟108M/2)
Udiv = (APB1_CLK+baud/2)/baud; //参考库函数比用户手册上大一些，是不是因为经验不稳定而加大一点
USART_BAUD(UART3) = (Udiv) & 0x0000ffff; //分频比 共16位 12位整数 4位小数
USART_CTL0(UART3) &= ~(0x00000001 <<12); //12位设置为0 表示8位数据位
USART_CTL1(UART3) &= ~(0x00000003 <<12); //12-13位设置为0 表示1位停止位
USART_CTL0(UART3) &= ~(0x00000003 <<9); //9-10位设置为0 表示无效验位
USART_CTL2(UART3) &= ~(0x00000003 <<8); //8-9位设置为0 表示禁用RTS CTS
USART_CTL0(UART3) &= ~(0x00000003 <<2); //第2位 设置为1 使能接收 3位设置为1 使能发送
USART_CTL0(UART3) |= (0x00000003 <<2);
USART_CTL0(UART3) |= (0x00000003 <<5); //5位置1 接收缓冲器清空中断 6位置1 发送完成中断
nvic_irq_enable(UART3_IRQn, 0, 1); //设置中断优先级
USART_CTL0(UART3) |= (0x00000001 <<13); //使能USART0
}
void UART3_IRQHandler(void)
{
uint32_t tmp = 0;
if(USART_STAT(UART3) &(0x00000001 <<6)) //发送完成
{
USART_STAT(UART3) &= ~(0x00000001 <<6);
if(mUsart3.TX.OntPtr != mUsart3.TX.InPtr)
{
USART_DATA(UART3) = mUsart3.TX.Buffer[mUsart3.TX.OntPtr];
mUsart3.TX.OntPtr++;
if(mUsart3.TX.OntPtr >=USART3_TX_BUFFER_SIZE)
{
mUsart3.TX.OntPtr = 0;
}
}
else
{
mUsart3.IsSending = 0;
}
}
if(USART_STAT(UART3) &(0x00000001 <<5)) //接收到数据
{
tmp = USART_STAT(UART3);
mUsart3.RX.Buffer[mUsart3.RX.InPtr] = USART_DATA(UART3);
mUsart3.RX.InPtr++;
if(mUsart3.RX.InPtr >= USART3_RX_BUFFER_SIZE)
{
mUsart3.RX.InPtr = 0;
}
}
if(USART_STAT(UART3) &(0x00000001 <<3)) //溢出中断
{
tmp = USART_STAT(UART3);
tmp = (USART_DATA(UART3)&0x000000ff);
}
}
void Usart3Send(unsigned char *dta,unsigned char lg)
{
unsigned char i;
for(i=0;i<lg;i++)
{
mUsart3.TX.Buffer[mUsart3.TX.InPtr] = dta[ i];
mUsart3.TX.InPtr++;
if(mUsart3.TX.InPtr >=USART3_TX_BUFFER_SIZE)
{
mUsart3.TX.InPtr = 0;
}
}
if(mUsart3.IsSending == 0)
{
mUsart3.IsSending = 1;
USART_DATA(UART3) = mUsart3.TX.Buffer[mUsart3.TX.OntPtr];
mUsart3.TX.OntPtr++;
if(mUsart3.TX.OntPtr >=USART3_TX_BUFFER_SIZE)
{
mUsart3.TX.OntPtr = 0;
}
}
}
void ResetUsart3DataBuffer(void)
{
unsigned int i;
for(i=0;i<USART3_TX_BUFFER_SIZE;i++)
{
mUsart3.TX.Buffer[ i] = 0;
}
for(i=0;i<USART3_RX_BUFFER_SIZE;i++)
{
mUsart3.RX.Buffer[ i] = 0;
}
mUsart3.TX.OntPtr = 0;
mUsart3.TX.InPtr = 0;
mUsart3.RX.OntPtr = 0;
mUsart3.RX.InPtr = 0;
}
void Usart4Init(uint32_t baud) //PD2 RX PC12 TX
{
uint32_t Udiv = 0;
RCU_APB2EN |= 0x00000001<<5; //使能GPIOD时钟
RCU_APB2EN |= 0x00000001<<4; //使能GPIOC时钟
RCU_APB1EN |= 0x00000001<<20; //使能USART2时钟
GPIO_CTL0(GPIOD) &= 0xffffF0ff; //设置RX引脚浮空输入 PD2
GPIO_CTL0(GPIOD) |= (0x00000004<<(4*2));
GPIO_CTL1(GPIOC) &= 0xfff0ffff; //设置TX引脚复用推完输出 50M PC12
GPIO_CTL1(GPIOC) |= (0x0000000B<<(4*4));
RCU_APB1RST |= (0x00000001 <<20); //复位USART2
RCU_APB1RST &= ~(0x00000001 <<20); //停止复位
//计算波特率分频比 udiv = UART0_CLK/(16*baud) 但寄存器中中小数点后面有四位，则需要扩大16倍 则 = UART0_CLK/baud
//时钟频率为APB1(系统初始化时已设定APB2等于APB/2等于系统时钟108M/2)
Udiv = (APB1_CLK+baud/2)/baud; //参考库函数比用户手册上大一些，是不是因为经验不稳定而加大一点
USART_BAUD(UART4) = (Udiv) & 0x0000ffff; //分频比 共16位 12位整数 4位小数
USART_CTL0(UART4) &= ~(0x00000001 <<12); //12位设置为1 表示8位数据位
USART_CTL1(UART4) &= ~(0x00000003 <<12); //12-13位设置为0 表示1位停止位
USART_CTL0(UART4) &= ~(0x00000003 <<9); //9-10位设置为0 表示无效验位
USART_CTL2(UART4) &= ~(0x00000003 <<8); //8-9位设置为0 表示禁用RTS CTS
USART_CTL0(UART4) &= ~(0x00000003 <<2); //第2位 设置为1 使能接收 3位设置为1 使能发送
USART_CTL0(UART4) |= (0x00000003 <<2);
USART_CTL0(UART4) |= (0x00000003 <<5); //5位置1 接收缓冲器清空中断 6位置1 发送完成中断
nvic_irq_enable(UART4_IRQn, 1, 1); //设置中断优先级
USART_CTL0(UART4) |= (0x00000001 <<13); //使能USART0
}
void UART4_IRQHandler(void)
{
uint32_t tmp = 0;
if(USART_STAT(UART4) &(0x00000001 <<6)) //发送完成
{
USART_STAT(UART4) &= ~(0x00000001 <<6);
if(mUsart4.TX.OntPtr != mUsart4.TX.InPtr)
{
USART_DATA(UART4) = mUsart4.TX.Buffer[mUsart4.TX.OntPtr];
mUsart4.TX.OntPtr++;
if(mUsart4.TX.OntPtr >=USART4_TX_BUFFER_SIZE)
{
mUsart4.TX.OntPtr = 0;
}
}
else
{
mUsart4.IsSending = 0;
}
}
if(USART_STAT(UART4) &(0x00000001 <<5)) //接收到数据
{
tmp = USART_STAT(UART4);
mUsart4.RX.Buffer[mUsart4.RX.InPtr] = USART_DATA(UART4);
mUsart4.RX.InPtr++;
if(mUsart4.RX.InPtr >= USART4_RX_BUFFER_SIZE)
{
mUsart4.RX.InPtr = 0;
}
}
if(USART_STAT(UART4) &(0x00000001 <<3)) //溢出中断
{
tmp = USART_STAT(UART4);
tmp = (USART_DATA(UART4)&0x000000ff);
}
}
void Usart4Send(unsigned char *dta,unsigned char lg)
{
unsigned char i;
for(i=0;i<lg;i++)
{
mUsart4.TX.Buffer[mUsart4.TX.InPtr] = dta[ i];
mUsart4.TX.InPtr++;
if(mUsart4.TX.InPtr >=USART4_TX_BUFFER_SIZE)
{
mUsart4.TX.InPtr = 0;
}
}
if(mUsart4.IsSending == 0)
{
mUsart4.IsSending = 1;
USART_DATA(UART4) = mUsart4.TX.Buffer[mUsart4.TX.OntPtr];
mUsart4.TX.OntPtr++;
if(mUsart4.TX.OntPtr >=USART4_TX_BUFFER_SIZE)
{
mUsart4.TX.OntPtr = 0;
}
}
}
void ResetUsart4DataBuffer(void)
{
unsigned int i;
for(i=0;i<USART4_TX_BUFFER_SIZE;i++)
{
mUsart4.TX.Buffer[ i] = 0;
}
for(i=0;i<USART4_RX_BUFFER_SIZE;i++)
{
mUsart4.RX.Buffer[ i] = 0;
}
mUsart4.TX.OntPtr = 0;
mUsart4.TX.InPtr = 0;
mUsart4.RX.OntPtr = 0;
mUsart4.RX.InPtr = 0;
}
|
