21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › IO软件模拟串口
返回列表 发新帖我要提问

[DemoCode下载] IO软件模拟串口

[复制链接]
677|4
 楼主| antusheng 发表于 2020-3-26 20:39 | 显示全部楼层 |阅读模式
软件, 模拟串口, IO, AC
EC_M051_SoftwareUART_V1.00.zip (2.58 MB, 下载次数: 17)


回复

收藏 举报

相关帖子
 楼主| antusheng 发表于 2020-3-26 20:49 | 显示全部楼层
复制
  1. /**************************************************************************//**
    

  2.  * [url=home.php?mod=space&uid=288409]@file[/url]     SoftwareUARRT.c
    

  3.  * [url=home.php?mod=space&uid=895143]@version[/url]  V1.00
    

  4.  * [url=home.php?mod=space&uid=247401]@brief[/url]    M051 Using GPIO emulation UART driver source file
    

  5.  *
    

  6.  * @note
    

  7.  * Copyright (C) 2019 Nuvoton Technology Corp. All rights reserved.
    

  8.  ******************************************************************************/
    

  9. #include "SoftwareUART.h"
    


  10. 

  11. /*---------------------------------------------------------------------------------------------------------*/
    

  12. /* Global variables                                                                                        */
    

  13. /*---------------------------------------------------------------------------------------------------------*/
    

  14. sUART_Config  g_sSoftwareUART_Config;
    

  15. sUART_Config *g_psSoftwareUART_Config;
    

  16. uint16_t g_au16TxBuff[256];
    

  17. uint16_t g_au16RxBuff[256];
    


  18. 

  19. /*---------------------------------------------------------------------------------------------------------*/
    

  20. /* Init SoftwareUART                                                                                       */
    

  21. /*---------------------------------------------------------------------------------------------------------*/
    

  22. void SoftwareUART_Init(sUART_Config *psConfig)
    

  23. {
    

  24.     /* Configure P2.6 as Input mode(Rx) */
    

  25.     GPIO_SetMode(P2, BIT6, GPIO_PMD_INPUT);
    

  26.     /* Configure P2.7 as Output mode(Tx) */
    

  27.     GPIO_SetMode(P2, BIT7, GPIO_PMD_OUTPUT);
    

  28.     /* Initial the SoftwareUART configuration setting */
    

  29.     SoftwareUART_ConfigInit(psConfig);
    

  30.         
    

  31.     /* Configure SoftwareUART and set SoftwareUART baudrate */
    

  32.     SoftwareUART_Open(psConfig,115200);
    

  33.         
    

  34. }
    


  35. 

  36. /*---------------------------------------------------------------------------------------------------------*/
    

  37. /* Init SoftwareUART configuration                                                                         */
    

  38. /*---------------------------------------------------------------------------------------------------------*/
    

  39. void SoftwareUART_ConfigInit(sUART_Config *psConfig)
    

  40. {
    

  41.   
    

  42.         g_psSoftwareUART_Config = psConfig; 
    

  43.         psConfig->u32BaudRate = 0;
    

  44.         psConfig->u8DataBits = 0;
    

  45.         psConfig->u8Parity = 0;
    

  46.         psConfig->u8StopBit = 0;
    

  47.         psConfig->u8RxStatus = eRxIdel;
    

  48.         psConfig->u8TxStatus = eTxIdel;
    

  49.         psConfig->u8CommunBitsLen = 0;
    

  50.         psConfig->pu16TxBuff = &g_au16TxBuff[0];
    

  51.         psConfig->pu16RxBuff = &g_au16RxBuff[0];
    

  52.         psConfig->u32SendLen = 0;
    

  53.         psConfig->u32ReceiveLen = 0;
    


  54. 

  55. }
    


  56. 

  57. /*---------------------------------------------------------------------------------------------------------*/
    

  58. /* Init SoftwareUART interface                                                                             */
    

  59. /*---------------------------------------------------------------------------------------------------------*/
    

  60. void SoftwareUART_Open(sUART_Config *psConfig,uint32_t u32BaudRate)
    

  61. {
    

  62.           uint32_t u32TimePeriodic; 
    

  63.         
    

  64.           psConfig->u32BaudRate = u32BaudRate;
    

  65.         
    

  66.           /* Setting the UART Rx bit rate */
    

  67.           u32TimePeriodic = psConfig->u32BaudRate*2; 
    

  68.           /* Open Timer0 frequency in periodic mode, and enable interrupt */
    

  69.           TIMER_Open(TIMER0,TIMER_PERIODIC_MODE,u32TimePeriodic);
    

  70.           /* Enable Timer0 INT */
    

  71.           TIMER_EnableInt(TIMER0);
    


  72. 

  73.           /* Setting the UART Tx bit rate */
    

  74.           u32TimePeriodic  =  psConfig->u32BaudRate;  
    

  75.           /* Open Timer0 frequency in periodic mode, and enable interrupt */
    

  76.           TIMER_Open(TIMER1,TIMER_PERIODIC_MODE,u32TimePeriodic);
    

  77.           /* Enable Timer0 INT */
    

  78.           TIMER_EnableInt(TIMER1);
    

  79.  
    

  80.           SoftwareUART_DataFormartConfig(psConfig);
    

  81.         
    

  82. }        
    


  83. 

  84. /*---------------------------------------------------------------------------------------------------------*/
    

  85. /* SoftwareUART data format setting                                                                        */
    

  86. /*---------------------------------------------------------------------------------------------------------*/
    

  87. void SoftwareUART_DataFormartConfig(sUART_Config *psConfig)
    

  88. {
    

  89.         
    

  90.         psConfig->u8DataBits = 8;                /* Setting data length is 8 bits */
    

  91.         psConfig->u8Parity = PARITY_NONE;        /* No Parity */
    

  92.         psConfig->u8StopBit = STOP_BIT_1;        /* 1 Stop bit */ 
    

  93.         psConfig->u8TxLatency = 2;               /* Transmission interval is 2 bits rate */
    

  94.         psConfig->u32SendLen = 16;               /* Send 16 bytes(Tx) */
    

  95.         psConfig->u32ReceiveLen = 16;            /* Receive 16 bytes(Rx) */
    

  96.         /*Building UART Tx serial number*/
    

  97.         BuildTxDataPattern(psConfig);
    

  98.         /* Configure the parity bit */
    

  99.         SoftwareUART_ParityBitConfig(psConfig); 
    

  100.         /* Configure the stop bit */
    

  101.         SoftwareUART_StopBitConfig(psConfig);
    

  102.  
    

  103.         psConfig->u8CommunBitsLen = psConfig->u8DataBits;
    


  104. 

  105.   if(psConfig->u8Parity != PARITY_NONE)
    

  106.     psConfig->u8CommunBitsLen += 1;     /* Parity bit */
    

  107.   if(psConfig->u8StopBit != STOP_BIT_1)  
    

  108.     psConfig->u8CommunBitsLen += 3;    /* Start bit + 2 Stop bits */
    

  109.   else
    

  110.     psConfig->u8CommunBitsLen += 2;    /* Start bit + 1 Stop bit*/
    

  111.  
    

  112. }
    

  113. /*---------------------------------------------------------------------------------------------------------*/
    

  114. /* SoftwareUART Tx Send Data                                                                               */
    

  115. /*---------------------------------------------------------------------------------------------------------*/
    

  116. void SoftwareUART_SendData(sUART_Config *psConfig) 
    

  117. {
    

  118.    uint32_t u32Index; 
    

  119.          uint32_t u16SendData;
    

  120.    /* Enable Timer1 NVIC */
    

  121.    NVIC_EnableIRQ(TMR1_IRQn);
    

  122.    /* Start Timer1 counting */
    

  123.    TIMER_Start(TIMER1);
    


  124. 

  125.          psConfig->u8TxStatus = eTxIdel;
    

  126.          psConfig->u8TxTiming =0;
    

  127.    for(u32Index=0 ;u32Index < psConfig->u32SendLen ;u32Index++)
    

  128.    {
    

  129.                 GPIO_UART_TX = 1;
    

  130.                 u16SendData = psConfig->pu16TxBuff[u32Index];
    

  131.                 while( psConfig->u8TxStatus != eTxActive){};
    

  132.                 psConfig->u8TxStatus = eTxSendData;
    

  133.           
    

  134.                 /* Use TIMER1 to emulate the bit rate of UART transmission */
    

  135.                 do{        
    

  136.         psConfig->u8TxTiming =0;
    


  137. 

  138.         if((u16SendData & 0x01) == 0x01)
    

  139.            GPIO_UART_TX =1;
    

  140.         else
    

  141.            GPIO_UART_TX =0;
    

  142.         u16SendData = u16SendData >> 1;
    

  143.         while(psConfig->u8TxTiming == 0){};
    

  144.        /* Total bits Length(start bit(1) + data bits(5~8) + parity bit(0~1)+ stop bit(1~2)) */
    

  145.       }while(psConfig->u8TxSendCount <  (psConfig->u8CommunBitsLen+ psConfig->u8TxLatency ));
    

  146.                 
    

  147.                  psConfig->u8TxStatus = eTxIdel;
    

  148.                  psConfig->u8TxSendCount =0;
    

  149.          
    

  150.          }                
    

  151.                         
    

  152.          /* Disable Timer1 NVIC */
    

  153.           NVIC_DisableIRQ(TMR1_IRQn);
    

  154.           /* Stop Timer1 counting */
    

  155.           TIMER_Stop(TIMER1); 
    

  156. }        
    

  157. /*---------------------------------------------------------------------------------------------------------*/
    

  158. /* SoftwareUART Rx Receive Data                                                                            */
    

  159. /*---------------------------------------------------------------------------------------------------------*/
    

  160. void SoftwareUART_ReadData(sUART_Config *psConfig) 
    

  161. {
    

  162.     uint32_t u32Index;
    

  163.     uint8_t u8RxCount;
    

  164.     /* Enable Timer0 NVIC */
    

  165.     NVIC_EnableIRQ(TMR0_IRQn);
    

  166.     /* Start Timer0 counting */
    

  167.     TIMER_Start(TIMER0);
    


  168. 

  169.     for(u32Index=0 ;u32Index < psConfig->u32ReceiveLen ;u32Index++)
    

  170.     {
    

  171.       u8RxCount = 0;
    

  172.       /* Use TIMER0 to emulate the bit rate of UART reception  */
    

  173.       psConfig->u8RxTiming =0;
    


  174. 

  175.       /* Wait to Receive the start bit */
    

  176.       while(GPIO_UART_RX == 1){};
    

  177.       psConfig->u8RxStatus = eRxRcvData;                                  
    

  178.         do{
    


  179. 

  180.       while(psConfig->u8RxTiming == 0){};
    

  181.       if(GPIO_UART_RX == 0)
    

  182.         psConfig->pu16RxBuff[u32Index] |= (0 << u8RxCount);
    

  183.       else
    

  184.         psConfig->pu16RxBuff[u32Index] |= (1 << u8RxCount);
    

  185.       psConfig->u8RxTiming =0;
    

  186.       while(psConfig->u8RxTiming == 0){};
    

  187.       psConfig->u8RxTiming =0;
    

  188.       u8RxCount++;
    

  189.       /* Total bits length(start bit(1) + data bits(5~8) + parity bit(0-1)+ stop bit(1~2)) */
    

  190.      }while(u8RxCount < psConfig->u8CommunBitsLen);
    

  191.      u8RxCount =0;
    

  192.                  /* End of reception */
    

  193.      psConfig->u8RxStatus = eRxIdel;
    

  194.      psConfig->u8RxTiming =0;
    


  195. 

  196.           }
    


  197. 

  198.      /* Disable Timer0 NVIC */
    

  199.      NVIC_DisableIRQ(TMR0_IRQn);
    

  200.      /* Stop Timer0 counting */
    

  201.      TIMER_Stop(TIMER0); 
    

  202.           
    

  203.          
    

  204.          for(u32Index=0 ;u32Index < psConfig->u32ReceiveLen ;u32Index++)
    

  205.          { 
    

  206.          SoftwareUART_ReceiveDateParse(psConfig,u32Index);
    

  207.          psConfig->pu16RxBuff[u32Index] = 0; 
    

  208.          } 
    

  209.          
    

  210. }        
    


  211. 

  212. /*---------------------------------------------------------------------------------------------------------*/
    

  213. /* Parse reduction receive data                                                                            */
    

  214. /*---------------------------------------------------------------------------------------------------------*/
    

  215. void SoftwareUART_ReceiveDateParse(sUART_Config *psConfig,uint32_t u32Index)
    

  216. {
    

  217.    uint8_t u8ParityCheck;
    

  218.          uint8_t u8TempData;
    

  219.          uint8_t u8DataMask;
    

  220.          uint8_t u8ParityBit;
    

  221.          uint8_t u8StopBit;
    


  222. 

  223.     /*Get the Parity bits number*/
    

  224.     u8DataMask = GetDataMsk(psConfig);
    


  225. 

  226.     /*Check start bit*/
    

  227.     if((psConfig->pu16RxBuff[u32Index] & 0x01) !=0)
    

  228.     {
    

  229.        printf("Start Bit Error\n");
    

  230.     }
    

  231.                  /*Remove start bit */
    

  232.     u8TempData = ((psConfig->pu16RxBuff[u32Index]>>1) & u8DataMask);
    


  233. 

  234.     if(psConfig->u8Parity != PARITY_NONE)
    

  235.     {
    

  236.       /*Get the parity number */
    

  237.       u8ParityCheck = GetParityBitsNumber(psConfig,u8TempData);
    

  238.       /*Get Parity bit*/
    

  239.       u8ParityBit = ((psConfig->pu16RxBuff[u32Index] >> (psConfig->u8DataBits+1)) &0x1);
    

  240.     }                
    

  241.     /*Check EVEN or ODD Parity bit*/
    

  242.     if( (psConfig->u8Parity == PARITY_EVEN ) || (psConfig->u8Parity == PARITY_ODD ) )
    

  243.           {
    

  244.        if(psConfig->u8Parity == PARITY_ODD)
    

  245.        {
    

  246.           if((u8ParityCheck % 2) == 0)
    

  247.           {
    

  248.             if(u8ParityBit != 1) printf("ODD Error\n");
    

  249.           }
    

  250.           else
    

  251.           {
    

  252.             if(u8ParityBit == 1)  printf("ODD Error\n");
    

  253.           }
    

  254.        }
    

  255.        else
    

  256.        {
    

  257.          if((u8ParityCheck % 2) == 0)
    

  258.          {
    

  259.             if(u8ParityBit != 0) printf("Even Error\n");
    

  260.          }
    

  261.          else
    

  262.          {
    

  263.             if(u8ParityBit != 1) printf("Even Error\n");
    

  264.          }
    

  265.        }
    

  266.    
    

  267.    }/*Check MARK Parity bit*/
    

  268.    else if(psConfig->u8Parity == PARITY_MARK)
    

  269.    {
    

  270.       if(u8ParityBit != 1) printf("MARK Error\n");
    

  271.    }/*Check Space Parity bit*/
    

  272.    else if(psConfig->u8Parity == PARITY_SPACE)
    

  273.    {
    

  274.       if(u8ParityBit != 0) printf("SPACE Error\n");
    

  275.    }
    


  276. 

  277.     /*Check Stop bit*/
    

  278.      if(psConfig->u8Parity == PARITY_NONE)
    

  279.         u8StopBit = (psConfig->pu16TxBuff[u32Index] >> (psConfig->u8DataBits + 1));
    

  280.      else
    

  281.         u8StopBit = (psConfig->pu16TxBuff[u32Index] >> (psConfig->u8DataBits + 2));
    


  282. 

  283.     if(psConfig->u8StopBit == STOP_BIT_1 )
    

  284.     {
    

  285.       if(u8StopBit != 1)printf("STOP bit Error\n");
    

  286.     }
    

  287.     else
    

  288.     {
    

  289.       if(u8StopBit != 3)printf("STOP bits Error\n");
    

  290.     }
    

  291.     
    

  292.     psConfig->pu16RxBuff[u32Index] = u8TempData;
    

  293.     printf("Rx Data[%d] =0x%x\n",u32Index,psConfig->pu16RxBuff[u32Index]) ;                 
    

  294.                          
    

  295. }        
    


  296. 


  297. 

  298. uint8_t GetDataMsk(sUART_Config *psConfig)
    

  299. {
    

  300.    uint8_t u8DataMask;
    

  301.         
    

  302.         if(psConfig->u8DataBits == 8) u8DataMask = 0xFF;            /* 8 bits (0x0~0xFF) */ 
    

  303.         else if(psConfig->u8DataBits == 7) u8DataMask = 0x7F;       /* 7 bits (0x0~0x7F) */
    

  304.         else if(psConfig->u8DataBits == 6) u8DataMask = 0x3F;       /* 6 bits (0x0~0x3F) */
    

  305.         else u8DataMask = 0x1F;                                     /* 5 bits (0x0~0x1F) */ 
    


  306. 

  307.         return u8DataMask;
    

  308. }
    


  309. 


  310. 

  311. uint8_t GetParityBitsNumber(sUART_Config *psConfig,uint8_t u8Data)
    

  312. { 
    

  313.     uint8_t u8Index,u8ParityCheck;
    

  314.           u8ParityCheck =0; 
    

  315.     for(u8Index = 0;u8Index < psConfig->u8DataBits ; u8Index++)        
    

  316.     {
    

  317.        if((u8Data & (1 << u8Index)) != 0)
    

  318.            u8ParityCheck++;
    

  319.     }
    


  320. 

  321.         return u8ParityCheck;         
    

  322.                 
    

  323. }        
    


  324. 


  325. 

  326. void BuildTxDataPattern(sUART_Config *psConfig)
    

  327. {
    

  328.   uint32_t u32Index;
    

  329.         uint8_t u8DataMask;
    


  330. 

  331.   u8DataMask = GetDataMsk(psConfig);
    

  332.   for(u32Index =0 ; u32Index  < psConfig->u32SendLen ;u32Index++)
    

  333.   {
    

  334.      psConfig->pu16TxBuff[u32Index] = (u32Index & u8DataMask);
    

  335.   }
    

  336. }
    

  337. /*---------------------------------------------------------------------------------------------------------*/
    

  338. /* SoftwareUART Stop bit configuration                                                                     */
    

  339. /*---------------------------------------------------------------------------------------------------------*/
    


  340. 

  341. void SoftwareUART_StopBitConfig(sUART_Config *psConfig)
    

  342. { 
    

  343.    uint32_t u32Index;
    

  344.    for(u32Index =0 ; u32Index < psConfig->u32SendLen ; u32Index++)
    

  345.    {
    

  346.      if(psConfig->u8StopBit == STOP_BIT_1 )
    

  347.      {        
    

  348.         /* No Parity bit,offset value(start bit + data bits) */
    

  349.         if(psConfig->u8Parity == PARITY_NONE)
    

  350.            psConfig->pu16TxBuff[u32Index] |= (0x01 << (psConfig->u8DataBits + 1));
    

  351.         else /* offset offset value(start bit + data bits + parity bit) */
    

  352.            psConfig->pu16TxBuff[u32Index] |= (0x01 << (psConfig->u8DataBits + 2));
    

  353.      }
    

  354.      else
    

  355.      {
    

  356.         /* No Parity bit,offset value(start bit + data bits) */
    

  357.         if(psConfig->u8Parity == PARITY_NONE)
    

  358.            psConfig->pu16TxBuff[u32Index] |= (0x03 << (psConfig->u8DataBits + 1));
    

  359.         else /* offset value (start bit + data bits + parity bit) */
    

  360.            psConfig->pu16TxBuff[u32Index] |= (0x03 << (psConfig->u8DataBits + 2));
    

  361.      }
    

  362.    }
    

  363.          
    

  364. }        
    


  365. 

  366. /*---------------------------------------------------------------------------------------------------------*/
    

  367. /* SoftwareUART Parity bit configuration                                                                   */
    

  368. /*---------------------------------------------------------------------------------------------------------*/
    

  369. void SoftwareUART_ParityBitConfig(sUART_Config *psConfig)
    

  370. {
    

  371.   uint8_t u8ParityCheck;
    

  372.          uint32_t u32DatIndex;
    


  373. 

  374.    for(u32DatIndex =0 ; u32DatIndex < psConfig->u32SendLen ; u32DatIndex++)
    

  375.    {
    

  376.      if((psConfig->u8Parity == PARITY_EVEN ) || (psConfig->u8Parity == PARITY_ODD ) )
    

  377.                  {
    

  378.       
    

  379.        u8ParityCheck = GetParityBitsNumber(psConfig,(uint8_t)psConfig->pu16TxBuff[u32DatIndex]);
    

  380.       
    

  381.        if(psConfig->u8Parity == PARITY_ODD)
    

  382.        {
    

  383.          if((u8ParityCheck % 2) == 0)
    

  384.              psConfig->pu16TxBuff[u32DatIndex] = (psConfig->pu16TxBuff[u32DatIndex]<< 1) | (0x01 << (psConfig->u8DataBits+1));
    

  385.          else
    

  386.              psConfig->pu16TxBuff[u32DatIndex] = (psConfig->pu16TxBuff[u32DatIndex]<< 1);
    

  387.        }
    

  388.        else
    

  389.        {
    

  390.          if((u8ParityCheck % 2) == 1)
    

  391.              psConfig->pu16TxBuff[u32DatIndex] = (psConfig->pu16TxBuff[u32DatIndex]<< 1)|(0x01 << (psConfig->u8DataBits+1));
    

  392.          else
    

  393.              psConfig->pu16TxBuff[u32DatIndex] = (psConfig->pu16TxBuff[u32DatIndex]<< 1);
    

  394.        }
    

  395.     }
    

  396.     else if(psConfig->u8Parity == PARITY_MARK)
    

  397.     {
    

  398.             psConfig->pu16TxBuff[u32DatIndex] = (psConfig->pu16TxBuff[u32DatIndex]<< 1)|(0x01 << (psConfig->u8DataBits+1));
    

  399.     }
    

  400.     else
    

  401.     {
    

  402.             psConfig->pu16TxBuff[u32DatIndex] = (psConfig->pu16TxBuff[u32DatIndex]<< 1);
    

  403.     }
    

  404.    
    

  405.         
    

  406.  } 
    


  407. 

  408. }
    


  409. 

  410. /**
    

  411.  * @brief       Timer0 IRQ
    

  412.  *
    

  413.  * @param       None
    

  414.  *
    

  415.  * [url=home.php?mod=space&uid=266161]@return[/url]      None
    

  416.  *
    

  417.  * [url=home.php?mod=space&uid=1543424]@Details[/url]     The Timer0 default IRQ, declared in startup_M051Series.s.
    

  418.  */
    

  419. void TMR0_IRQHandler(void)
    

  420. {
    

  421.     /* Clear Timer0 time-out interrupt flag */
    

  422.     TIMER_ClearIntFlag(TIMER0);
    

  423.     /* Receiving data */
    

  424.     if( g_psSoftwareUART_Config->u8RxStatus == eRxRcvData)
    

  425.         g_psSoftwareUART_Config->u8RxTiming = 1;
    

  426.   
    

  427.         
    

  428. }
    


  429. 

  430. /**
    

  431.  * @brief       Timer1 IRQ
    

  432.  *
    

  433.  * @param       None
    

  434.  *
    

  435.  * @return      None
    

  436.  *
    

  437.  * @details     The Timer1 default IRQ, declared in startup_M051Series.s.
    

  438.  */
    

  439. void TMR1_IRQHandler(void)
    

  440. {
    

  441.     /* Clear Timer1 time-out interrupt flag */
    

  442.      TIMER_ClearIntFlag(TIMER1);
    


  443. 

  444.      g_psSoftwareUART_Config->u8TxSendCount++;
    

  445.       /*Wait for the Tx transfer start bit to complete*/
    

  446.      if(g_psSoftwareUART_Config->u8TxStatus == eTxIdel)
    

  447.      {
    

  448.         if(g_psSoftwareUART_Config->u8TxSendCount == g_psSoftwareUART_Config->u8TxLatency)
    

  449.            g_psSoftwareUART_Config->u8TxStatus = eTxActive;
    

  450.      }/* Tx transfer timing */
    

  451.      else if(g_psSoftwareUART_Config->u8TxStatus == eTxSendData)
    

  452.                          g_psSoftwareUART_Config->u8TxTiming = 1;
    

  453.                  
    

  454. }
    


  455. 

  456. /*** (C) COPYRIGHT 2019 Nuvoton Technology Corp. ***/
    


  457.
