⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 uart.lst

📁 c8051f330系统
💻 LST
字号:
C51 COMPILER V7.50   UART                                                                  12/11/2007 10:19:45 PAGE 1   


C51 COMPILER V7.50, COMPILATION OF MODULE UART
OBJECT MODULE PLACED IN Uart.OBJ
COMPILER INVOKED BY: D:\keil\C51\BIN\C51.EXE Uart.c BROWSE DEBUG OBJECTEXTEND

line level    source

   1          
   2          //#include "ML-330.H"
   3          
   4          //#define SYSCLK      24500000
   5          
   6          #include <string.h>
   7          #include "c8051F330.h"
   8          //#include "const.h"
   9          #include "uart.h"
  10          
  11          
  12          //串口读写驱动程序
  13          
  14          #define  SYSCLK 22118400
  15          
  16          #define MAX_LEN      128
  17          #define MAX_SEND_LEN 256
  18          
  19          
  20          volatile bit  readFlag0 = 0;                           //Uart0中断接收处理标志
  21          volatile bit  readFlag1 = 0;                           //Uart1中断接收处理标志
  22          volatile bit  sendFlag0 = 0;                           //Uart0中断发送处理标志
  23          volatile bit  sendFlag1 = 0;                           //Uart1中断发送处理标志
  24          
  25          volatile unsigned char xdata PRead0 = 0;                   //uart0接收缓冲读指针
  26          volatile unsigned char xdata PWrite0 = 0;                   //uart0接收缓冲写指针
  27          volatile unsigned char xdata PRead1 = 0;                   //uart1接收缓冲读指针
  28          volatile unsigned char xdata PWrite1 = 0;                   //uart1接收缓冲写指针
  29          
  30          volatile unsigned char xdata PSendRead0 = 0;                   //uart0发送缓冲读指针
  31          volatile unsigned char xdata PSendWrite0 = 0;                   //uart0发送缓冲写指针
  32          volatile unsigned char xdata PSendRead1 = 0;                   //uart1发送缓冲读指针
  33          volatile unsigned char xdata PSendWrite1 = 0;                   //uart1发送缓冲写指针
  34          
  35          unsigned char xdata BufData0[MAX_LEN];  //uart0接收缓冲
  36          unsigned char xdata BufSend0[MAX_SEND_LEN];  //uart0发送缓冲
  37          unsigned char xdata BufData1[MAX_LEN];  //uart1接收缓冲
  38          unsigned char xdata BufSend1[MAX_SEND_LEN];  //uart1发送缓冲
  39          
  40          unsigned char xdata SendCount0 = 0;               //uart0发送字节数
  41          unsigned char xdata SendCount1 = 0;               //uart0发送字节数
  42          
  43          
  44          void Uart0_Init(unsigned long BAUDRATE)
  45          {
  46   1         SCON0 = 0x10;//允许接收
  47   1      
  48   1        if (SYSCLK/BAUDRATE/2/256 < 1) {
  49   2            TH1 = 255-(SYSCLK/BAUDRATE);
  50   2            CKCON &= ~0x0B;                  // T1M = 1; SCA1:0 = xx
  51   2            CKCON |=  0x08;
  52   2         } else if (SYSCLK/BAUDRATE/2/256 < 4) {
  53   2            TH1 = -(SYSCLK/BAUDRATE/2/4);
  54   2            CKCON &= ~0x0B;                  // T1M = 0; SCA1:0 = 01                  
  55   2            CKCON |=  0x09;
C51 COMPILER V7.50   UART                                                                  12/11/2007 10:19:45 PAGE 2   

  56   2         } else if (SYSCLK/BAUDRATE/2/256 < 12) {
  57   2            TH1 = -(SYSCLK/BAUDRATE/2/12);
  58   2            CKCON &= ~0x0B;                  // T1M = 0; SCA1:0 = 00
  59   2         } else {
  60   2            TH1 = -(SYSCLK/BAUDRATE/2/48);
  61   2            CKCON &= ~0x0B;                  // T1M = 0; SCA1:0 = 10
  62   2            CKCON |=  0x02;
  63   2         }
  64   1         /*TH1 =  63;
  65   1         CKCON &= ~0x0B;
  66   1         CKCON |=  0x08;*/
  67   1      
  68   1         TL1 = TH1;
  69   1         TMOD &= ~0xf0;
  70   1         TMOD |=  0x20;
  71   1         TR1 = 1;
  72   1        // TI0 = 1;
  73   1      }
  74          
  75          
  76          //串口接收函数
  77          unsigned char UART_Read(const unsigned char ComPort,
  78                                  unsigned char *Buffer)
  79          {
  80   1        unsigned char xdata BufferStr[MAX_LEN];
  81   1        int xdata readCounts = 0; //已经读取的字符个数,与MAX_LEN比较 
  82   1        unsigned char xdata temp = 0;
  83   1        unsigned char xdata BufLen = 0;
  84   1      
  85   1        if ((PRead0!=PWrite0) & (ComPort == 0))
  86   1        {
  87   2          temp = PWrite0;
  88   2          readCounts = (int)temp - (int)PRead0;  
  89   2      
  90   2          if (readCounts > 0)
  91   2          {
  92   3            memcpy( BufferStr, BufData0 + PRead0 , readCounts);   
  93   3            PRead0 = temp;   
  94   3      
  95   3            memcpy(Buffer,BufferStr,readCounts);
  96   3      
  97   3            BufLen = readCounts;
  98   3          }
  99   2          else if ( readCounts < 0)
 100   2          { 
 101   3            memcpy( BufferStr, BufData0 + PRead0 , MAX_LEN-PRead0);
 102   3      
 103   3            memcpy( BufferStr+MAX_LEN-PRead0, BufData0 , temp);
 104   3      
 105   3            PRead0 = temp;
 106   3      
 107   3            memcpy(Buffer,BufferStr,MAX_LEN+readCounts);
 108   3      
 109   3            BufLen = MAX_LEN+readCounts;
 110   3          }
 111   2          readFlag0 = 1;         
 112   2        }
 113   1        else if ((PRead1!=PWrite1) & (ComPort == 1))
 114   1        {
 115   2          temp = PWrite1;
 116   2          readCounts = (int)temp - (int)PRead1;  
 117   2          memset( BufferStr, 0, MAX_LEN );
C51 COMPILER V7.50   UART                                                                  12/11/2007 10:19:45 PAGE 3   

 118   2          if (readCounts > 0)
 119   2          {
 120   3            memcpy( BufferStr, BufData1 + PRead1 , readCounts);   
 121   3            PRead1 = temp;    
 122   3            memcpy(Buffer,BufferStr,readCounts);   
 123   3            BufLen = readCounts;
 124   3          }
 125   2          else if ( readCounts < 0)
 126   2          {
 127   3            memcpy( BufferStr, BufData1 + PRead1 , MAX_LEN-PRead1);
 128   3            memcpy( BufferStr+MAX_LEN-PRead1, BufData1 , temp);
 129   3            PRead1 = temp;
 130   3            memcpy(Buffer,BufferStr,MAX_LEN+readCounts);
 131   3            BufLen = MAX_LEN+readCounts;
 132   3          }
 133   2          readFlag1 = 1;         
 134   2        } 
 135   1        return BufLen;
 136   1      }
 137          
 138          void Send_Char(const unsigned char com,unsigned char ch)
 139          {
 140   1         
 141   1        switch (com)
 142   1        {
 143   2          case 0:
 144   2            //SFRPAGE = UART0_PAGE;
 145   2                SBUF0 = ch;
 146   2                break;
 147   2              case 1:
 148   2            //SFRPAGE = UART1_PAGE;
 149   2                //SBUF1 = ch;
 150   2                break;
 151   2          default:
 152   2                break;
 153   2        }
 154   1        
 155   1      }
 156          
 157          //串口发送函数
 158          void UART_Send(const unsigned char ComPort,
 159                         const unsigned char *Data,
 160                                     const unsigned char DataSize)
 161          {
 162   1      
 163   1        unsigned int k = 0;
 164   1        int i;
 165   1        
 166   1        if ((DataSize > 0)&(DataSize< MAX_SEND_LEN))
 167   1        {
 168   2          switch (ComPort)
 169   2                {
 170   3                  case 0:
 171   3                        //将需要发送的数据放入相应的发送缓冲内
 172   3                    for (i=0;i<DataSize;i++)
 173   3                        {
 174   4                          BufSend0[PSendWrite0] = Data[i];
 175   4                          PSendWrite0++;
 176   4                          if (PSendWrite0 == MAX_SEND_LEN)
 177   4                          {
 178   5                            PSendWrite0 = 0; 
 179   5                          }
C51 COMPILER V7.50   UART                                                                  12/11/2007 10:19:45 PAGE 4   

 180   4                        }
 181   3      
 182   3              //判断中断服务程序是否完成发送(发送标志位是否为0)
 183   3                        if (sendFlag0 == 0)
 184   3                        {             
 185   4                          sendFlag0 = 1;  //置发送标志位为1
 186   4                          Send_Char(ComPort,*Data);//调用发送字符函数,发送第一个字节,触发发送中断
 187   4                        }                     
 188   3                        break;
 189   3                        case 1:
 190   3                                //将需要发送的数据放入相应的发送缓冲内
 191   3                        for (i=0;i<DataSize;i++)
 192   3                        {
 193   4                          BufSend1[PSendWrite1] = Data[i];
 194   4                          PSendWrite1++;
 195   4                          if (PSendWrite1 == MAX_SEND_LEN)
 196   4                          {
 197   5                            PSendWrite1 = 0; 
 198   5                          }
 199   4                        }
 200   3              //判断中断服务程序是否完成发送(发送标志位是否为0)
 201   3                        if (sendFlag1 == 0)
 202   3                        {             
 203   4                          sendFlag1 = 1;  //置发送标志位为1
 204   4                          Send_Char(ComPort,*Data);//调用发送字符函数,发送第一个字节,触发发送中断
 205   4                        }                     
 206   3                        break;
 207   3                  default:
 208   3                    break;
 209   3          }  
 210   2        }
 211   1      }
 212          
 213          //UART0中断服务程序. 接收字符
 214          void UART0_ISR(void) interrupt 4 
 215          {
 216   1        unsigned char rxch;
 217   1        
 218   1        
 219   1        readFlag0 = 0; //中断处理标志
 220   1        //SFRPAGE = UART0_PAGE;
 221   1        if(RI0)                                   //中断标志 RI0=1 数据完整接收
 222   1        {
 223   2          RI0 = 0;                              //软件清零
 224   2          rxch = SBUF0;                         //读缓冲
 225   2           
 226   2          if(PWrite0==MAX_LEN) 
 227   2          {
 228   3            PWrite0 = 0;
 229   3          }
 230   2          BufData0[PWrite0] = rxch;                    
 231   2          PWrite0++;    
 232   2          readFlag0 =1;    
 233   2        }
 234   1      
 235   1        if (TI0)
 236   1        {              // handle transmit function
 237   2          TI0 = 0;                         // 清除发送完成标志
 238   2          //将缓冲尾指针加1
 239   2                      PSendRead0++;
 240   2                      if (PSendRead0 == MAX_SEND_LEN)
 241   2                      {
C51 COMPILER V7.50   UART                                                                  12/11/2007 10:19:45 PAGE 5   

 242   3                        PSendRead0 = 0;
 243   3                      }
 244   2                      
 245   2                      if (PSendWrite0!=PSendRead0)     //判断缓冲内的首尾指针是否相同
 246   2                      {
 247   3                        SBUF0 = BufSend0[PSendRead0];  //如果不同,发送尾指针所在的字节
 248   3                      }
 249   2                      else 
 250   2                      {
 251   3                        sendFlag0 = 0;                 //如果相同,置发送标志为0
 252   3                      }
 253   2        }
 254   1      
 255   1      }
 256          
 257          


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =   1277    ----
   CONSTANT SIZE    =   ----    ----
   XDATA SIZE       =    778     132
   PDATA SIZE       =   ----    ----
   DATA SIZE        =   ----      17
   IDATA SIZE       =   ----    ----
   BIT SIZE         =      4    ----
END OF MODULE INFORMATION.


C51 COMPILATION COMPLETE.  0 WARNING(S),  0 ERROR(S)

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -