cc1100drv.txt

cc1100的驱动程序

#include<pic.h>
__CONFIG(INTOSCIO&UNPROTECT&WDTDIS&MCLRDIS&BOREN);

#define PCLK RA0
#define PDATA RA1
#define PALE  RA2
#define TR_SW RA3
#define DCLK RC0
#define DIO RC1
#define LED RC2

bit fgbit;
char DATA[4];


#define CC1000_MAIN            0x00
#define CC1000_FREQ_2A         0x01
#define CC1000_FREQ_1A         0x02
#define CC1000_FREQ_0A         0x03
#define CC1000_FREQ_2B         0x04
#define CC1000_FREQ_1B         0x05
#define CC1000_FREQ_0B         0x06
#define CC1000_FSEP1           0x07
#define CC1000_FSEP0           0x08
#define CC1000_CURRENT         0x09
#define CC1000_FRONT_END       0x0A
#define CC1000_PA_POW          0x0B
#define CC1000_PLL             0x0C
#define CC1000_LOCK            0x0D
#define CC1000_CAL             0x0E
#define CC1000_MODEM2          0x0F
#define CC1000_MODEM1          0x10
#define CC1000_MODEM0          0x11
#define CC1000_MATCH           0x12
#define CC1000_FSCTRL          0x13
#define CC1000_FSHAPE7         0x14
#define CC1000_FSHAPE6         0x15
#define CC1000_FSHAPE5         0x16
#define CC1000_FSHAPE4         0x17
#define CC1000_FSHAPE3         0x18
#define CC1000_FSHAPE2         0x19
#define CC1000_FSHAPE1         0x1A
#define CC1000_FSDELAY         0x1B
#define CC1000_PRESCALER       0x1C
#define CC1000_TEST6           0x40
#define CC1000_TEST5           0x41
#define CC1000_TEST4           0x42
#define CC1000_TEST3           0x43
#define CC1000_TEST2           0x44
#define CC1000_TEST1           0x45
#define CC1000_TEST0           0x46

bit fgkey;
bit fgbit;
bit fgdio;

void delay1mS(int time)
{
 char i;
 char j;
 for(j=0;j<time;j++)
 {
  for(i=0;i<165;i++);
//  {
//   NOP();
//   NOP();
//   TMR0=0;
//   while(TMR0<238);
//  }
 }
}
//******************************************************//

void delay (unsigned char m)   //控制频率延时
{ 
 unsigned i=3*m;
 while(i--);
}


/****************************************************************************/
/*   CC1000    写内部寄存器子程序             
/****************************************************************************/
void WriteToCC1000Register(char Register, char DATA)
{
 char i;
 PCLK=1;
 PDATA=1;
 PALE=0;
 Register=(Register<<1)+0x01;
 for(i=8;i>0;i--)
 {
  if(Register&0x80)PDATA=1;
  else PDATA=0;
  PCLK=1;
  Register<<=1;
  NOP();
  NOP();
  NOP();
  NOP();
  NOP();
  PCLK=0;                               
 }
 NOP();
 PCLK=1;
 PALE=1;
 for(i=8;i>0;i--)
 {
  if(DATA&0x80)PDATA=1;
  else PDATA=0;
  PCLK=1;
  DATA<<=1;
  NOP();
  NOP();
  NOP();
  NOP();
  NOP();
  PCLK=0;                                
 }
 NOP();
 NOP();
 NOP();
 NOP();
 NOP();
 PCLK=1;
 PDATA=1;
}

/****************************************************************************/
/*   CC1000    读内部寄存器子程序             
/****************************************************************************/
char ReadfromCC1000Register(char addr)
{
  char Result=0;
  char i;
  PCLK=1;
  PDATA=1;
  PALE=0;
  addr=addr<<1;
  for(i=8;i>0;i--)
  {
   if(addr&0x80)PDATA=1;
    else PDATA=0;
    PCLK=1;
    addr<<=1;
    NOP();
    NOP();
    NOP();
    NOP();
    NOP();
    PCLK=0;                                
  }
  TRISA=0x0a;
  NOP();
  PCLK=1;
  PALE=1;
  for(i=8;i>0;i--)
  {
   PCLK=1;
   Result=(Result<<1)|PDATA;
   NOP();
   NOP();
   NOP(); 
   PCLK=0; 
   NOP();
   NOP();
   NOP();
   NOP();                      
 }
 PCLK=1;
 TRISA=0x08;
 return(Result);
}
/****************************************************************************/
/*  This routine puts the CC1000 into RX mode . When switching to  */
/*  RX from PD, use WakeupC1000ToRX first                                   */
/****************************************************************************/

