找回密碼
 立即注冊(cè)

QQ登錄

只需一步,快速開始

搜索
查看: 4035|回復(fù): 1
收起左側(cè)

GD32F103RCT6單片機(jī)串口初始化寄存器版代碼(循環(huán)數(shù)組異步發(fā)送)

[復(fù)制鏈接]
ID:939250 發(fā)表于 2021-6-17 13:43 | 顯示全部樓層 |閱讀模式
//USART0
void Usart0Init(uint32_t baud)                  //PA10 RX  PA9 TX     //
{
        uint32_t Udiv = 0;
  RCU_APB2EN |= 0x00000001<<2;                //使能GPIOA時(shí)鐘
        RCU_APB2EN |= 0x00000001<<14;               //使能USART0時(shí)鐘
  GPIO_CTL1(GPIOA) &= 0xfffff0ff;            //設(shè)置RX引腳浮空輸入  PA10
        GPIO_CTL1(GPIOA) |= (0x00000004<<(4*2));
  GPIO_CTL1(GPIOA) &= 0xffffff0f;            //設(shè)置TX引腳復(fù)用推完輸出  50M     PA9
  GPIO_CTL1(GPIOA) |= (0x0000000B<<(4*1));   

        RCU_APB2RST  |=  (0x00000001 <<14);        //復(fù)位USART0
        RCU_APB2RST  &= ~(0x00000001 <<14);        //停止復(fù)位
        
        //計(jì)算波特率分頻比   udiv = UART0_CLK/(16*baud)  但寄存器中中小數(shù)點(diǎn)后面有四位,則需要擴(kuò)大16倍  則 =  UART0_CLK/baud
        //時(shí)鐘頻率為APB2(系統(tǒng)初始化時(shí)已設(shè)定APB2等于APB等于系統(tǒng)時(shí)鐘108M)
  Udiv = (APB2_CLK+baud/2)/baud;                  //參考庫(kù)函數(shù)比用戶手冊(cè)上大一些,是不是因?yàn)榻?jīng)驗(yàn)不穩(wěn)定而加大一點(diǎn)
        USART_BAUD(USART0) = (Udiv) & 0x0000ffff;       //分頻比 共16位  12位整數(shù)  4位小數(shù)

        USART_CTL0(USART0) &= ~(0x00000001 <<12);       //12位設(shè)置為0  表示8位數(shù)據(jù)位

        
        USART_CTL1(USART0) &= ~(0x00000003 <<12);        //12-13位設(shè)置為0   表示1位停止位
        USART_CTL0(USART0) &= ~(0x00000003 <<9);         //9-10位設(shè)置為0    表示無(wú)效驗(yàn)位
        
        USART_CTL2(USART0) &= ~(0x00000003 <<8);         //8-9位設(shè)置為0     表示禁用RTS CTS
        
        USART_CTL0(USART0) &= ~(0x00000003 <<2);       //第2位 設(shè)置為1  使能接收  3位設(shè)置為1  使能發(fā)送
        USART_CTL0(USART0) |=  (0x00000003 <<2);
        
        USART_CTL0(USART0) |=  (0x00000003 <<5);      //5位置1  接收緩沖器清空中斷   6位置1  發(fā)送完成中斷
        
        nvic_irq_enable(USART0_IRQn, 0, 0);           //設(shè)置中斷優(yōu)先級(jí)
        USART_CTL0(USART0) |=  (0x00000001 <<13);      //使能USART0
}

