configure.c

单片无限收发芯片的一些资料

/****************************************************************************/
/* Application note AN015                                                   */
/* Reference design : CC1000 RF Modem                                       */
/*                                                                          */
/* File:      configure.c                                                   */
/* Revision:  1.0                                                           */
/*                                                                          */
/* Microcontroller:                                                         */
/*          Microchip PIC16F876                                             */
/*                                                                          */
/* Author:  Karl H. Torvmark, Field Applications Engineer, Chipcon          */
/*                                                                          */
/* Contact: Chipcon AS [phone]                                      */
/*          [e-mail]                                            */
/****************************************************************************/

/****************************************************************************/
/* This file contains routines for CC1000 configuration. The configuration  */
/* menu is implemented here.                                                */
/****************************************************************************/

/*                                                                           *
 * Revision history:                                                         *
 *                                                                           *
 * $Log: configure.c,v $
 * Revision 2.1  2003/04/24 12:42:41  tos
 * Cosmetic change: added revision history for CVS.
 *
 *                                                                           *
 ****************************************************************************/
 

#include "configure.h"
#include "cc1000.h"
#include "simpleio.h"
#include "io16f876.h" // IAR-specific header file for the 16F876
#include <ctype.h>    // ANSI standard header file
#include <stdio.h>    // ANSI standard header file

// The configuration data for the CC1000 is stored in the EEPROM data memory
// This allows the configuration to persist even when power is shut off,
// and also prevents this data from cluttering up the SRAM data memory.

 __eeprom __no_init union {
     char EEPROMCC1000Config[33];
     struct {
      char EEPROMFreq2A;
      char EEPROMFreq1A;
      char EEPROMFreq0A;
      char EEPROMFreq2B;
      char EEPROMFreq1B;
      char EEPROMFreq0B;
      char EEPROMFreqSep1;
      char EEPROMFreqSep0; 
      char EEPROMCurrent;
      char EEPROMXOsc;
      char EEPROMPAPower;
      char EEPROMPLL;
      char EEPROMLock;
      char EEPROMCal;
      char EEPROMModem2;
      char EEPROMModem1;
      char EEPROMModem0;
      char EEPROMMatch;
      char EEPROMFSControl;
      char EEPROMFShape7;
      char EEPROMFShape6;
      char EEPROMFShape5;
      char EEPROMFShape4;
      char EEPROMFShape3;
      char EEPROMFShape2;
      char EEPROMFShape1;
      char EEPROMFSDelay;
      char EEPROMPrescaler;
      char EEPROMTest6;
      char EEPROMTest5;
      char EEPROMTest4;
      char EEPROMTest3;
      char EEPROMTest2;
    };
};

// EEPROM variables for storing the characters sent when the buttons are pressed

__eeprom __no_init char EEPROMButton1Char;
__eeprom __no_init char EEPROMButton2Char;

// RAM variables that mirror the EEPROM variables above
__no_init char Button1Char, Button2Char;
 
// EEPROM unit address variable. Addressing is not yet implemented.
__eeprom __no_init char UnitAddress;

// EEPROM variables storing the value of the CURRENT and PLL registers in RX and TX
__eeprom __no_init char EEPROMTXCurrent;
__eeprom __no_init char EEPROMRXCurrent; 
__eeprom __no_init char EEPROMTXPLL;
__eeprom __no_init char EEPROMRXPLL;
 
// RAM variables that mirror the EEPROM variables above
__no_init char TXCurrent;
__no_init char RXCurrent;
__no_init char TXPLL;
__no_init char RXPLL;


// Default RF setups, stored in Flash
    
// 433.27 MHz, 0 dBm output (Europe)      
// Output power is set to 0 dBm so that use with 100% duty cycle is legal in most European countries
// Some countries allow +10 dBm without a restriction on duty cycle
// Also, if 10% duty cycle can be guaranteed, output power can be increased to +10 dBm
const char DefaultConfig433[35] = {0x66,0xC0,0x00,0x41,0xFB,0x2D,0x02,0x80,0x44,0x12,0x0F,0x70,0x10,0x26,0x8E,0x69,
  0x47,0x70,0x01,0x1C,0x16,0x10,0x0A,0x06,0x03,0x01,0x02,0x00,0x00,0x00,0x3F,0x00};
