示例#1
0
void RF_init()
{
  
  TI_CC_SPISetup();                         // Initialize SPI port
  TI_CC_PowerupResetCCxxxx();               // Reset CCxxxx
  writeRFSettings();                        // Write RF settings to config reg
  
  TI_CC_SPIWriteBurstReg(TI_CCxxx0_PATABLE, paTable, paTableLen);//Write PATABLE
  //TI_CC_SPIStrobe(TI_CCxxx0_SIDLE); // set IDLE
  TI_CC_SPIWriteReg (TI_CCxxx0_PATABLE,paTable[0]); // init at max powerlevel

  // Configure ports -- switch inputs, LEDs, GDO0 to RX packet info from CCxxxx
  
  TI_CC_SW_PxREN |= TI_CC_SW1;               // Enable Pull up resistor
  TI_CC_SW_PxOUT |= TI_CC_SW1;               // Enable pull up resistor
  TI_CC_SW_PxIES |= TI_CC_SW1;               // Int on falling edge
  TI_CC_SW_PxIFG &= ~(TI_CC_SW1);            // Clr flags
  TI_CC_SW_PxIE |= TI_CC_SW1;                // Activate interrupt enables
  
  TI_CC_GDO0_PxIES |= TI_CC_GDO0_PIN;       // Int on falling edge (end of pkt)
  TI_CC_GDO0_PxIFG &= ~TI_CC_GDO0_PIN;      // Clear flag
  TI_CC_GDO0_PxIE |= TI_CC_GDO0_PIN;        // Enable int on end of packet

  TI_CC_SPIStrobe(TI_CCxxx0_SRX);           // Initialize CCxxxx in RX mode.
                                            // When a pkt is received, it will
                                            // signal on GDO0 and wake CPU

}
void main (void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT

  TI_CC_SPISetup();                         // Initialize SPI port

  TI_CC_PowerupResetCCxxxx();               // Reset CCxxxx
  writeRFSettings();                        // Write RF settings to config reg
  TI_CC_SPIWriteBurstReg(TI_CCxxx0_PATABLE, paTable, paTableLen);//Write PATABLE

  // Configure ports -- switch inputs, LEDs, GDO0 to RX packet info from CCxxxx
  TI_CC_SW_PxREN |= TI_CC_SW1+TI_CC_SW2;    // Enable pull-up resistor
  TI_CC_SW_PxOUT |= TI_CC_SW1+TI_CC_SW2;    // Enable pull-up resistor
  TI_CC_SW_PxIES = TI_CC_SW1+TI_CC_SW2;     // Int on falling edge
  TI_CC_SW_PxIFG &= ~(TI_CC_SW1+TI_CC_SW2); // Clr flags
  TI_CC_SW_PxIE = TI_CC_SW1+TI_CC_SW2;      // Activate interrupt enables
  TI_CC_LED_PxOUT &= ~(TI_CC_LED1 + TI_CC_LED2); // Outputs = 0
  TI_CC_LED_PxDIR |= TI_CC_LED1 + TI_CC_LED2;// LED Direction to Outputs

  TI_CC_GDO0_PxIES |= TI_CC_GDO0_PIN;       // Int on falling edge (end of pkt)
  TI_CC_GDO0_PxIFG &= ~TI_CC_GDO0_PIN;      // Clear flag
  TI_CC_GDO0_PxIE |= TI_CC_GDO0_PIN;        // Enable int on end of packet

  TI_CC_SPIStrobe(TI_CCxxx0_SRX);           // Initialize CCxxxx in RX mode.
                                            // When a pkt is received, it will
                                            // signal on GDO0 and wake CPU

  __bis_SR_register(LPM3_bits + GIE);       // Enter LPM3, enable interrupts
}
示例#3
0
int main(void) {
    WDTCTL = WDTPW | WDTHOLD;	// Stop watchdog timer

    //P2REN |= BIT3; // enable pull up resistor on p2.3
    //P2OUT |= BIT3; // This does not seem to be working as expected.

    // Initialize radio and SPI
    TI_CC_SPISetup();                         // Initialize SPI port
	TI_CC_PowerupResetCCxxxx();               // Reset CCxxxx
	writeRFSettings();                        // Write RF settings to config reg
	TI_CC_SPIWriteBurstReg(TI_CCxxx0_PATABLE, paTable, paTableLen);//Write PATABLE
	// Enable interrupts from radio module
	TI_CC_GDO0_PxIES |= TI_CC_GDO0_PIN;       // Int on falling edge (end of pkt)
	TI_CC_GDO0_PxIFG &= ~TI_CC_GDO0_PIN;      // Clear flag
	TI_CC_GDO0_PxIE |= TI_CC_GDO0_PIN;        // Enable int on end of packet
	// Enable radio
	TI_CC_SPIStrobe(TI_CCxxx0_SRX);           // Initialize CCxxxx in RX mode.

    // configure packet
    // --------------------------------------------
	txBuffer[0] = MSGLEN-1;                        // Packet length
	txBuffer[1] = 0x01;                     // Packet address - If this is 0xFF, it's an ack and not data.
	// Begin data
	// --------------------------------------------
	txBuffer[2] = VALID_LEVEL; // default flag is valid. This is set on request from other module.
	txBuffer[3] = 0x30;
	txBuffer[4] = 0x31;
	txBuffer[5] = 0x34;
	txBuffer[6] = 0x35;
	txBuffer[7] = 0x36;
	txBuffer[8] = 0x37;
	txBuffer[9] = 0x38;
	txBuffer[10] = 0x39;		// the rest of this data is used as filler.
	// ------
	// End Data
	txBuffer[11] = 0x00;					// terimate
	// --------------------------------------------

	_BIS_SR(GIE); // turn on interrupts. Initialization must be complete by this point
    while(1) {
    	if(water_level_request) {
    		// Ideally, P2.3 should be pulled high. This is causing strange behavior
    		// 		on the pin that should be investigated.
    		// Check the status of P2.3 and set the r
    		txBuffer[WATER_DATA_TX_INDEX] = (P2IN & BIT3) ? 0 : VALID_LEVEL;// turn on the pump if the water level is valid.
    		RFSendPacket(txBuffer, MSGLEN);		// Send water level data back to controller
    		__delay_cycles(450000); 			// delay a few cycles. Note that this means requests that take place during
    											// a pump cycle will be ignored completely.
    		water_level_request = 0; // clear requested data flag
      	}
    }
}
示例#4
0
void RadioInit(void) {
    TI_CC_SPISetup();      		// Initialize SPI port del PIC
    TI_CC_PowerupResetCCxxxx(); // Reset CCxxxx
    IoWait(200);
    WriteRFSettings();                        // Write RF settings to config reg
    TI_CC_SPIWriteBurstReg(TI_CCxxx0_PATABLE, paTable, paTableLen);//Write PATABLE
    ModeRecepcio();
    // Capturo l'adreça local i l'adreça del control remot des de l'eeprom.
    EEGetShortMAC(LocalAddress);
#ifdef _DEPURANT_RADIO
    RemoteAddress[0] = AdressaRemotaFalsa[0];
    RemoteAddress[1] = AdressaRemotaFalsa[1];
    RemoteAddress[2] = AdressaRemotaFalsa[2];
#else
    EERead(EE_MAC_REMOT,RemoteAddress, 	RF_LEN_ADDRESS);
    // Versió 0.2
    if ((RemoteAddress[0] == 0xFF) && (RemoteAddress[1] == 0xff)) ModeLite = 1;
    else ModeLite = 0;
#endif
}
void main (void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT

  // 5ms delay to compensate for time to startup between MSP430 and CC1100/2500
  __delay_cycles(5000);
  
  TI_CC_SPISetup();                         // Initialize SPI port

  DCOCTL = 0;                               // Select lowest DCOx and MODx settings
  BCSCTL1 = CALBC1_1MHZ;                    // Set DCO
  DCOCTL = CALDCO_1MHZ;

  P2SEL = 0;                                // Sets P2.6 & P2.7 as GPIO
  TI_CC_PowerupResetCCxxxx();               // Reset CCxxxx
  writeRFSettings();                        // Write RF settings to config reg
  TI_CC_SPIWriteBurstReg(TI_CCxxx0_PATABLE, paTable, paTableLen);//Write PATABLE

  // Configure ports -- switch inputs, LEDs, GDO0 to RX packet info from CCxxxx
  COM_Init();
  TI_CC_SW_PxREN = TI_CC_SW1;               // Enable Pull up resistor
  TI_CC_SW_PxOUT = TI_CC_SW1;               // Enable pull up resistor
  TI_CC_SW_PxIES = TI_CC_SW1;               // Int on falling edge
  TI_CC_SW_PxIFG &= ~(TI_CC_SW1);           // Clr flags
  TI_CC_SW_PxIE = TI_CC_SW1;                // Activate interrupt enables
  TI_CC_LED_PxOUT &= ~(TI_CC_LED1 + TI_CC_LED2); // Outputs = 0
  TI_CC_LED_PxDIR |= TI_CC_LED1 + TI_CC_LED2;// LED Direction to Outputs

  TI_CC_GDO0_PxIES |= TI_CC_GDO0_PIN;       // Int on falling edge (end of pkt)
  TI_CC_GDO0_PxIFG &= ~TI_CC_GDO0_PIN;      // Clear flag
  TI_CC_GDO0_PxIE |= TI_CC_GDO0_PIN;        // Enable int on end of packet

  TI_CC_SPIStrobe(TI_CCxxx0_SRX);           // Initialize CCxxxx in RX mode.
                                            // When a pkt is received, it will
                                            // signal on GDO0 and wake CPU
  __bis_SR_register(LPM0_bits + GIE);       // Enter LPM3, enable interrupts
}
int main(void) {
    WDTCTL = WDTPW | WDTHOLD;	// Stop watchdog timer
    P2DIR |= BIT3 | BIT4; 		// output to BLDC and LED
    P2OUT &= ~BIT3; 			// make sure pump is off
    P2OUT &= ~BIT4; 			//make sure LED is off

    // Port 1 pushbutton config
    P1REN |= TI_CC_SW1; 		// enable pullup/down on switch1
    P1OUT |= TI_CC_SW1; 		// configure PUR as pull down (active low)
    P1IES |= TI_CC_SW1; 		// interrupt on falling edge
    P1IFG = 0; // clear all interurpt flags
    P1IE = TI_CC_SW1; // enable interrupts on pushbutton

    // Initialize radio and SPI - This code is derived from TI radio drivers
    TI_CC_SPISetup();                         // Initialize SPI port
	TI_CC_PowerupResetCCxxxx();               // Reset CCxxxx
	writeRFSettings();                        // Write RF settings to config reg
	TI_CC_SPIWriteBurstReg(TI_CCxxx0_PATABLE, paTable, paTableLen);//Write PATABLE
	// Enable interrupts from radio module
	P2IES |= TI_CC_GDO0_PIN;       // Int on falling edge (end of pkt)
	P2IFG &= ~TI_CC_GDO0_PIN;      // Clear flag
	P2IE |= TI_CC_GDO0_PIN;        // Enable int on end of packet
	// Enable radio
	TI_CC_SPIStrobe(TI_CCxxx0_SRX);           // Initialize CCxxxx in RX mode.

    // configure packet
    // --------------------------------------------
	txBuffer[0] = MSGLEN-1;                        // Packet length -- this will get trimmed off.
	txBuffer[1] = 0x01;                     // Packet address - If this is 0xFF, it's an ack and not data.
	// Begin data
	// --------------------------------------------
	txBuffer[2] = OPERATE_SENSOR; 	// flag for other node to know that it needs to read switch state.
	txBuffer[3] = 0x30; 			// Filler data to be used later on
	txBuffer[4] = 0x31;
	txBuffer[5] = 0x34;
	txBuffer[6] = 0x35;
	txBuffer[7] = 0x36;
	txBuffer[8] = 0x37;
	txBuffer[9] = 0x38;
	txBuffer[10] = 0x39;		// the rest of this data isn't used in ths project
	// Extra data could be used in the event that more controller nodes are added
	// ------
	// End Data
	txBuffer[11] = 0x00;					// terimate
	// --------------------------------------------

	_BIS_SR(GIE); // turn on interrupts. Initialization is now complete.
    while(1) {
    	if(buttonPressed) { 		// buttonPressed is a user interrupt flag
    		P1IE &= ~TI_CC_SW1; 	// disable user interrupts to avoid conflicting pump cycles
    		if (WaterLevelValid()) { // WaterLevelValid() will retrieve water level status from the other node
    			P2OUT |= BIT3; // turn on pump
    			__delay_cycles(1000000); // delay for a second while pump runs
    			P2OUT &= ~BIT3; // turn off pump
    			P2OUT &= ~BIT4; // turn off LED
    		}
    		buttonPressed = 0; 	// clear flag
    		P1IE = TI_CC_SW1; 	// Enable user interrupts (accept a new pump cycle)
    	}
    }
}
示例#7
0
//This function configures the SPI interface
//to the CC1101, resets the device and
//sets the scanning parameters
//GETS: Pointer to the scan parameters
//and the pointer to the structure
//where the Rssi values will be stored
//RETURNS: NULL if something went wrong
//or pointer to the SCAN_CONFIG structure
//with the parameters actually used by the function
SCAN_CONFIG * configScanner(SCAN_CONFIG * pconfigParameters, BYTE * rssiArray) {
	BYTE reg;

	//Store the array pointer, if it's NULL report failure
	if(rssiArray==NULL)
		return NULL;
	rssiTable = rssiArray;
	//Configure the SPI interface
	TI_CC_SPISetup();
	//Reset the CC1101
	TI_CC_PowerupResetCCxxxx();

	//If pconfigParameters is NULL, use defaults
	if(pconfigParameters==NULL){
		pconfigParameters=&scanParameters;
		scanParameters.startFreqMhz=MIN_FREQ;
		scanParameters.startFreqKhz=0;
		scanParameters.stopFreqMhz=MAX_FREQ;
		//scanParameters.stopFreqMhz=820;
		scanParameters.stopFreqKhz=0;
		scanParameters.freqResolution=DEFAULT_RESOLUTION;
		scanParameters.modFormat=TI_CCxxx0_MDMCFG2_MODFORMAT_ASK;
		scanParameters.rssiWait=AVG_WAIT_WITH_AGC;
		scanParameters.activateAGC=TRUE;
	}

	/**Start parsing parameters**/

	//Parsing startFreq
	if (pconfigParameters->startFreqMhz < MIN_FREQ
			|| pconfigParameters->startFreqMhz > MAX_FREQ) {
		//Use default value: MIN_FREQ
		scanParameters.startFreqMhz = MIN_FREQ;
		scanParameters.startFreqKhz = 0;
	} else {
		scanParameters.startFreqMhz = pconfigParameters->startFreqMhz;
		if (pconfigParameters->startFreqKhz>= 1000
				|| pconfigParameters->startFreqMhz==MAX_FREQ) {
			//Use default value: 0
			scanParameters.startFreqKhz = 0;
		} else{
			scanParameters.startFreqKhz = pconfigParameters->startFreqKhz;
		}
	}

		//Parsing stopFreq
	if (pconfigParameters->stopFreqMhz < MIN_FREQ
			|| pconfigParameters->stopFreqMhz > MAX_FREQ) {
		//Use default value: MAX_FREQ
		scanParameters.stopFreqMhz = MAX_FREQ;
		scanParameters.stopFreqKhz = 0;
	} else {
		scanParameters.stopFreqMhz = pconfigParameters->stopFreqMhz;
		if (pconfigParameters->stopFreqKhz>= 1000
				|| pconfigParameters->stopFreqMhz==MAX_FREQ) {
			//Use default value: 0
			scanParameters.stopFreqKhz = 0;
		} else{
			scanParameters.stopFreqKhz = pconfigParameters->stopFreqKhz;
		}
	}
		//Check if the range limits make sense
	if (scanParameters.startFreqMhz > scanParameters.stopFreqMhz)
		return NULL;
	if (scanParameters.startFreqMhz == scanParameters.stopFreqMhz
			&& scanParameters.startFreqKhz > scanParameters.stopFreqKhz)
		return NULL;
	if (scanParameters.startFreqMhz == MAX_FREQ
			&& scanParameters.startFreqKhz > 0)
		return NULL;

	//Parsing filterBandwidth
	if(pconfigParameters->freqResolution<filterBandwidthList[0][0] ||
			pconfigParameters->freqResolution>filterBandwidthList[3][3])
		scanParameters.freqResolution=DEFAULT_RESOLUTION;

	//Find the valid filter value closest to the one requested
	UINT16 diff, tempDiff;
	BYTE i, j, row, column;
	for (i = 0; i < sizeof(filterBandwidthList); i++) {
		for (j = 0; j < sizeof(*filterBandwidthList); j++) {
			if(filterBandwidthList[i][j] > pconfigParameters->freqResolution)
				tempDiff=filterBandwidthList[i][j] - pconfigParameters->freqResolution;
			else
				tempDiff=pconfigParameters->freqResolution - filterBandwidthList[i][j];
			if (i == 0 && j==0)
				diff = tempDiff;
			if (tempDiff <= diff) {
				diff = tempDiff;
				row = i;
				column = j;
			}
			if (diff == 0)
				break;
		}
		if (diff == 0)
			break;
	}
	scanParameters.freqResolution = filterBandwidthList[row][column];
	//Set the channel filter bandwidth
	reg = TI_CC_SPIReadReg(TI_CCxxx0_MDMCFG4);
	reg &= ~(TI_CCxxx0_MDMCFG4_CHANBW_E + TI_CCxxx0_MDMCFG4_CHANBW_M);
	reg |= (chanBwE[row][column] << 4) + (chanBwM[row][column] << 6);
	TI_CC_SPIWriteReg(TI_CCxxx0_MDMCFG4, reg);
	//Initialize the variables related to the frequency registers REG2:REG1:REG0
	//Formula: f_carrier=(f_xosc/2^16)*FREQ[23:0]
	//TODO: To optimize, consider using Horner division code from SLAA329
	//Link: http://www.ti.com/mcu/docs/litabsmultiplefilelist.tsp?sectionId=96&tabId=1502&literatureNumber=slaa329&docCategoryId=1&familyId=4
	freqRegsBase=(((UINT32)scanParameters.startFreqMhz)<<16)/fXoscMhz;
	freqRegsBase+=(((UINT32)scanParameters.startFreqKhz)<<16)/(fXoscMhz*1000);
	freqRegsStep=(((UINT32)scanParameters.freqResolution)<<16)/(fXoscMhz*1000);


	//Set the channel spacing
//	reg = TI_CC_SPIReadReg(TI_CCxxx0_MDMCFG1);
//	reg &= ~TI_CCxxx0_MDMCFG1_CHANSPC_E_MASK;
//	reg |= chanSpcE[row][column];
//	TI_CC_SPIWriteReg(TI_CCxxx0_MDMCFG1, reg);
//	TI_CC_SPIWriteReg(TI_CCxxx0_MDMCFG0, chanSpcM[row][column]);
	//Set the number of channels per Mhz
	//Parsing the modulation format
	//If it's a wrong or invalid value, use the first valid modulation format
	if (pconfigParameters->modFormat < sizeof(validModFormats)
			&& validModFormats[pconfigParameters->modFormat])
		scanParameters.modFormat = pconfigParameters->modFormat;
	else {
		for (i = 0; i < sizeof(validModFormats) && !validModFormats[i]; i++)
			;
		scanParameters.modFormat = i;
	}
	//Set the modulation for the current scan
	reg = TI_CC_SPIReadReg(TI_CCxxx0_MDMCFG2);
	reg &= ~TI_CCxxx0_MDMCFG2_MODFORMAT_MASK;
	reg |= modFormatMDMCFG2[scanParameters.modFormat];
	TI_CC_SPIWriteReg(TI_CCxxx0_MDMCFG2, reg);

	//Parse AGC options
	//If the AGC is disabled, we manually set
	//all the gain stages, otherwise we ignore
	//those fields
	if(pconfigParameters->activateAGC){
		scanParameters.activateAGC = TRUE;
		//Parse rssiWait
		if(pconfigParameters->rssiWait<MIN_WAIT_WITH_AGC || pconfigParameters->rssiWait>MAX_WAIT_WITH_AGC){
			//Use default: AVG_WAIT_WITHOUT_AGC
			scanParameters.rssiWait=AVG_WAIT_WITH_AGC;
		}
		else{
			scanParameters.rssiWait=pconfigParameters->rssiWait;
		}
	}
	else{
		scanParameters.activateAGC = FALSE;
		//Freeze the AGC
		reg = TI_CC_SPIReadReg(TI_CCxxx0_AGCCTRL0);
		reg &= ~TI_CCxxx0_AGCCTRL0_AGCFREEZE_MASK;
		reg |= TI_CCxxx0_AGCCTRL0_AGCFREEZE_ALL;
		TI_CC_SPIWriteReg(TI_CCxxx0_AGCCTRL0, reg);
		//Parse static gain options
		if (pconfigParameters->agcLnaGain < LNA_MIN_GAIN
				&& pconfigParameters->agcLnaGain > LNA_MAX_GAIN)
			scanParameters.agcLnaGain = pconfigParameters->agcLnaGain;
		else
			scanParameters.agcLnaGain = LNA_MAX_GAIN;
		if (pconfigParameters->agcLna2Gain > LNA2_MIN_GAIN
				&& pconfigParameters->agcLna2Gain < LNA2_MAX_GAIN)
			scanParameters.agcLna2Gain = pconfigParameters->agcLna2Gain;
		else
			scanParameters.agcLna2Gain = LNA2_MAX_GAIN;
		if (pconfigParameters->agcDvgaGain > DVGA_MIN_GAIN
				&& pconfigParameters->agcDvgaGain < DVGA_MAX_GAIN)
			scanParameters.agcDvgaGain = pconfigParameters->agcDvgaGain;
		else
			scanParameters.agcDvgaGain = DVGA_MAX_GAIN;
		//Set static gain value
		reg = scanParameters.agcDvgaGain | (scanParameters.agcLna2Gain << 3)
				| (scanParameters.agcLna2Gain << 6);
		TI_CC_SPIWriteReg(TI_CCxxx0_AGCTEST, reg);

		//Parse rssiWait
		if(pconfigParameters->rssiWait<MIN_WAIT_WITHOUT_AGC || pconfigParameters->rssiWait>MAX_WAIT_WITHOUT_AGC){
			//Use default: AVG_WAIT_WITH_AGC
			scanParameters.rssiWait=AVG_WAIT_WITH_AGC;
		}
		else{
			scanParameters.rssiWait=pconfigParameters->rssiWait;
		}
	}
	/**Finished parsing parameters**/

	//Everything OK, return pointer to the parameter structure
	return &scanParameters;
}