void USART0_IRQHandler(void)
{
        uint32_t tmp = 0;
        if(USART_STAT(USART0) &(0x00000001 <<6))          //發(fā)送完成
  {
                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))          //接收到數(shù)據(jù)
  {
                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時(shí)鐘
        RCU_APB1EN |= 0x00000001<<17;              //使能USART1時(shí)鐘
  GPIO_CTL0(GPIOA) &= 0xffff0fff;            //設(shè)置RX引腳浮空輸入  PA3
        GPIO_CTL0(GPIOA) |= (0x00000004<<(4*3));
  GPIO_CTL0(GPIOA) &= 0xfffff0ff;            //設(shè)置TX引腳復(fù)用推完輸出   50M     PA2
  GPIO_CTL0(GPIOA) |= (0x0000000B<<(4*2));   
  RCU_APB1RST  |=  (0x00000001 <<17);        //復(fù)位USART1
        RCU_APB1RST  &= ~(0x00000001 <<17);        //停止復(fù)位
        
        //計(jì)算波特率分頻比   udiv = UART0_CLK/(16*baud)  但寄存器中中小數(shù)點(diǎn)后面有四位,則需要擴(kuò)大16倍  則 =  UART0_CLK/baud
        //時(shí)鐘頻率為APB1(系統(tǒng)初始化時(shí)已設(shè)定APB2等于APB/2等于系統(tǒng)時(shí)鐘108M/2)
  Udiv = (APB1_CLK+baud/2)/baud;                  //參考庫(kù)函數(shù)比用戶手冊(cè)上大一些,是不是因?yàn)榻?jīng)驗(yàn)不穩(wěn)定而加大一點(diǎn)
        USART_BAUD(USART1) = (Udiv) & 0x0000ffff;       //分頻比 共16位  12位整數(shù)  4位小數(shù)

        USART_CTL0(USART1) &= ~(0x00000001 <<12);       //12位設(shè)置為0  表示8位數(shù)據(jù)位

        
        USART_CTL1(USART1) &= ~(0x00000003 <<12);        //12-13位設(shè)置為0   表示1位停止位
        USART_CTL0(USART1) &= ~(0x00000003 <<9);         //9-10位設(shè)置為0    表示無(wú)效驗(yàn)位
        
        USART_CTL2(USART1) &= ~(0x00000003 <<8);         //8-9位設(shè)置為0     表示禁用RTS CTS
        
        USART_CTL0(USART1) &= ~(0x00000003 <<2);       //第2位 設(shè)置為1  使能接收  3位設(shè)置為1  使能發(fā)送
        USART_CTL0(USART1) |=  (0x00000003 <<2);
        
        USART_CTL0(USART1) |=  (0x00000003 <<5);      //5位置1  接收緩沖器清空中斷   6位置1  發(fā)送完成中斷
        
        nvic_irq_enable(USART1_IRQn, 0, 0);           //設(shè)置中斷優(yōu)先級(jí)
        USART_CTL0(USART1) |=  (0x00000001 <<13);      //使能USART0
}

void USART1_IRQHandler(void)
{
        uint32_t tmp = 0;
        if(USART_STAT(USART1) &(0x00000001 <<6))          //發(fā)送完成
  {
                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))          //接收到數(shù)據(jù)
  {
                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時(shí)鐘
        RCU_APB1EN |= 0x00000001<<18;               //使能USART2時(shí)鐘
  GPIO_CTL1(GPIOB) &= 0xffff0fff;            //設(shè)置RX引腳浮空輸入  PA10
        GPIO_CTL1(GPIOB) |= (0x00000004<<(4*3));
  GPIO_CTL1(GPIOB) &= 0xfffff0ff;            //設(shè)置TX引腳復(fù)用推完輸出  50M     PB10
  GPIO_CTL1(GPIOB) |= (0x0000000B<<(4*2));   

        RCU_APB1RST  |=  (0x00000001 <<18);        //復(fù)位USART2
        RCU_APB1RST  &= ~(0x00000001 <<18);        //停止復(fù)位
        
        //計(jì)算波特率分頻比   udiv = UART0_CLK/(16*baud)  但寄存器中中小數(shù)點(diǎn)后面有四位,則需要擴(kuò)大16倍  則 =  UART0_CLK/baud
        //時(shí)鐘頻率為APB1(系統(tǒng)初始化時(shí)已設(shè)定APB2等于APB/2等于系統(tǒng)時(shí)鐘108M/2)
  Udiv = (APB1_CLK+baud/2)/baud;                  //參考庫(kù)函數(shù)比用戶手冊(cè)上大一些,是不是因?yàn)榻?jīng)驗(yàn)不穩(wěn)定而加大一點(diǎn)
        USART_BAUD(USART2) = (Udiv) & 0x0000ffff;       //分頻比 共16位  12位整數(shù)  4位小數(shù)

        USART_CTL0(USART2) &= ~(0x00000001 <<12);       //12位設(shè)置為0  表示8位數(shù)據(jù)位

        
        USART_CTL1(USART2) &= ~(0x00000003 <<12);        //12-13位設(shè)置為0   表示1位停止位
        USART_CTL0(USART2) &= ~(0x00000003 <<9);         //9-10位設(shè)置為0    表示無(wú)效驗(yàn)位
        
        USART_CTL2(USART2) &= ~(0x00000003 <<8);         //8-9位設(shè)置為0     表示禁用RTS CTS
        
        USART_CTL0(USART2) &= ~(0x00000003 <<2);       //第2位 設(shè)置為1  使能接收  3位設(shè)置為1  使能發(fā)送
        USART_CTL0(USART2) |=  (0x00000003 <<2);
        
        USART_CTL0(USART2) |=  (0x00000003 <<5);      //5位置1  接收緩沖器清空中斷   6位置1  發(fā)送完成中斷
        
        nvic_irq_enable(USART2_IRQn, 0, 0);           //設(shè)置中斷優(yōu)先級(jí)
        USART_CTL0(USART2) |=  (0x00000001 <<13);      //使能USART0
}

