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

📄 main.lst

📁 C8051F320+Nrf24L01无线模块的实现
💻 LST
📖 第 1 页 / 共 3 页
字号:
C51 COMPILER V7.50   MAIN                                                                  05/25/2010 11:46:57 PAGE 1   


C51 COMPILER V7.50, COMPILATION OF MODULE MAIN
OBJECT MODULE PLACED IN .\Bin\main.obj
COMPILER INVOKED BY: C:\Keil\C51\BIN\C51.EXE main.c BROWSE DEBUG OBJECTEXTEND SYMBOLS PRINT(.\Bin\main.lst) OBJECT(.\Bin
                    -\main.obj)

line level    source

   1          #include "c8051f320.h"
   2          #include "typedef.h"
   3          #include "misc.h"
   4          #include "io.h"
   5          //#include "reg51.H"
   6          #include "api.h"
   7          #define uchar unsigned char
   8          #define uint unsigned int
   9           void init_io();                //声明外部函数
  10           void RX_Mode();
  11           void init_int0();
  12           void CheckButtons();
  13           uchar SPI_RW_REG(BYTE reg,BYTE value);
  14           //extern  uchar SPI_RW_REG123(BYTE reg,BYTE value);
  15          uchar flag;
  16          #define uchar unsigned char
  17          #define TX_ADR_WIDTH    5   // 5 bytes TX(RX) address width
  18          #define TX_PLOAD_WIDTH  20  // 20 bytes TX payload
  19          
  20          uchar const TX_ADDRESS[TX_ADR_WIDTH]  = {0x34,0x43,0x10,0x10,0x01}; // Define a static TX address
  21          /*uchar Original_ADDRESS[TX_ADR_WIDTH] ={0x32,0x43,0x10,0x10,0x01};      //Define Original address 
  22          uchar OnePress_ADDRESS[TX_ADR_WIDTH] ={0x33,0x43,0x10,0x10,0x01};
  23          /*BYTE const TX_PAYLOAD[TX_PLOAD_WIDTH] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
  24                                                   0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f}; */
  25          uchar rx_buf[TX_PLOAD_WIDTH];
  26          uchar tx_buf[TX_PLOAD_WIDTH];
  27          
  28          
  29          sbit key=P3^0;
  30          sbit led=P2^4;
  31          /**************************************************/
  32          sbit CE =  P0^4;
  33          sbit CSN=  P0^3;
  34          sbit SCK=  P0^0;
  35          sbit MOSI= P0^2;
  36          sbit MISO= P0^1;
  37          sbit IRQ = P0^5;
  38          /**************************************************/
  39          uchar   bdata sta;
  40          sbit    RX_DR   =sta^6;
  41          sbit    TX_DS   =sta^5;
  42          sbit    MAX_RT  =sta^4;
  43          uchar tf=0; // Send interrut enabled flag
  44          //      uchar t;   //record the number of times you press the button
  45                  uchar i;   //recond the number of times led shake
  46          /*void main(void)       // 主程序
  47          {
  48                  bit light;       //位变量
  49                  uint n;
  50                  PCA0MD &=  0xb9;
  51                  while(1) //程序循环
  52                  {
  53                          if(!K1)  //如果读到K1为0
  54                          {
C51 COMPILER V7.50   MAIN                                                                  05/25/2010 11:46:57 PAGE 2   

  55                                  for(n=0;n<1000;n++); //等待按键稳定
  56                                  light=~light;  //每按键一次,标记变化一次
  57                                  while(!K1);     //等待按键松开
  58                                  for(n=0;n<1000;n++);  //等待按键稳定松开
  59                          }
  60                          P0=light; //直接把位变量赋值给LED灯
  61                  }
  62          }        
  63          
  64          */      
  65          
  66          void delays(uchar n)
  67          {
  68   1              for(;n>0;n--)
  69   1                      _nop_();
  70   1      }
  71          void init_io(void)
  72          {
  73   1              delays(100);
  74   1              CE=0;                   // chip enable
  75   1              CSN=1;                  // Spi disable  
  76   1              SCK=0;          // Spi clock line init high
  77   1      
  78   1      }       
  79          void init_int0()
  80          {
  81   1              EA=1;
  82   1              EX0=1;                                          // Enable int0 interrupt.
  83   1      }       
  84          /*The following program is achieve by HardWare SPI*/
  85          void SPI_rf_write(uchar dat)
  86          {
  87   1              while(SPI0CFG&0x80);
  88   1              SPIF = 0;
  89   1              SPI0DAT = dat;
  90   1              while(!SPIF);   //wait spi transfer finish
  91   1      }
  92          uchar SPI_rf_read(void)
  93          {
  94   1              while(SPI0CFG&0x80);
  95   1              SPIF = 0;
  96   1              SPI0DAT = 0x00;
  97   1              while(!SPIF);   //wait spi transfer finish
  98   1              return (SPI0DAT);
  99   1      }
 100          void write_rf_reg(uchar address,uchar dat)
 101          {
 102   1              CSN=0;
 103   1              SPI_rf_write(WRITE_REG + address);
 104   1              SPI_rf_write(dat);
 105   1              CSN=1;
 106   1      }
 107          uchar read_rf_reg(uchar address)
 108          {       
 109   1              uchar status;
 110   1              CSN=0;
 111   1              SPI_rf_write(address);
 112   1              status = SPI_rf_read();
 113   1              CSN=1;
 114   1              return (status);
 115   1      }
 116          void write_rf_data(uchar reg,uchar *data_ptr,uchar nLength)