void CC1000_init()
{
 char cal_complete;
 WriteToCC1000Register(CC1000_MAIN,0x3a);          //RXTX=0;F_REQ=0(RX:Register A ,TX:Register B);RX_PD=1;TX_PD=1;FS_PD=1;CORE_PD=0;BIAS_PD=1;REST_N=0
 WriteToCC1000Register(CC1000_PA_POW,0x00); 
 WriteToCC1000Register(CC1000_MAIN,0x3b);       
 //cal_complete=ReadfromCC1000Register(CC1000_MAIN);
// cal_complete=0;
// WriteToCC1000Register(CC1000_MAIN,cal_complete);
 delay1mS(2);
// WriteToCC1000Register(CC1000_MAIN,0x01);
// writes 24-bit frequency value used for RX to 433.9164 MHz.
// Check CC1000 data sheet for equations used to find
// 0x582000.
 WriteToCC1000Register(CC1000_FREQ_2A,0x58);       
 WriteToCC1000Register(CC1000_FREQ_1A,0x20);
 WriteToCC1000Register(CC1000_FREQ_0A,0x00);
// writes 24-bit frequency value used for TX to 433.9164 MHz.
// Check CC1000 data sheet for equations used to find
// 0x448856.
 WriteToCC1000Register(CC1000_FREQ_2B,0x44);       
 WriteToCC1000Register(CC1000_FREQ_1B,0x88);
 WriteToCC1000Register(CC1000_FREQ_0B,0x56);
// sets frequency separation between 0 value and 1 value
//设定误码率
 WriteToCC1000Register(CC1000_FSEP1,0x02);
 WriteToCC1000Register(CC1000_FSEP0,0x98);
 WriteToCC1000Register(CC1000_CURRENT,0x44);
// sets some internal current levels, and enables RSSI output to pin
 WriteToCC1000Register(CC1000_FRONT_END,0x12);
 WriteToCC1000Register(CC1000_PA_POW,0xff);
// sets the PLL reference divider to divide by 6
 WriteToCC1000Register(CC1000_PLL,0x48);   
// sets External LNA control lock indicator to output on the CHP_OUT pin                  
 WriteToCC1000Register(CC1000_LOCK,0xa0);
 WriteToCC1000Register(CC1000_CAL,0x26);   
// sets threshold level for peak detector (not used in this design) 
 WriteToCC1000Register(CC1000_MODEM2,0x8E);    
// sets the averaging filter to free-running and controlled by writes
// to bit 4 of this register.
// Sets averaging filter sensitivity to .6dB worst-case loss of sensitivity
 WriteToCC1000Register(CC1000_MODEM1,0x6F); 
// baud rate to 2.4 k, Manchester, and crystal freq. to 11.0592 MHz
 WriteToCC1000Register(CC1000_MODEM0,0x22);            
// sets capacitor array values for RX and TX
 WriteToCC1000Register(CC1000_MATCH,0x70); 
// disables dithering and data shaping  
 WriteToCC1000Register(CC1000_FSCTRL,0x01); 
// sets prescaling to nominal values  
/*
 WriteToCC1000Register(CC1000_FSHAPE7,0x1c);
 WriteToCC1000Register(CC1000_FSHAPE6,0x16);
 WriteToCC1000Register(CC1000_FSHAPE5,0x10);
 WriteToCC1000Register(CC1000_FSHAPE4,0x0a);
 WriteToCC1000Register(CC1000_FSHAPE3,0x06);
 WriteToCC1000Register(CC1000_FSHAPE2,0x03);
 WriteToCC1000Register(CC1000_FSHAPE1,0x01);
*/
 WriteToCC1000Register(CC1000_FSDELAY,0x1f);
 WriteToCC1000Register(CC1000_PRESCALER,0x00);

// sets charge pump current scaling factor, which determines the bandwidth
// of the PLL.
// WriteToCC1000Register(CC1000_TEST4,0x25);
// Calibration Process
// RX Calibration
// set transceiver to RX mode
 WriteToCC1000Register(CC1000_MAIN,0x11);
 WriteToCC1000Register(CC1000_CURRENT,0x44);// RX mode current
 WriteToCC1000Register(CC1000_PLL,0x48);
 WriteToCC1000Register(CC1000_CAL,0xa6);
 cal_complete = 0;
 do
 {
  cal_complete =ReadfromCC1000Register(CC1000_CAL);
 }
 while(!(cal_complete & 0x08)); // spin until calibration is complete
 WriteToCC1000Register(CC1000_CAL,0x26);
// TX Calibration
 WriteToCC1000Register(CC1000_MAIN,0xE1);
 WriteToCC1000Register(CC1000_CURRENT,0x81);// TX mode current
 WriteToCC1000Register(CC1000_PA_POW,0xff);
 WriteToCC1000Register(CC1000_PLL,0x38);   
// calibration
 WriteToCC1000Register(CC1000_CAL,0xa6);
 cal_complete = 0;
 do
 {
  cal_complete =ReadfromCC1000Register(CC1000_CAL);
 }
 while(!(cal_complete & 0x08)); // spin until calibration is complete
 WriteToCC1000Register(CC1000_CAL,0x26);
 WriteToCC1000Register(CC1000_MAIN,0x3d);
 WriteToCC1000Register(CC1000_PA_POW,0x00);
}
//-----------------------------------------------------------------------------
// C1000_RX_MODE
//-----------------------------------------------------------------------------
// C1000_RX_MODE sets the transceiver to RX mode and
// then initializes the 250 microsecond counter
// that gets incremented in the ADC ISR.
void C1000_RX_MODE(void)
{
 WriteToCC1000Register(CC1000_MAIN,0x11); // set to RX mode
 WriteToCC1000Register(CC1000_CURRENT,0x44); // set RX current level
 WriteToCC1000Register(CC1000_PLL,0x48);   
}
//-----------------------------------------------------------------------------
// C1000_TX_MODE
//-----------------------------------------------------------------------------
// C1000_TX_MODE sets the transceiver to TX mode and
// then initializes the 250 microsecond counter
void C1000_TX_MODE(void)
{
 WriteToCC1000Register(CC1000_MAIN,0xe1); // set to TX mode
 WriteToCC1000Register(CC1000_PA_POW,0xff); // no output power needed
 WriteToCC1000Register(CC1000_CURRENT,0x81); // set TX current level
 WriteToCC1000Register(CC1000_PLL,0x38);   
}
//-----------------------------------------------------------------------------
// C1000_PWDON_MODE
//-----------------------------------------------------------------------------
// C1000_PWDON_MODE sets the transceiver to TX mode and
// then initializes the 250 microsecond counter
void C1000_PWDON_MODE(void)
{
 WriteToCC1000Register(CC1000_MAIN,0x3F);
}
 