回复

收藏 举报

 楼主| antusheng 发表于 2020-3-26 20:50 | 显示全部楼层
复制
  1. #ifndef __SOFTWAREUART_H__
    

  2. #define __SOFTWAREUART_H__
    


  3. 

  4. #include "stdio.h"
    

  5. #include "stdlib.h"
    

  6. #include "M051Series.h"
    

  7. #include "string.h"
    


  8. 

  9. /*---------------------------------------------------------------------------------------------------------*/
    

  10. /* Define                                                                                                  */
    

  11. /*---------------------------------------------------------------------------------------------------------*/
    


  12. 

  13. /* Set to use GPIO emulation UART transfer */
    

  14. #define GPIO_UART_TX       P27   
    

  15. #define GPIO_UART_RX       P26
    


  16. 

  17. /*Define the UART Parity mode*/
    

  18. #define PARITY_NONE        0
    

  19. #define PARITY_ODD         1
    

  20. #define PARITY_EVEN        2
    

  21. #define PARITY_MARK        3
    

  22. #define PARITY_SPACE       4
    


  23. 

  24. /*Define the UART STOP bit*/
    

  25. #define STOP_BIT_1         0
    

  26. #define STOP_BITS_2        1
    


  27. 


  28. 

  29. /*---------------------------------------------------------------------------------------------------------*/
    

  30. /* Global variables                                                                                        */
    

  31. /*---------------------------------------------------------------------------------------------------------*/
    


  32. 

  33. /*SoftwareUART Rx status enumeration*/
    

  34. typedef enum
    

  35. {
    

  36.  eRxIdel = 0, /*Wait receive start bit*/
    

  37.  eRxActive,   /*Receive start bit */
    

  38.  eRxRcvData,  /*Receiving data*/          
    

  39. }E_RX_STATUS;
    


  40. 

  41. /*SoftwareUART Tx status enumeration*/
    

  42. typedef enum
    

  43. {
    

  44.  eTxIdel = 0, /*Wait send start bit*/
    

  45.  eTxActive,   /*Send start bit*/
    

  46.  eTxSendData, /*Sending data*/         
    

  47. }E_TX_STATUS;
    


  48. 

  49. /*SoftwareUART communication struct*/
    

  50. typedef  struct _Config{
    

  51.  uint32_t u32BaudRate;      /* Setting the UART Bit Rate*/
    

  52.  uint8_t  u8DataBits;       /* UART Data bits Length(5-8 bits) */
    

  53.  uint8_t  u8Parity;         /* UART Parity(NONE,EVEN,ODD,SPACE,MARK)*/
    

  54.  uint8_t  u8StopBit;        /* 1 bit,2 bits */
    

  55.  uint8_t         u8CommunBitsLen;  /* for Software UART Tx/Rx Communication bits Length using */
    

  56.  uint8_t  u8TxSendCount;          /* Tx Send Data Timing Counter */
    

  57.  uint8_t  u8TxLatency;      /* Transmission interval*/
    

  58.  uint8_t  u8TxStatus;       /* UART Tx Status*/
    

  59.  uint8_t  u8TxTiming;              /* UART Tx Bit rate timing */
    

  60.  uint8_t  u8RxStatus;              /* UART Rx Status*/ 
    

  61.  uint8_t  u8RxTiming;              /* UART Rx Bit rate timing */
    

  62.  uint16_t *pu16TxBuff;      /* UART Tx Buffer pointer */
    

  63.  uint16_t *pu16RxBuff;      /* UART Rx Buffer pointer */
    

  64.  uint32_t        u32SendLen;       /* UART Tx transfer total length*/
    

  65.  uint32_t        u32ReceiveLen;          /* UART Tx receive total length*/ 
    

  66. }sUART_Config;
    


  67. 

  68. extern sUART_Config  g_sSoftwareUART_Config;
    

  69. extern sUART_Config *g_psSoftwareUART_Config;
    


  70. 

  71. /*---------------------------------------------------------------------------------------------------------*/
    

  72. /* SoftwareUART Function                                                                                   */
    

  73. /*---------------------------------------------------------------------------------------------------------*/
    

  74. void SoftwareUART_ParityBitConfig(sUART_Config *spConfig);
    

  75. void SoftwareUART_StopBitConfig(sUART_Config *spConfig);
    

  76. void SoftwareUART_DataFormartConfig(sUART_Config *psConfig);
    

  77. void BuildTxDataPattern(sUART_Config *psConfig);
    

  78. void SoftwareUART_ConfigInit(sUART_Config *psConfig);
    

  79. void SoftwareUART_Open(sUART_Config *psConfig,uint32_t u32BaudRate);
    

  80. void SoftwareUART_SendData(sUART_Config *psConfig) ;
    

  81. void SoftwareUART_ReadData(sUART_Config *psConfig) ;
    

  82. uint8_t GetParityBitsNumber(sUART_Config *psConfig,uint8_t u8Data);
    

  83. void SoftwareUART_ReceiveDateParse(sUART_Config *psConfig,uint32_t u32Index);
    

  84. uint8_t GetDataMsk(sUART_Config *psConfig);
    


  85. 

  86. extern void SoftwareUART_Init(sUART_Config *psConfig);
    

  87. extern void UART_TX_TestFunctoion(sUART_Config *psConfig);
    

  88. extern void UART_RX_TestFunctoion(sUART_Config *psConfig);
    

  89. extern void SoftwareUART_SendData(sUART_Config *psConfig) ;
    

  90. extern void SoftwareUART_ReadData(sUART_Config *psConfig) ;
    


  91. 


  92. 

  93. #endif  /* __SOFTWAREUART_H__*/
