ti_cc_spi.lst

8051f340实现cc1100软件SPI的正常数据收发

                IFG2 &= ~UCB1RXIFG;                       // Clear flag set during last write
                UCB1TXBUF = (addr | TI_CCxxx0_READ_BURST);// Send address
                while (!(IFG2&UCB1RXIFG));                // Wait for TX to finish
                IFG2 &= ~UCB1RXIFG;                       // Clear flag set during last write
                UCB1TXBUF = 0;                            // Dummy write so we can read data
                while (!(IFG2&UCB1RXIFG));                // Wait for RX to finish
                x = UCB1RXBUF;                            // Read data
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;         // /CS disable
              
                return x;
              }
              
C51 COMPILER V7.06   TI_CC_SPI                                                             02/03/2009 16:53:58 PAGE 16  

              void TI_CC_SPIStrobe(char strobe)
              {
                IFG2 &= ~UCB1RXIFG;                       // Clear flag
                TI_CC_CSn_PxOUT &= ~TI_CC_CSn_PIN;        // /CS enable
                while (TI_CC_SPI_USCIB1_PxIN&TI_CC_SPI_USCIB1_SOMI);// Wait for CCxxxx ready
                UCB1TXBUF = strobe;                       // Send strobe
                // Strobe addr is now being TX'ed
                while (!(IFG2&UCB1RXIFG));                // Wait for end of addr TX
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;         // /CS disable
              }
              
              void TI_CC_PowerupResetCCxxxx(void)
              {
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;
                TI_CC_Wait(30);
                TI_CC_CSn_PxOUT &= ~TI_CC_CSn_PIN;
                TI_CC_Wait(30);
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;
                TI_CC_Wait(45);
              
                TI_CC_CSn_PxOUT &= ~TI_CC_CSn_PIN;        // /CS enable
                while (TI_CC_SPI_USCIB1_PxIN&TI_CC_SPI_USCIB1_SOMI);// Wait for CCxxxx ready
                UCB1TXBUF = TI_CCxxx0_SRES;               // Send strobe
                // Strobe addr is now being TX'ed
                IFG2 &= ~UCB1RXIFG;                       // Clear flag
                while (!(IFG2&UCB1RXIFG));                // Wait for end of addr TX
                while (TI_CC_SPI_USCIB1_PxIN&TI_CC_SPI_USCIB1_SOMI);
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;         // /CS disable
              }
              
              
              #elif TI_CC_RF_SER_INTF == TI_CC_SER_INTF_USI
              
              
              void TI_CC_SPISetup(void)
              {
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;
                TI_CC_CSn_PxDIR |= TI_CC_CSn_PIN;         // /CS disable
              
                USICTL0 |= USIPE7 +  USIPE6 + USIPE5 + USIMST + USIOE;// Port, SPI master
                USICKCTL = USISSEL_2 + USICKPL;           // SCLK = SMCLK
                USICTL0 &= ~USISWRST;                     // USI released for operation
              
                USISRL = 0x00;                            // Ensure SDO low instead of high,
                USICNT = 1;                               // to avoid conflict with CCxxxx
              }
              
              void TI_CC_SPIWriteReg(char addr, char value)
              {
                TI_CC_CSn_PxOUT &= ~TI_CC_CSn_PIN;        // /CS enable
                while (TI_CC_SPI_USI_PxIN&TI_CC_SPI_USI_SOMI);// Wait for CCxxxx ready
                USISRL = addr;                            // Load address
                USICNT = 8;                               // Send it
                while (!(USICTL1&USIIFG));                // Wait for TX to finish
                USISRL = value;                           // Load value
                USICNT = 8;                               // Send it
                while (!(USICTL1&USIIFG));                // Wait for TX to finish
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;         // /CS disable
              }
              
              void TI_CC_SPIWriteBurstReg(char addr, char *buffer, char count)
              {
C51 COMPILER V7.06   TI_CC_SPI                                                             02/03/2009 16:53:58 PAGE 17  

                unsigned int i;
              
                TI_CC_CSn_PxOUT &= ~TI_CC_CSn_PIN;        // /CS enable
                while (TI_CC_SPI_USI_PxIN&TI_CC_SPI_USI_SOMI);// Wait for CCxxxx ready
                USISRL = addr | TI_CCxxx0_WRITE_BURST;    // Load address
                USICNT = 8;                               // Send it
                while (!(USICTL1&USIIFG));                // Wait for TX to finish
                for (i = 0; i < count; i++)
                {
                  USISRL = buffer[i];                     // Load data
                  USICNT = 8;                             // Send it
                  while (!(USICTL1&USIIFG));              // Wait for TX to finish
                }
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;         // /CS disable
              }
              
              char TI_CC_SPIReadReg(char addr)
              {
                char x;
              
                TI_CC_CSn_PxOUT &= ~TI_CC_CSn_PIN;        // /CS enable
                while (TI_CC_SPI_USI_PxIN&TI_CC_SPI_USI_SOMI);// Wait for CCxxxx ready
                USISRL = addr | TI_CCxxx0_READ_SINGLE;    // Load address
                USICNT = 8;                               // Send it
                while (!(USICTL1&USIIFG));                // Wait for TX to finish
                USICNT = 8;                               // Dummy write so we can read data
                while (!(USICTL1&USIIFG));                // Wait for RX to finish
                x = USISRL;                               // Store data
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;         // /CS disable
              
                return x;
              }
              
              void TI_CC_SPIReadBurstReg(char addr, char *buffer, char count)
              {
                unsigned int i;
              
                TI_CC_CSn_PxOUT &= ~TI_CC_CSn_PIN;        // /CS enable
                while (TI_CC_SPI_USI_PxIN&TI_CC_SPI_USI_SOMI);// Wait for CCxxxx ready
                USISRL = addr | TI_CCxxx0_READ_BURST;     // Load address
                USICNT = 8;                               // Send it
                while (!(USICTL1&USIIFG));                // Wait for TX to finish
                for (i = 0; i < count; i++)
                {
                  USICNT = 8;                             // Dummy write so we can read data
                  while (!(USICTL1&USIIFG));              // Wait for RX to finish
                  buffer[i] = USISRL;                     // Store data
                }
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;         // /CS disable
              }
              
              char TI_CC_SPIReadStatus(char addr)
              {
                char x;
              
                TI_CC_CSn_PxOUT &= ~TI_CC_CSn_PIN;        // /CS enable
                while (TI_CC_SPI_USI_PxIN&TI_CC_SPI_USI_SOMI);// Wait for CCxxxx ready
                USISRL = addr | TI_CCxxx0_READ_BURST;     // Load address
                USICNT = 8;                               // Send it
                while (!(USICTL1&USIIFG));                // Wait for TX to finish
                USICNT = 8;                               // Dummy write so we can read data
                while (!(USICTL1&USIIFG));                // Wait for RX to finish
C51 COMPILER V7.06   TI_CC_SPI                                                             02/03/2009 16:53:58 PAGE 18  

                x = USISRL;                               // Store data
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;         // /CS disable
              
                return x;
              }
              
              void TI_CC_SPIStrobe(char strobe)
              {
                TI_CC_CSn_PxOUT &= ~TI_CC_CSn_PIN;        // /CS enable
                while (TI_CC_SPI_USI_PxIN&TI_CC_SPI_USI_SOMI);// Wait for CCxxxx ready
                USISRL = strobe;                          // Load strobe
                USICNT = 8;                               // Send it
                while (!(USICTL1&USIIFG));                // Wait for TX to finish
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;         // /CS disable
              }
              
              void TI_CC_PowerupResetCCxxxx(void)
              {
                // Sec. 27.1 of CC1100 datasheet
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;
                TI_CC_Wait(30);
                TI_CC_CSn_PxOUT &= ~TI_CC_CSn_PIN;
                TI_CC_Wait(30);
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;
                TI_CC_Wait(45);
              
                TI_CC_CSn_PxOUT &= ~TI_CC_CSn_PIN;
                while (TI_CC_SPI_USI_PxIN&TI_CC_SPI_USI_SOMI);
                USISRL = TI_CCxxx0_SRES;
                USICNT = 8;
                while (!(USICTL1&USIIFG));
                while (TI_CC_SPI_USI_PxIN&TI_CC_SPI_USI_SOMI);
                TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;
              }
              
              
              #elif TI_CC_RF_SER_INTF == TI_CC_SER_INTF_BITBANG