const char DefaultTXPLL433 = 0x48;
const char DefaultRXPLL433 = 0x70;
 
// 869.850 MHz, +5 dBm output (Europe)
const char DefaultConfig868[35] = {0x58,0x60,0x00,0x58,0x5B,0x43,0x01,0xAB,0x8C,0x32,0xFF,0x30,0x10,0x26,0x90,0x69,
  0x47,0x10,0x01,0x1C,0x16,0x10,0x0A,0x06,0x03,0x01,0x0F,0x00,0x00,0x00,0x3F,0x00};
const char DefaultTXPLL868 = 0x30;
const char DefaultRXPLL868 = 0x30;
  
// 905.002985 MHz, +5 dBm output (US)
const char DefaultConfig905[35] = {0xC7,0x60,0x00,0x5B,0xEE,0xF4,0x01,0xAB,0x8C,0x32,0xFF,0x68,0x10,0x26,0x91,0x69,
  0x47,0x10,0x01,0x1C,0x16,0x10,0x0A,0x06,0x03,0x01,0x06,0x00,0x00,0x00,0x3F,0x00};
const char DefaultTXPLL905 = 0x30;
const char DefaultRXPLL905 = 0x68;


// Configures all the CC1000 registers according to the values stored in EEPROM
void SetupCC1000All(void)
{ 
  char counter;
  char value;
  
  for (counter=0x01;counter<=0x1C;counter++) {
    value=EEPROMCC1000Config[counter-1];
    WriteToCC1000Register(counter,value);
  }
  

  for (counter=0x40;counter<=0x44;counter++) {
    value=EEPROMCC1000Config[counter-0x40+0x1C];
    WriteToCC1000Register(counter,value);
  }
  
  Button1Char=EEPROMButton1Char;
  Button2Char=EEPROMButton2Char;
  TXCurrent=EEPROMTXCurrent;
  RXCurrent=EEPROMRXCurrent;
  TXPLL=EEPROMTXPLL;
  RXPLL=EEPROMRXPLL;
}


// Dumps the values of all the registers of the CC1000 to the screen
void DumpCC1000Regs(void)
{
  char RegCounter;
  
  writestr("Register dump:\n\r\n\r");
  for(RegCounter=0x00;RegCounter<=0x1C;RegCounter++) {
    writestr("Addr. ");
    writehex(RegCounter);
    writestr(" : ");
    writehex(ReadFromCC1000Register(RegCounter));
    writeln("");
  }
  for(RegCounter=0x40;RegCounter<=0x46;RegCounter++) {
    writestr("Addr. ");
    writehex(RegCounter);
    writestr(" : ");
    writehex(ReadFromCC1000Register(RegCounter));
    writeln("");
  }
}