回复

收藏 举报

 楼主| antusheng 发表于 2020-3-26 20:58 | 显示全部楼层
复制
  1. /**************************************************************************//**
    

  2.  * @file     main.c
    

  3.  * @version  V1.00
    

  4.  * @brief    M051 Simulate UART transfers using GPIO Sample Code
    

  5.  *
    

  6.  * @note
    

  7.  * Copyright (C) 2019 Nuvoton Technology Corp. All rights reserved.
    

  8.  ******************************************************************************/
    

  9. #include <stdio.h>
    

  10. #include "M051Series.h"
    

  11. #include "SoftwareUART.h"
    


  12. 

  13. #define PLLCON_SETTING      CLK_PLLCON_50MHz_HXT
    

  14. #define PLL_CLOCK           50000000
    


  15. 


  16. 

  17. void SYS_Init(void)
    

  18. {
    

  19.     /*---------------------------------------------------------------------------------------------------------*/
    

  20.     /* Init System Clock                                                                                       */
    

  21.     /*---------------------------------------------------------------------------------------------------------*/
    

  22.     
    

  23.           /* Enable IRC22M clock */
    

  24.     CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);
    

  25.         
    

  26.     /* Waiting for IRC22M clock ready */
    

  27.     CLK_WaitClockReady(CLK_CLKSTATUS_IRC22M_STB_Msk);
    


  28. 

  29.     /* Enable external 12MHz XTAL clock ready */
    

  30.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);
    


  31. 

  32.     /* Waiting for 12MHz XTAL clock ready */
    

  33.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);
    


  34. 

  35.     /* Enable external IRC10K */
    

  36.     CLK_EnableXtalRC(CLK_PWRCON_OSC10K_EN_Msk);
    

  37.     
    

  38.     /* Waiting for IRC10K clock ready */
    

  39.     CLK_WaitClockReady(CLK_CLKSTATUS_OSC10K_STB_Msk); 
    

  40.                 
    

  41.     /* Set core clock as PLL_CLOCK from PLL */
    

  42.     CLK_SetCoreClock(PLL_CLOCK);
    


  43. 

  44.     /* Switch HCLK clock source to HIRC */
    

  45.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_PLL, CLK_CLKDIV_HCLK(1));
    


  46. 

  47.     /* Enable peripheral clock */
    

  48.     /* Enable UART0 module clock */ 
    

  49.     CLK_EnableModuleClock(UART0_MODULE);
    

  50.     /* Enable TIMER0 module clock */ 
    

  51.     CLK_EnableModuleClock(TMR0_MODULE);
    

  52.     /* Enable TIMER1 module clock */
    

  53.     CLK_EnableModuleClock(TMR1_MODULE); 
    

  54.                 
    

  55.     /* Peripheral clock source */
    

  56.         
    

  57.     /* Select UART module clock source */
    

  58.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));
    

  59.     /* Select TMR0 module clock source */
    

  60.     CLK_SetModuleClock(TMR0_MODULE, CLK_CLKSEL1_TMR0_S_HXT,0);
    

  61.     /* Select TMR1 module clock source */
    

  62.     CLK_SetModuleClock(TMR1_MODULE, CLK_CLKSEL1_TMR1_S_HXT,0);
    


  63. 

  64.     /* Update System Core Clock */
    

  65.     /* User can use SystemCoreClockUpdate() to calculate PllClock, SystemCoreClock and CycylesPerUs automatically. */
    

  66.     SystemCoreClockUpdate();
    


  67. 

  68.     /*---------------------------------------------------------------------------------------------------------*/
    

  69.     /* Init I/O Multi-function                                                                                 */
    

  70.     /*---------------------------------------------------------------------------------------------------------*/
    

  71.     /* Set P3 multi-function pins for UART0 RXD, TXD */
    

  72.     SYS->P3_MFP = SYS_MFP_P30_RXD0 | SYS_MFP_P31_TXD0;
    

  73. }
    


  74. 

  75. void SoftwareUART_TestItem(void)
    

  76. {
    


  77. 

  78.     printf("+--------------------------------------------------------+\n");
    

  79.     printf("|           M051 SoftwareUART Transmission               |\n");
    

  80.     printf("+--------------------------------------------------------+\n");
    

  81.     printf("| [1] Software UART TX                                   |\n");
    

  82.     printf("| [2] Software UART RX                                   |\n");
    

  83.     printf("+--------------------------------------------------------+\n");
    

  84.     printf("Please Enter any Key to Start: "); 
    

  85. }        
    

  86. /*---------------------------------------------------------------------------------------------------------*/
    

  87. /* UART0 Init Function                                                                                     */
    

  88. /*---------------------------------------------------------------------------------------------------------*/
    

  89. void UART0_Init(void)
    

  90. {
    

  91.     /* Reset IP */
    

  92.     SYS_ResetModule(UART0_RST);
    


  93. 

  94.     /* Configure UART0 and set UART0 Baudrate */
    

  95.     UART_Open(UART0, 115200);
    

  96. }
    

  97. /*---------------------------------------------------------------------------------------------------------*/
    

  98. /* Simulate UART Tx transfers using GPIO                                                                   */
    

  99. /*---------------------------------------------------------------------------------------------------------*/
    

  100. void UART_TX_TestFunctoion(sUART_Config *psConfig)
    

  101. {
    

  102.    printf("Transfer %d-byte serial number\n",psConfig->u32SendLen);
    

  103.    SoftwareUART_SendData(psConfig);
    

  104. }        
    


  105. 

  106. /*---------------------------------------------------------------------------------------------------------*/
    

  107. /*  Receive data using GPIO emulation UART Rx                                                              */
    

  108. /*---------------------------------------------------------------------------------------------------------*/
    

  109. void UART_RX_TestFunctoion(sUART_Config *psConfig)
    

  110. {        
    

  111.    printf("Waiting to receive %d-byte\n",psConfig->u32ReceiveLen);
    

  112.    SoftwareUART_ReadData(psConfig);
    

  113. }        
    


  114. 


  115. 

  116. /*---------------------------------------------------------------------------------------------------------*/
    

  117. /*  MAIN function                                                                                          */
    

  118. /*---------------------------------------------------------------------------------------------------------*/
    

  119. int main(void)
    

  120. {
    

  121.     uint8_t u8TestItem;
    

  122.     /* Unlock protected registers */
    

  123.     SYS_UnlockReg();
    


  124. 

  125.     /* Init System, peripheral clock and multi-function I/O */
    

  126.     SYS_Init();
    


  127. 

  128.     /* Lock protected registers */
    

  129.     SYS_LockReg();
    

  130.     
    

  131.     /* Init UART0 for printf */
    

  132.     UART0_Init();
    

  133.           /* Init SoftwareUART  */
    

  134.     SoftwareUART_Init(&g_sSoftwareUART_Config);
    

  135.     printf("\nSystem Clock = %d Hz\n",SystemCoreClock);
    

  136.     
    

  137.    while(1)
    

  138.    {
    


  139. 

  140.     SoftwareUART_TestItem();
    

  141.     u8TestItem = getchar(); 
    

  142.     printf("%c\n",u8TestItem);
    

  143.     
    

  144.      switch(u8TestItem)
    

  145.      {
    

  146.        case '1':
    

  147.                UART_TX_TestFunctoion(g_psSoftwareUART_Config);
    

  148.               break; 
    

  149.        case '2':
    

  150.                UART_RX_TestFunctoion(g_psSoftwareUART_Config);
    

  151.               break;
    

  152.        default:
    

  153.               break;                                  
    

  154.      } 
    

  155.     }
    

  156. }
    


  157. 

  158. /*** (C) COPYRIGHT 2019 Nuvoton Technology Corp. ***/
    


  159.
回复

收藏 举报

huangcunxiake 发表于 2020-3-26 22:31 | 显示全部楼层

前来观摩学习。
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

antusheng

86

主题

1723

帖子

5

粉丝
快速回复 在线客服 返回列表 返回顶部