1085          
1086          void TI_CC_SPI_bitbang_out(char);
1087          char TI_CC_SPI_bitbang_in();
1088          
1089          void TI_CC_SPISetup(void)
1090          {
1091   1        
1092   1        TI_CC_CSn_PxOUT |= TI_CC_CSn_PIN;
1093   1        TI_CC_CSn_PxDIR |= TI_CC_CSn_PIN;         // /CS disable
1094   1      
1095   1        // Config bitbang pins
1096   1        //TI_CC_SPI_BITBANG_PxREN |=TI_CC_SPI_BITBANG_SOMI; //2系列有
1097   1        TI_CC_SPI_BITBANG_PxOUT |= TI_CC_SPI_BITBANG_SIMO|TI_CC_SPI_BITBANG_UCLK;
1098   1        TI_CC_SPI_BITBANG_PxDIR |= TI_CC_SPI_BITBANG_SIMO | TI_CC_SPI_BITBANG_UCLK;
1099   1        
1100   1        
1101   1      }
1102          
1103          // Output eight-bit value using selected bit-bang pins
1104          void TI_CC_SPI_bitbang_out(char value)
1105          {
1106   1        char x;
1107   1      
1108   1        for(x=8;x>0;x--)
1109   1        {
C51 COMPILER V7.06   TI_CC_SPI                                                             02/03/2009 16:53:58 PAGE 19  

1110   2          if(value & 0x80)                                     // If bit is high...
1111   2            TI_CC_SPI_BITBANG_PxOUT |= TI_CC_SPI_BITBANG_SIMO; // Set SIMO high...
1112   2          else
1113   2            TI_CC_SPI_BITBANG_PxOUT &= ~TI_CC_SPI_BITBANG_SIMO;// Set SIMO low...
1114   2          value = value << 1;                                  // Rotate bits
1115   2      
1116   2          TI_CC_SPI_BITBANG_PxOUT &= ~TI_CC_SPI_BITBANG_UCLK;  // Set clock low
1117   2          TI_CC_SPI_BITBANG_PxOUT |= TI_CC_SPI_BITBANG_UCLK;   // Set clock high
1118   2        }
1119   1      }
1120          
1121          // Input eight-bit value using selected bit-bang pins
1122          char TI_CC_SPI_bitbang_in()
1123          {
1124   1        char x=0,shift=0;
1125   1        int y;
1126   1      
1127   1        // Determine how many bit positions SOMI is from least-significant bit
1128   1        x = TI_CC_SPI_BITBANG_SOMI;
1129   1        while(x>1)
1130   1        {
1131   2          shift++;
1132   2          x = x >> 1;
1133   2        };
1134   1      
1135   1        x = 0;
1136   1        for(y=8;