void USART2_IRQHandler(void)
{
        uint32_t tmp = 0;
        if(USART_STAT(USART2) &(0x00000001 <<6))          //發(fā)送完成
  {
                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))          //接收到數(shù)據(jù)
  {
                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時(shí)鐘
        RCU_APB1EN |= 0x00000001<<19;               //使能USART2時(shí)鐘
  GPIO_CTL1(GPIOC) &= 0xffff0fff;            //設(shè)置RX引腳浮空輸入  PC11
        GPIO_CTL1(GPIOC) |= (0x00000004<<(4*3));
  GPIO_CTL1(GPIOC) &= 0xfffff0ff;            //設(shè)置TX引腳復(fù)用推完輸出  50M     PC10
  GPIO_CTL1(GPIOC) |= (0x0000000B<<(4*2));   

        RCU_APB1RST  |=  (0x00000001 <<19);        //復(fù)位USART2
        RCU_APB1RST  &= ~(0x00000001 <<19);        //停止復(fù)位
        
        //計(jì)算波特率分頻比   udiv = UART0_CLK/(16*baud)  但寄存器中中小數(shù)點(diǎn)后面有四位,則需要擴(kuò)大16倍  則 =  UART0_CLK/baud
        //時(shí)鐘頻率為APB1(系統(tǒng)初始化時(shí)已設(shè)定APB2等于APB/2等于系統(tǒng)時(shí)鐘108M/2)
  Udiv = (APB1_CLK+baud/2)/baud;                  //參考庫(kù)函數(shù)比用戶手冊(cè)上大一些,是不是因?yàn)榻?jīng)驗(yàn)不穩(wěn)定而加大一點(diǎn)
        USART_BAUD(UART3) = (Udiv) & 0x0000ffff;       //分頻比 共16位  12位整數(shù)  4位小數(shù)

        USART_CTL0(UART3) &= ~(0x00000001 <<12);       //12位設(shè)置為0  表示8位數(shù)據(jù)位
        
        USART_CTL1(UART3) &= ~(0x00000003 <<12);        //12-13位設(shè)置為0   表示1位停止位
        USART_CTL0(UART3) &= ~(0x00000003 <<9);         //9-10位設(shè)置為0    表示無(wú)效驗(yàn)位
        
        USART_CTL2(UART3) &= ~(0x00000003 <<8);         //8-9位設(shè)置為0     表示禁用RTS CTS
        
        USART_CTL0(UART3) &= ~(0x00000003 <<2);       //第2位 設(shè)置為1  使能接收  3位設(shè)置為1  使能發(fā)送
        USART_CTL0(UART3) |=  (0x00000003 <<2);
        
        USART_CTL0(UART3) |=  (0x00000003 <<5);      //5位置1  接收緩沖器清空中斷   6位置1  發(fā)送完成中斷
        
        nvic_irq_enable(UART3_IRQn, 0, 1);           //設(shè)置中斷優(yōu)先級(jí)
        USART_CTL0(UART3) |=  (0x00000001 <<13);      //使能USART0
}