// Lets the user select the RF data rate
void SetRFDataRate(void)
{
  int i;
  char regvalue;
  char PLLvalue;
  
  
  writeln("Select data rate (in kbit/s):\n\r");
  writeln("0 - 0.3kbit/s Manchester");
  writeln("1 - 0.6kbit/s NRZ");
  writeln("2 - 0.6kbit/s Manchester");
  writeln("3 - 1.2kbit/s NRZ");
  writeln("4 - 1.2kbit/s Manchester");
  writeln("5 - 2.4kbit/s NRZ");
  writeln("6 - 2.4kbit/s Manchester");
  writeln("7 - 4.8kbit/s NRZ");
  writeln("8 - 4.8kbit/s Manchester");
  writeln("9 - 9.6kbit/s NRZ");
  writeln("A - 9.6kbit/s Manchester");
  writeln("B - 19.2kbit/s NRZ");
  writeln("C - 19.2kbit/s Manchester");
  writeln("D - 38.4kbit/s NRZ");
  writeln("E - 38.4kbit/s Manchester");
  writeln("F - 76.8kbit/s NRZ\n\r");
  writestr("Enter choice >");
  
  i=getchar();
  writeln("");
  
  switch(toupper(i)) {
    case '0' :
      regvalue=0x07;
      PLLvalue=0x25;
      break;
    case '1' :
      regvalue=0x03;
      PLLvalue=0x25;
      break;
    case '2' :
      regvalue=0x17;
      PLLvalue=0x25;
      break;
    case '3' :
      regvalue=0x13;
      PLLvalue=0x25;
      break;
    case '4' :
      regvalue=0x27;
      PLLvalue=0x25;
      break;
    case '5' :
      regvalue=0x23;
      PLLvalue=0x25;
      break;
    case '6' :
      regvalue=0x37;
      PLLvalue=0x25;
      break;
    case '7' :
      regvalue=0x33;
      PLLvalue=0x25;
      break;
    case '8' :
      regvalue=0x47;
      PLLvalue=0x3F;
      break;
    case '9' :
      regvalue=0x43;
      PLLvalue=0x3F;
      break;
    case 'A' :
      regvalue=0x57;
      PLLvalue=0x3F;
      break;
    case 'B' :
      regvalue=0x53;
      PLLvalue=0x3F;
      break;
    case 'C' :
      regvalue=0x55;
      PLLvalue=0x3F;
      break;
    case 'D' :
      regvalue=0x51;
      PLLvalue=0x3F;
      break;
    case 'E' :
      regvalue=0x54;
      PLLvalue=0x3F;
      break;
    case 'F' :
      regvalue=0x50;
      PLLvalue=0x3F;
      break;
  }
  WriteToCC1000Register(CC1000_MODEM0,regvalue);
  EEPROMModem0=regvalue;
  
  WriteToCC1000Register(CC1000_TEST4,PLLvalue);
  EEPROMTest4=PLLvalue;
}

// Lets the user select one of the default setups
void DefaultSettings(void)
{
  char i;
  
  
  writeln("Select default configuration:\n\r");
  writeln("4 - 433.30 MHz, +0dBm");
  writeln("8 - 869.85 MHz, +5dBm");
  writeln("9 - 905.00 MHz, +5dBm");
  writestr("Enter choice : ");
  
  i=getchar();
  writeln("");  
  
  switch (toupper(i)) {
    case '4' :
        for(i=0;i<33;i++) {
         EEPROMCC1000Config[i]=DefaultConfig433[i];
        }
        EEPROMTXCurrent=TX_CURRENT_433;
        EEPROMRXCurrent=RX_CURRENT_433;
        EEPROMTXPLL=DefaultTXPLL433;
        EEPROMRXPLL=DefaultRXPLL433;
        break;
    case '8' :
        for (i=0;i<33;i++) {
          EEPROMCC1000Config[i]=DefaultConfig868[i];
        }
        EEPROMTXCurrent=TX_CURRENT_868;
        EEPROMRXCurrent=RX_CURRENT_868;
        EEPROMTXPLL=DefaultTXPLL868;
        EEPROMRXPLL=DefaultRXPLL868;
        break;
    case '9' :
        for (i=0;i<33;i++) {
          EEPROMCC1000Config[i]=DefaultConfig905[i];
        }
        EEPROMTXCurrent=TX_CURRENT_868;
        EEPROMRXCurrent=RX_CURRENT_868;
        EEPROMTXPLL=DefaultTXPLL905;
        EEPROMRXPLL=DefaultRXPLL905;
        break;
  }
  
  

  SetupCC1000All();
  
  EEPROMButton1Char='Y';
  EEPROMButton2Char='Z';
  
  Button1Char=EEPROMButton1Char;
  Button2Char=EEPROMButton2Char;
  TXCurrent=EEPROMTXCurrent;
  RXCurrent=EEPROMRXCurrent;
  TXPLL=EEPROMTXPLL;
  RXPLL=EEPROMRXPLL;
  
  UnitAddress=0x01;
}