void TX(char TXDATA)
{
 char i;
 for(i=8;i>0;i--)
 {
  while(DCLK==1);
  if(TXDATA&0x80)DIO=1;
  else DIO=0;
  TXDATA<<=1;
  while(DCLK==0);
 }
}

void Transmit(char addr1,char addr2,char TXdata)
{
 char j;
 TRISC=0x01; 
 for(j=6;j>0;j--)
 {
  TX(0xaa);
  TX(addr1);
  TX(addr2);
  TX(TXdata);
 }
 TRISC=0x03; 
}
char rebit;    //接收位数
char  Txbit;            //发射位数
char syncdata; 
char Rxbuffer[3];      //接收缓充
char Txbuffer[3];
bit  Rxfull;           //接收缓充溢出标志
bit  RXEN;             //允许接收标志
bit  TxEN;             //允许发射标志
bit  Txcomplete;       //发射完成标志
char seendtime;        //
char Txtime;           //重复发射次数
bit seendcomple;
/************************************************************************************
函数：
功能：
*************************************************************************************/
#pragma    // install as interrupt handler (comment for HiTech!)
interrupt
rxi()
{
 if(RXEN==1)
 {
  rebit++;
  switch(rebit)
  {
   case 1: if(DIO!=1)rebit=0;break;
   case 2: if(DIO!=0)rebit=0;break;
   case 3: if(DIO!=1)rebit=0;break;
   case 4: if(DIO!=0)rebit=0;break;
   case 5: if(DIO!=1)rebit=0;break;
   case 6: if(DIO!=0)rebit=0;break;
   case 7: if(DIO!=1)rebit=0;break;
   case 8: if(DIO!=0)rebit=0;
           else syncdata=0;
           break;
  }
  if(rebit>8)
  {
    syncdata=DIO;
    syncdata<<=1;
    if(rebit==16)Rxbuffer[0]=syncdata;syncdata=0;
    if(rebit==24)Rxbuffer[1]=syncdata;syncdata=0;
    if(rebit==32)rebit=0;Rxbuffer[2]=syncdata;syncdata=0;Rxfull=1;RXEN=0;
  }
 }
 if(TxEN==1)
 {
  if(seendtime<Txtime)
  {
   if(Txbit<32)
   {
    if(Txbit<8)
    {
     DIO=syncdata;
     syncdata<<=1;
    }
    else if(Txbit<16)
    {
     DIO=Txbuffer[0];
     Txbuffer[0]<<=1;
    }
    else if(Txbit<24)
    {
     DIO=Txbuffer[1];
     Txbuffer[1]<<=1;
    }
    else 
    {
     DIO=Txbuffer[2];
     Txbuffer[2]<<=1;
    }
    Txbit++;
   }
  if(Txbit==24)Txcomplete=1;
  seendtime++;
  }
 }
 else {TxEN=0;seendcomple=1;}
 INTF=0;
}

void main()
{
 TRISA=0x08;
 PORTA=0x07;
 TRISC=0x03;                             //b'
 PORTC=0x00;
// OPTION=0x0f;
 OPTION=0x07;
 CMCON=0X07;
 WPUA=0x35;
 CC1000_init();
 C1000_PWDON_MODE();
// CLRWDT();
 while(1)
 {
  if(TR_SW==0)
  {
   C1000_TX_MODE();
   while(TR_SW==0)Transmit(0x00,0x08,0x04); //A
   C1000_PWDON_MODE();
  }
  else
  {
   C1000_RX_MODE();   
   while(TR_SW==1)RX();
   C1000_PWDON_MODE();
  }
//  CLRWDT();
//  SLEEP();
//  CLRWDT();

 }
}