void UART3_IRQHandler(void)
{
        uint32_t tmp = 0;
        if(USART_STAT(UART3) &(0x00000001 <<6))          //發(fā)送完成
  {
                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))          //接收到數(shù)據(jù)
  {
                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時(shí)鐘
  RCU_APB2EN |= 0x00000001<<4;                //使能GPIOC時(shí)鐘
        RCU_APB1EN |= 0x00000001<<20;               //使能USART2時(shí)鐘
  GPIO_CTL0(GPIOD) &= 0xffffF0ff;            //設(shè)置RX引腳浮空輸入  PD2
        GPIO_CTL0(GPIOD) |= (0x00000004<<(4*2));
  GPIO_CTL1(GPIOC) &= 0xfff0ffff;            //設(shè)置TX引腳復(fù)用推完輸出  50M     PC12
  GPIO_CTL1(GPIOC) |= (0x0000000B<<(4*4));   

        RCU_APB1RST  |=  (0x00000001 <<20);        //復(fù)位USART2
        RCU_APB1RST  &= ~(0x00000001 <<20);        //停止復(fù)位
        
        //計(jì)算波特率分頻比   udiv = UART0_CLK/(16*baud)  但寄存器中中小數(shù)點(diǎn)后面有四位,則需要擴(kuò)大16倍  則 =  UART0_CLK/baud
        //時(shí)鐘頻率為APB1(系統(tǒng)初始化時(shí)已設(shè)定APB2等于APB/2等于系統(tǒng)時(shí)鐘108M/2)
  Udiv = (APB1_CLK+baud/2)/baud;                  //參考庫(kù)函數(shù)比用戶手冊(cè)上大一些,是不是因?yàn)榻?jīng)驗(yàn)不穩(wěn)定而加大一點(diǎn)
        USART_BAUD(UART4) = (Udiv) & 0x0000ffff;       //分頻比 共16位  12位整數(shù)  4位小數(shù)

        USART_CTL0(UART4) &= ~(0x00000001 <<12);       //12位設(shè)置為1  表示8位數(shù)據(jù)位

        
        USART_CTL1(UART4) &= ~(0x00000003 <<12);        //12-13位設(shè)置為0   表示1位停止位
        USART_CTL0(UART4) &= ~(0x00000003 <<9);         //9-10位設(shè)置為0    表示無(wú)效驗(yàn)位
        
        USART_CTL2(UART4) &= ~(0x00000003 <<8);         //8-9位設(shè)置為0     表示禁用RTS CTS
        
        USART_CTL0(UART4) &= ~(0x00000003 <<2);       //第2位 設(shè)置為1  使能接收  3位設(shè)置為1  使能發(fā)送
        USART_CTL0(UART4) |=  (0x00000003 <<2);
        
        USART_CTL0(UART4) |=  (0x00000003 <<5);      //5位置1  接收緩沖器清空中斷   6位置1  發(fā)送完成中斷
        
        nvic_irq_enable(UART4_IRQn, 1, 1);           //設(shè)置中斷優(yōu)先級(jí)
        USART_CTL0(UART4) |=  (0x00000001 <<13);      //使能USART0
}

void UART4_IRQHandler(void)
{
        uint32_t tmp = 0;
        if(USART_STAT(UART4) &(0x00000001 <<6))          //發(fā)送完成
  {
                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))          //接收到數(shù)據(jù)
  {
                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;
}

評(píng)分

參與人數(shù) 1黑幣 +50 收起 理由
admin + 50 共享資料的黑幣獎(jiǎng)勵(lì)!

查看全部評(píng)分

回復(fù)

使用道具 舉報(bào)

ID:939250 發(fā)表于 2021-6-17 13:45 | 顯示全部樓層
接受和發(fā)送使用循環(huán)數(shù)據(jù)組緩沖區(qū)異步發(fā)送
回復(fù)

使用道具 舉報(bào)

本版積分規(guī)則

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術(shù)交流QQ群281945664

Powered by 單片機(jī)教程網(wǎng)

快速回復(fù) 返回頂部 返回列表