// Lets the user set up which characters are transmitted when the buttons are pressed
void ButtonConfig(void)
{
  
  
  writestr("Enter character to be sent when button 1 is pressed: ");
  EEPROMButton1Char=getchar();
  writeln("");
  writestr("\n\rEnter character to be sent when button 2 is pressed: ");
  EEPROMButton2Char=getchar();
  
  writeln("");
  
  Button1Char=EEPROMButton1Char;
  Button2Char=EEPROMButton2Char;
}  

// Lets the user configure the modem by loading in a configuration file from SmartRF Studio
void LoadSRFSConfig(void)
{
  char lineno;
  
  char address,value;
  char readval;
   
  
  writeln("Transfer configuration data from SmartRF Studio.");
  writeln("The data should be in EEP format (File|Print registers to file from Register view).");
  writeln("Send data now");
  
  for (lineno=0;lineno<0x24;lineno++){
    
    // Ignore leading whitespace
    do {
      readval=getchar();
    }
    while (!isxdigit(readval));
    
    address=hexdigit2int(readval)*0x10;
    address+=hexdigit2int(getchar());
    
    // Ignore all separators
    do {
      readval=getchar();
    }
    while (!isxdigit(readval));
    
    value=hexdigit2int(readval)*0x10;
    value+=hexdigit2int(getchar());
    
    // Address translation for SmartRF Studio 3.20, this will not be required
    // for future versions
    
    if ((address>=0x0A)&&(address<=0x21))
      address+=1;
    else if (address==0x22)
      address=0x0A;
    else if (address==0x23)
      address=0x1C;
    
    writehex(address-1);
    writestr(" : ");
    writehex(value);
    writeln("");
    if (address>0x00)
      EEPROMCC1000Config[address-1]=value;    
        
  }
  
  SetupCC1000All();
}
   
// Displays the configuration menu
void DisplayConfigMenu(void)
{
  writeln("RF Modem Configuration Menu\n\r");
  writeln("D - Dump CC1000 registers");
  writeln("E - Set RF data rate");
  writeln("F - Default settings");
  writeln("C - Calibrate");
  writeln("R - RX mode");
  writeln("T - TX mode");
  writeln("L - PLL lock");
  writeln("B - Button configuration");
  writeln("O - Load configuration data from SmartRF Studio");
  writeln("X - Exit from configuration menu");
}

// Handles keystrokes for the configuration menu
void HandleConfigMenu(char inputvalue)
{
  switch(toupper(inputvalue)) {
    case 'D' : 
      DumpCC1000Regs();
      break; 
    case 'E' :
      SetRFDataRate();
      break;
    case 'X' :
      break;
    case 'F' :
      DefaultSettings();
      break;
    case 'C' :
      if (CalibrateCC1000())
        writeln("Calibrate OK");
      else
        writeln("Calibrate failed");
      break;
    case 'R' :
      SetupCC1000RX(RXCurrent,RXPLL);
      OPTION=0xC0;        // INT on rising edge
      TRISC|=0x02;        // Set DIO as input
      break;
    case 'T' :
      SetupCC1000TX(TXCurrent,TXPLL);
      OPTION=0x80;        // INT on falling edge
      TRISC&=~(0x02);     // Set DIO as output
      break;      
    case 'L' :
      if (ReadFromCC1000Register(CC1000_LOCK)&0x01==1)
        writeln("PLL in lock");
      else
        writeln("PLL out of lock");
      break;
    case 'B' :
      ButtonConfig();
      break;
    case 'O' :
      LoadSRFSConfig();
      break;
    default:
      DisplayConfigMenu();
      break;
  }
}

// Runs the configuration menu
void ConfigurationMode(void)
{
  int i;
  
  DisplayConfigMenu();
 
  while(1) {
    writestr(">");
    i=getchar();
    writeln("");
    HandleConfigMenu(i);
    if (toupper(i)=='X') {
      SetupCC1000All(); 
      return;
    }
  }  
  
  
}