void rf_security_enable(uint8_t *key)
{
cc2420WriteReg(CC2420_SECCTRL0, 0x0306); // Enable CTR encryption with key 0
cc2420WriteReg(CC2420_SECCTRL1, 0x0e0e); // Encrypt / Decrypt 18 bytes into header
security_enable=1;
}
/**********************************************************
* set the radio into "normal" mode (buffered TXFIFO) and go into (data) receive */
void rf_data_mode() {
#ifdef RADIO_PRIORITY_CEILING
nrk_sem_pend(radio_sem);
#endif
cc2420Strobe(CC2420_SRFOFF); //stop radio
cc2420WriteReg(CC2420_MDMCTRL1, 0x0500); // default MDMCTRL1 value
cc2420WriteReg(CC2420_DACTST, 0); // default value
rf_flush_rx_fifo();
#ifdef RADIO_PRIORITY_CEILING
nrk_sem_post(radio_sem);
#endif
}
//-------------------------------------------------------------------------------------------------------
// void halRfSetChannel(UINT8 Channel)
//
// DESCRIPTION:
// Programs CC2420 for a given IEEE 802.15.4 channel.
// Note that SRXON, STXON or STXONCCA must be run for the new channel selection to take full effect.
//
// PARAMETERS:
// UINT8 channel
// The channel number (11-26)
//-------------------------------------------------------------------------------------------------------
void halRfSetChannel(uint8_t channel) {
uint16_t f;
/*
// Derive frequency programming from the given channel number
f = (uint16_t) (channel - 11); // Subtract the base channel
f = f + (f << 2); // Multiply with 5, which is the channel spacing
f = f + 357 + 0x4000; // 357 is 2405-2048, 0x4000 is LOCK_THR = 1
// Write it to the CC2420
DISABLE_GLOBAL_INT();
cc2420WriteReg(CC2420_FSCTRL, f);
ENABLE_GLOBAL_INT();
*/
f= cc2420ReadReg(CC2420_FSCTRL);
// Mask bit 0-9 to 0
f &= 0x3C00;
// Set bit 0-9
f |= 357 + ((channel - 11) * 5)+0x4000;
DISABLE_GLOBAL_INT();
cc2420WriteReg(CC2420_FSCTRL, f);
ENABLE_GLOBAL_INT();
} // rfSetChannel
void cc2420SetChannel(u08 channel)
{
u16 f;
// Derive frequency programming from the given channel number
f = (u16)(channel-11); // Subtract the base channel
f = f + (f << 2); // Multiply with 5, which is the channel spacing
f = f + 357 + 0x4000; // 357 is 2405-2048, 0x4000 is LOCK_THR = 1
// Write it to the CC2420
cc2420WriteReg(CC2420_FSCTRL, f);
}
void rf_test_mode()
{
#ifdef RADIO_PRIORITY_CEILING
nrk_sem_pend(radio_sem);
#endif
cc2420Strobe(CC2420_SRFOFF); //stop radio
// NOTE ON SETTING CC2420_MDMCTRL1
//
// RF studio" uses TX_MODE=3 (CC2420_MDMCTRL1=0x050C)
// to send an unmodulated carrier; data sheet says TX_MODE
// can be 2 or 3. So it should not matter...
// HOWEVER, using (TX_MODE=3) sometimes causes problems when
// going back to "data" mode!
cc2420WriteReg(CC2420_MDMCTRL1, 0x0508); // MDMCTRL1 with TX_MODE=2
cc2420WriteReg(CC2420_DACTST, 0x1800); // send unmodulated carrier
rf_flush_rx_fifo();
#ifdef RADIO_PRIORITY_CEILING
nrk_sem_post(radio_sem);
#endif
}
void rf_tx_power(uint8_t pwr)
{
uint16_t tmp;
//tmp=0x5070;
#ifdef RADIO_PRIORITY_CEILING
nrk_sem_pend (radio_sem);
#endif
tmp=0xA0E0;
tmp=tmp | (pwr&0x1F);
cc2420WriteReg(CC2420_TXCTRL, tmp); // Set the FIFOP threshold to maximum
#ifdef RADIO_PRIORITY_CEILING
nrk_sem_post(radio_sem);
#endif
}
void rf_set_cca_thresh(int8_t t)
{
// default is -32
// Higher number is less sensitive
uint16_t val;
#ifdef RADIO_PRIORITY_CEILING
nrk_sem_pend(radio_sem);
#endif
val=(t<<8) | 0x80;
cc2420WriteReg(CC2420_RSSI, val);
#ifdef RADIO_PRIORITY_CEILING
nrk_sem_post(radio_sem);
#endif
}
//-------------------------------------------------------------------------------------------------------
// void rf_init(RF_RX_INFO *pRRI, uint8_t channel, WORD panId, WORD myAddr)
//
// DESCRIPTION:
// Initializes CC2420 for radio communication via the basic RF library functions. Turns on the
// voltage regulator, resets the CC2420, turns on the crystal oscillator, writes all necessary
// registers and protocol addresses (for automatic address recognition). Note that the crystal
// oscillator will remain on (forever).
//
// ARGUMENTS:
// RF_RX_INFO *pRRI
// A pointer the RF_RX_INFO data structure to be used during the first packet reception.
// The structure can be switched upon packet reception.
// uint8_t channel
// The RF channel to be used (11 = 2405 MHz to 26 = 2480 MHz)
// WORD panId
// The personal area network identification number
// WORD myAddr
// The 16-bit short address which is used by this node. Must together with the PAN ID form a
// unique 32-bit identifier to avoid addressing conflicts. Normally, in a 802.15.4 network, the
// short address will be given to associated nodes by the PAN coordinator.
//-------------------------------------------------------------------------------------------------------
void rf_init(RF_RX_INFO *pRRI, uint8_t channel, uint16_t panId, uint16_t myAddr) {
uint8_t n;
uint16_t f;
uint8_t spiStatusByte;
#ifdef RADIO_PRIORITY_CEILING
int8_t v;
radio_sem = nrk_sem_create(1,RADIO_PRIORITY_CEILING);
if (radio_sem == NULL)
nrk_kernel_error_add (NRK_SEMAPHORE_CREATE_ERROR, nrk_get_pid ());
v = nrk_sem_pend (radio_sem);
if (v == NRK_ERROR) {
nrk_kprintf (PSTR ("CC2420 ERROR: Access to semaphore failed\r\n"));
}
#endif
// Make sure that the voltage regulator is on, and that the reset pin is inactive
SET_VREG_ACTIVE();
halWait(1000);
SET_RESET_ACTIVE();
halWait(1);
SET_RESET_INACTIVE();
halWait(100);
// Initialize the FIFOP external interrupt
//FIFOP_INT_INIT();
//ENABLE_FIFOP_INT();
// Turn off all interrupts while we're accessing the CC2420 registers
DISABLE_GLOBAL_INT();
// Register modifications
cc2420Strobe(CC2420_SXOSCOFF);
cc2420Strobe(CC2420_SXOSCON);
mdmctrl0=0x02E2;
cc2420WriteReg(CC2420_MDMCTRL0, mdmctrl0); // Std Preamble, CRC, no auto ack, no hw addr decoding
//FASTSPI_SETREG(CC2420_MDMCTRL0, 0x0AF2); // Turn on automatic packet acknowledgment
// Turn on hw addre decoding
cc2420WriteReg(CC2420_MDMCTRL1, 0x0500); // Set the correlation threshold = 20
cc2420WriteReg(CC2420_IOCFG0, 0x007F); // Set the FIFOP threshold to maximum
cc2420WriteReg(CC2420_SECCTRL0, 0x01C4); // Turn off "Security"
cc2420WriteReg(CC2420_RXCTRL1, 0x1A56); // All default except
// reference bias current to RX
// bandpass filter is set to 3uA
/*
// FIXME: remove later for auto ack
myAddr=MY_MAC;
panId=0x02;
FASTSPI_SETREG(CC2420_MDMCTRL0, 0x0AF2); // Turn on automatic packet acknowledgment
// FASTSPI_SETREG(CC2420_MDMCTRL0, 0x0AE2); // Turn on automatic packet acknowledgment
nrk_spin_wait_us(500);
nrk_spin_wait_us(500);
FASTSPI_WRITE_RAM_LE(&myAddr, CC2420RAM_SHORTADDR, 2, n);
nrk_spin_wait_us(500);
FASTSPI_WRITE_RAM_LE(&panId, CC2420RAM_PANID, 2, n);
nrk_spin_wait_us(500);
printf( "myAddr=%d\r\n",myAddr );
*/
nrk_spin_wait_us(500);
cc2420WriteRamLE((uint8 *)&panId, CC2420RAM_PANID, 2);
nrk_spin_wait_us(500);
ENABLE_GLOBAL_INT();
// Set the RF channel
//halRfSetChannel(channel);
f= cc2420ReadReg(CC2420_FSCTRL);
// Mask bit 0-9 to 0
f &= 0x3C00;
// Set bit 0-9
f |= 357 + ((channel - 11) * 5)+0x4000;
DISABLE_GLOBAL_INT();
cc2420WriteReg(CC2420_FSCTRL, f);
ENABLE_GLOBAL_INT();
// Turn interrupts back on
ENABLE_GLOBAL_INT();
// Set the protocol configuration
rfSettings.pRxInfo = pRRI;
rfSettings.panId = panId;
rfSettings.myAddr = myAddr;
rfSettings.txSeqNumber = 0;
rfSettings.receiveOn = FALSE;
// Wait for the crystal oscillator to become stable
//halRfWaitForCrystalOscillator();
// Poll the SPI status byte until the crystal oscillator is stable
do {
DISABLE_GLOBAL_INT();
spiStatusByte=cc2420GetStatus();
ENABLE_GLOBAL_INT();
} while (!(spiStatusByte & (BM(CC2420_XOSC16M_STABLE))));
// Write the short address and the PAN ID to the CC2420 RAM (requires that the XOSC is on and stable)
// DISABLE_GLOBAL_INT();
// FASTSPI_WRITE_RAM_LE(&myAddr, CC2420RAM_SHORTADDR, 2, n);
// FASTSPI_WRITE_RAM_LE(&panId, CC2420RAM_PANID, 2, n);
// ENABLE_GLOBAL_INT();
#ifdef RADIO_PRIORITY_CEILING
v = nrk_sem_post (radio_sem);
if (v == NRK_ERROR) {
nrk_kprintf (PSTR ("CC2420 ERROR: Release of semaphore failed\r\n"));
_nrk_errno_set (2);
}
#endif
auto_ack_enable=0;
security_enable=0;
last_pkt_encrypted=0;
} // rf_init()
void rf_auto_ack_disable()
{
auto_ack_enable=0;
mdmctrl0 &= (~0x0010);
cc2420WriteReg(CC2420_MDMCTRL0, mdmctrl0);
}
void rf_auto_ack_enable()
{
auto_ack_enable=1;
mdmctrl0 |= 0x0010;
cc2420WriteReg(CC2420_MDMCTRL0, mdmctrl0);
}
void rf_addr_decode_disable()
{
mdmctrl0 &= (~0x0800);
cc2420WriteReg(CC2420_MDMCTRL0, mdmctrl0);
}
void rf_addr_decode_enable()
{
mdmctrl0 |= 0x0800;
cc2420WriteReg(CC2420_MDMCTRL0, mdmctrl0);
}
void rf_security_disable()
{
cc2420WriteReg(CC2420_SECCTRL0, 0x01C4); // Turn off "Security enable"
security_enable=0;
}
/**********************************************************
* Put the radio in serial TX mode, where data is sampled from the FIFO
* pin to send after SFD, and timing is done using FIFOP
* use rf_carrier_on() to start, set FIFO to first bit, then wait for it
* to go up and down, then set next bit etc.
* NOTE: You must set the FIFO pin to output mode in order to do this!
* This can be undone by calling rf_data_mode()
*/
void rf_tx_set_serial()
{
cc2420WriteReg(CC2420_MDMCTRL1, 0x0504); // set TXMODE to 1
rf_flush_rx_fifo();
}
/**********************************************************
* Set the radio into serial unbuffered RX mode
* RX data is received through sampling the FIFO pin, timing is done using FIFOP
* Use rf_rx_on() to start rcv, then wait for SFD / FIFOP. Sample during each high edge of FIFOP
* This can be undone by using rf_data_mode()
*/
void rf_rx_set_serial()
{
cc2420Strobe(CC2420_SRFOFF); // stop radio
cc2420WriteReg(CC2420_MDMCTRL1, 0x0501); // Set RX_MODE to 1
rf_flush_rx_fifo();
}