C51 COMPILER V7.50   MAIN                                                                  05/25/2010 11:46:57 PAGE 3   

 117          {
 118   1              uchar i;
 119   1              CSN=0;
 120   1              SPI_rf_write(reg);
 121   1              for(i=0;i<nLength;i++)
 122   1                      SPI_rf_write(*data_ptr++);
 123   1              CSN=1;
 124   1      }                                /*
 125          uchar read_rf_data(uchar reg,uchar *data_ptr,uchar nLength)
 126          {
 127                  uchar i,status;
 128                  CSN=0;
 129                  SPI_rf_write(reg);
 130                  for(i=0;i<nLength;i++)
 131                  data_ptr[nLength]=SPI_rf_read();
 132                  status=SPI_rf_read();
 133                  CSN=1;
 134                  return(status);
 135          }
 136          
 137                             /*
 138          uchar SPI_Read_Buf(BYTE reg, BYTE *pBuf, BYTE bytes)
 139          {
 140                  uchar status,byte_ctr;
 141          
 142                  CSN = 0;                                // Set CSN low, init SPI tranaction
 143                  status = SPI_RW(reg);                   // Select register to write to and read status byte
 144          
 145                  for(byte_ctr=0;byte_ctr<bytes;byte_ctr++)
 146                  pBuf[byte_ctr] = SPI_RW(0);    // Perform SPI_RW to read byte from nRF24L01
 147          
 148                  CSN = 1;                           // Set CSN high again
 149          
 150                  return(status);                    // return nRF24L01 status byte
 151          }                        */       
 152          void init_24L01()
 153          {        
 154   1              CE=0;
 155   1              
 156   1              write_rf_data(WRITE_REG + TX_ADDR,TX_ADDRESS,TX_ADR_WIDTH);             
 157   1              write_rf_data(WRITE_REG + RX_ADDR_P0,TX_ADDRESS,TX_ADR_WIDTH);
 158   1              
 159   1              write_rf_reg(EN_AA,0x01);
 160   1              write_rf_reg(EN_RXADDR,0x01);
 161   1              write_rf_reg(SETUP_RETR,0x1a);
 162   1              write_rf_reg(RF_CH,40);
 163   1              write_rf_reg(RF_SETUP,0x0f);
 164   1              write_rf_reg(CONFIG,0x0f);
 165   1      
 166   1              CE=1;
 167   1              delays(130);
 168   1      //      flush_rf_tx();
 169   1      //      flush_rf_rx();
 170   1      }
 171          void Set_TX()
 172          {
 173   1              CE=0;
 174   1      
 175   1              write_rf_data(WRITE_REG + RX_ADDR_P0,TX_ADDRESS,TX_ADR_WIDTH);
 176   1              write_rf_data(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH);
 177   1              write_rf_reg(CONFIG,0x0e);
 178   1      
C51 COMPILER V7.50   MAIN                                                                  05/25/2010 11:46:57 PAGE 4   

 179   1              CE=1;
 180   1              delays(130);            
 181   1      }                                       
 182          void Set_RX()
 183          {
 184   1              CE=0;
 185   1      
 186   1              write_rf_reg(CONFIG,0x0f);
 187   1              write_rf_reg(RX_PW_P0,TX_PLOAD_WIDTH);
 188   1              
 189   1              CE=1;
 190   1              delays(130);
 191   1      }          
 192          /*The foregoing program is achieve by HardWare SPI*/
 193                  /*               
 194          uchar SPI_RW(uint  byte)
 195          {
 196                  uchar bit_ctr;
 197                  for(bit_ctr=0;bit_ctr<8;bit_ctr++)   // output 8-bit
 198                  {
 199                          MOSI = (byte & 0x80);         // output 'byte', MSB to MOSI
 200                          byte = (byte << 1);           // shift next bit into MSB..
 201                          SCK = 1;                      // Set SCK high..
 202                          byte |= MISO;                     // capture current MISO bit
 203                          SCK = 0;                          // ..then set SCK low again
 204                  }                                
 205              return(byte);                         // return read byte
 206          }  
 207          uchar SPI_RW_Reg(BYTE reg, BYTE value)
 208          {
 209                  uchar status;
 210           
 211                  CSN = 0;                   // CSN low, init SPI transaction
 212                  status = SPI_RW(reg);      // select register
 213                  SPI_RW(value);             // ..and write value to it..

⌨️ 快捷键说明

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