[Tinyos-2-commits] CVS: tinyos-2.x/tos/lib/net/zigbee/cc2420
AddressFilter.nc, NONE, 1.1 CC2420ControlC.nc, NONE,
1.1 CC2420ControlP.nc, NONE, 1.1 CC2420ReceiveC.nc, NONE,
1.1 CC2420ReceiveP.nc, NONE, 1.1 CC2420SpiP.nc, NONE,
1.1 CC2420TransmitC.nc, NONE, 1.1 CC2420TransmitP.nc, NONE,
1.1 Receiveframe.nc, NONE, 1.1 Sendframe.nc, NONE,
1.1 readme.txt, NONE, 1.1
André Cunha
a_cunha at users.sourceforge.net
Mon Feb 11 09:41:28 PST 2008
Update of /cvsroot/tinyos/tinyos-2.x/tos/lib/net/zigbee/cc2420
In directory sc8-pr-cvs10.sourceforge.net:/tmp/cvs-serv25859/cc2420
Added Files:
AddressFilter.nc CC2420ControlC.nc CC2420ControlP.nc
CC2420ReceiveC.nc CC2420ReceiveP.nc CC2420SpiP.nc
CC2420TransmitC.nc CC2420TransmitP.nc Receiveframe.nc
Sendframe.nc readme.txt
Log Message:
--- NEW FILE: AddressFilter.nc ---
/**
*
* @author André Cunha
* @version 1.0
*/
interface AddressFilter {
command error_t set_address(uint16_t mac_short_address, uint32_t mac_extended0, uint32_t mac_extended1);
command error_t set_coord_address(uint16_t mac_coord_address, uint16_t mac_panid);
command error_t enable_address_decode(uint8_t enable);
}
--- NEW FILE: CC2420ControlC.nc ---
/*
* Copyright (c) 2005-2006 Arch Rock Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* - Neither the name of the Arch Rock Corporation nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* ARCHED ROCK OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE
*/
/**
* Implementation for configuring a ChipCon CC2420 radio.
*
* @author Jonathan Hui <jhui at archrock.com>
* @version $Revision: 1.1 $ $Date: 2008/02/11 17:41:25 $
*/
#include "CC2420.h"
#include "IEEE802154.h"
configuration CC2420ControlC {
provides interface Resource;
provides interface CC2420Config;
provides interface CC2420Power;
provides interface Read<uint16_t> as ReadRssi;
// provides interface Read_rssi;
}
implementation {
components CC2420ControlP;
Resource = CC2420ControlP;
CC2420Config = CC2420ControlP;
CC2420Power = CC2420ControlP;
ReadRssi = CC2420ControlP;
//Read_rssi = CC2420ControlP;
components MainC;
MainC.SoftwareInit -> CC2420ControlP;
//components CC2420ActiveMessageC;
//CC2420ControlP.AMPacket -> CC2420ActiveMessageC;
components AlarmMultiplexC as Alarm;
CC2420ControlP.StartupTimer -> Alarm;
components HplCC2420PinsC as Pins;
CC2420ControlP.CSN -> Pins.CSN;
CC2420ControlP.RSTN -> Pins.RSTN;
CC2420ControlP.VREN -> Pins.VREN;
components HplCC2420InterruptsC as Interrupts;
CC2420ControlP.InterruptCCA -> Interrupts.InterruptCCA;
components new CC2420SpiC() as Spi;
CC2420ControlP.SpiResource -> Spi;
CC2420ControlP.SRXON -> Spi.SRXON;
CC2420ControlP.SRFOFF -> Spi.SRFOFF;
CC2420ControlP.SXOSCON -> Spi.SXOSCON;
CC2420ControlP.SXOSCOFF -> Spi.SXOSCOFF;
CC2420ControlP.FSCTRL -> Spi.FSCTRL;
CC2420ControlP.IOCFG0 -> Spi.IOCFG0;
CC2420ControlP.IOCFG1 -> Spi.IOCFG1;
CC2420ControlP.MDMCTRL0 -> Spi.MDMCTRL0;
CC2420ControlP.MDMCTRL1 -> Spi.MDMCTRL1;
CC2420ControlP.PANID -> Spi.PANID;
CC2420ControlP.RXCTRL1 -> Spi.RXCTRL1;
CC2420ControlP.RSSI -> Spi.RSSI;
components new CC2420SpiC() as SyncSpiC;
CC2420ControlP.SyncResource -> SyncSpiC;
components new CC2420SpiC() as RssiResource;
CC2420ControlP.RssiResource -> RssiResource;
//components ActiveMessageAddressC;
//CC2420ControlP.ActiveMessageAddress -> ActiveMessageAddressC;
}
--- NEW FILE: CC2420ControlP.nc ---
/*
* Copyright (c) 2005-2006 Arch Rock Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* - Neither the name of the Arch Rock Corporation nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* ARCHED ROCK OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE
*/
/**
* @author Jonathan Hui <jhui at archrock.com>
* @author David Moss
* @author Urs Hunkeler (ReadRssi implementation)
* @version $Revision: 1.1 $ $Date: 2008/02/11 17:41:25 $
*/
#include "Timer.h"
module CC2420ControlP {
provides interface Init;
provides interface Resource;
provides interface CC2420Config;
provides interface CC2420Power;
provides interface Read<uint16_t> as ReadRssi;
// provides interface Read_rssi;
uses interface Alarm<T32khz,uint32_t> as StartupTimer;
uses interface GeneralIO as CSN;
uses interface GeneralIO as RSTN;
uses interface GeneralIO as VREN;
uses interface GpioInterrupt as InterruptCCA;
//uses interface ActiveMessageAddress;
uses interface CC2420Ram as PANID;
uses interface CC2420Register as FSCTRL;
uses interface CC2420Register as IOCFG0;
uses interface CC2420Register as IOCFG1;
uses interface CC2420Register as MDMCTRL0;
uses interface CC2420Register as MDMCTRL1;
uses interface CC2420Register as RXCTRL1;
uses interface CC2420Register as RSSI;
uses interface CC2420Strobe as SRXON;
uses interface CC2420Strobe as SRFOFF;
uses interface CC2420Strobe as SXOSCOFF;
uses interface CC2420Strobe as SXOSCON;
// uses interface AMPacket;
uses interface Resource as SpiResource;
uses interface Resource as RssiResource;
uses interface Resource as SyncResource;
uses interface Leds;
}
implementation {
typedef enum {
S_VREG_STOPPED,
S_VREG_STARTING,
S_VREG_STARTED,
S_XOSC_STARTING,
S_XOSC_STARTED,
} cc2420_control_state_t;
uint8_t m_channel;
uint8_t m_tx_power;
uint16_t m_pan;
uint16_t m_short_addr;
bool m_sync_busy;
bool autoAckEnabled;
bool hwAutoAckDefault;
bool addressRecognition;
norace cc2420_control_state_t m_state = S_VREG_STOPPED;
/***************** Prototypes ****************/
void writeFsctrl();
void writeMdmctrl0();
void writeId();
task void sync();
task void syncDone();
/***************** Init Commands ****************/
command error_t Init.init() {
call CSN.makeOutput();
call RSTN.makeOutput();
call VREN.makeOutput();
//m_short_addr = call ActiveMessageAddress.amAddress();
// m_pan = call ActiveMessageAddress.amGroup();
m_tx_power = CC2420_DEF_RFPOWER;
//m_channel = CC2420_DEF_CHANNEL;
m_channel = LOGICAL_CHANNEL;
//#if defined(CC2420_NO_ACKNOWLEDGEMENTS)
autoAckEnabled = FALSE;
//#else
// autoAckEnabled = TRUE;
//#endif
//#if defined(CC2420_HW_ACKNOWLEDGEMENTS)
// hwAutoAckDefault = TRUE;
//#else
hwAutoAckDefault = FALSE;
//#endif
//#if defined(CC2420_NO_ADDRESS_RECOGNITION)
addressRecognition = FALSE;
//#else
// addressRecognition = TRUE;
//#endif
return SUCCESS;
}
/***************** Resource Commands ****************/
async command error_t Resource.immediateRequest() {
error_t error = call SpiResource.immediateRequest();
if ( error == SUCCESS ) {
call CSN.clr();
}
return error;
}
async command error_t Resource.request() {
return call SpiResource.request();
}
async command uint8_t Resource.isOwner() {
return call SpiResource.isOwner();
}
async command error_t Resource.release() {
atomic {
call CSN.set();
return call SpiResource.release();
}
}
/***************** CC2420Power Commands ****************/
async command error_t CC2420Power.startVReg() {
atomic {
if ( m_state != S_VREG_STOPPED ) {
return FAIL;
}
m_state = S_VREG_STARTING;
}
call VREN.set();
call StartupTimer.start( CC2420_TIME_VREN );
return SUCCESS;
}
async command error_t CC2420Power.stopVReg() {
m_state = S_VREG_STOPPED;
call RSTN.clr();
call VREN.clr();
call RSTN.set();
return SUCCESS;
}
async command error_t CC2420Power.startOscillator() {
atomic {
//if ( m_state != S_VREG_STARTED ) {
// return FAIL;
//}
//m_state = S_XOSC_STARTING;
/*
call IOCFG1.write( CC2420_SFDMUX_XOSC16M_STABLE <<
CC2420_IOCFG1_CCAMUX );
*/
call IOCFG1.write(0x0018);
call InterruptCCA.enableRisingEdge();
call SXOSCON.strobe();
/*
call IOCFG0.write( ( 1 << CC2420_IOCFG0_FIFOP_POLARITY ) |
( 127 << CC2420_IOCFG0_FIFOP_THR ) );
*/
call IOCFG0.write(0x027F);
writeFsctrl();
//call FSCTRL.write(0x4192);
//initial set of frequency channel
//call FSCTRL.write( ( 1 << CC2420_FSCTRL_LOCK_THR ) | ( ( (LOGICAL_CHANNEL - 11)*5+357) << CC2420_FSCTRL_FREQ ) );
//call MDMCTRL0.write(0x0AE2);
call MDMCTRL0.write(0x02E2);
//CHANGE
writeMdmctrl0();
//call RXCTRL1.write(0x0A56);
/*
call RXCTRL1.write( ( 1 << CC2420_RXCTRL1_RXBPF_LOCUR ) |
( 1 << CC2420_RXCTRL1_LOW_LOWGAIN ) |
( 1 << CC2420_RXCTRL1_HIGH_HGM ) |
( 1 << CC2420_RXCTRL1_LNA_CAP_ARRAY ) |
( 1 << CC2420_RXCTRL1_RXMIX_TAIL ) |
( 1 << CC2420_RXCTRL1_RXMIX_VCM ) |
( 2 << CC2420_RXCTRL1_RXMIX_CURRENT ) );
*/
}
return SUCCESS;
}
async command error_t CC2420Power.stopOscillator() {
atomic {
if ( m_state != S_XOSC_STARTED ) {
return FAIL;
}
m_state = S_VREG_STARTED;
call SXOSCOFF.strobe();
}
return SUCCESS;
}
async command error_t CC2420Power.rxOn() {
atomic {
if ( m_state != S_XOSC_STARTED ) {
return FAIL;
}
call SRXON.strobe();
}
return SUCCESS;
}
async command error_t CC2420Power.rfOff() {
atomic {
if ( m_state != S_XOSC_STARTED ) {
return FAIL;
}
call SRFOFF.strobe();
}
return SUCCESS;
}
/***************** CC2420Config Commands ****************/
command uint8_t CC2420Config.getChannel() {
atomic return m_channel;
}
command void CC2420Config.setChannel( uint8_t channel ) {
atomic m_channel = channel;
}
async command uint16_t CC2420Config.getShortAddr() {
atomic return m_short_addr;
}
command void CC2420Config.setShortAddr( uint16_t addr ) {
atomic m_short_addr = addr;
}
async command uint16_t CC2420Config.getPanAddr() {
atomic return m_pan;
}
command void CC2420Config.setPanAddr( uint16_t pan ) {
atomic m_pan = pan;
}
/**
* Sync must be called to commit software parameters configured on
* the microcontroller (through the CC2420Config interface) to the
* CC2420 radio chip.
*/
command error_t CC2420Config.sync() {
atomic {
if ( m_sync_busy ) {
return FAIL;
}
m_sync_busy = TRUE;
if ( m_state == S_XOSC_STARTED ) {
call SyncResource.request();
} else {
post syncDone();
}
}
return SUCCESS;
}
/**
* @param on TRUE to turn address recognition on, FALSE to turn it off
*/
command void CC2420Config.setAddressRecognition(bool on) {
atomic addressRecognition = on;
}
/**
* @return TRUE if address recognition is enabled
*/
async command bool CC2420Config.isAddressRecognitionEnabled() {
atomic return addressRecognition;
}
/**
* Sync must be called for acknowledgement changes to take effect
* @param enableAutoAck TRUE to enable auto acknowledgements
* @param hwAutoAck TRUE to default to hardware auto acks, FALSE to
* default to software auto acknowledgements
*/
command void CC2420Config.setAutoAck(bool enableAutoAck, bool hwAutoAck) {
autoAckEnabled = enableAutoAck;
hwAutoAckDefault = hwAutoAck;
}
/**
* @return TRUE if hardware auto acks are the default, FALSE if software
* acks are the default
*/
async command bool CC2420Config.isHwAutoAckDefault() {
atomic return hwAutoAckDefault;
}
/**
* @return TRUE if auto acks are enabled
*/
async command bool CC2420Config.isAutoAckEnabled() {
atomic return autoAckEnabled;
}
/***************** ReadRssi Commands ****************/
command error_t ReadRssi.read() {
return call RssiResource.request();
}
/***************** Spi Resources Events ****************/
event void SyncResource.granted() {
//possibly this is on the sync of the new configuration of the transceiver //CHECK
call CSN.clr();
call SRFOFF.strobe();
writeFsctrl();
//CHANGE
writeMdmctrl0();
writeId();
call CSN.set();
call CSN.clr();
call SRXON.strobe();
call CSN.set();
call SyncResource.release();
post syncDone();
}
event void SpiResource.granted() {
call CSN.clr();
signal Resource.granted();
}
event void RssiResource.granted() {
uint16_t data;
call CSN.clr();
call RSSI.read(&data);
call CSN.set();
call RssiResource.release();
data += 0x7f;
data &= 0x00ff;
//signal ReadRssi.readDone(SUCCESS, data);
//signal Read_rssi.readDone(SUCCESS, data);
}
/***************** StartupTimer Events ****************/
async event void StartupTimer.fired() {
if ( m_state == S_VREG_STARTING ) {
m_state = S_VREG_STARTED;
call RSTN.clr();
call RSTN.set();
signal CC2420Power.startVRegDone();
}
}
/***************** InterruptCCA Events ****************/
async event void InterruptCCA.fired() {
m_state = S_XOSC_STARTED;
call InterruptCCA.disable();
call IOCFG1.write( 0 );
writeId();
call CSN.set();
call CSN.clr();
signal CC2420Power.startOscillatorDone();
}
/***************** ActiveMessageAddress Events ****************/
/*
async event void ActiveMessageAddress.changed() {
atomic {
m_short_addr = call ActiveMessageAddress.amAddress();
m_pan = call ActiveMessageAddress.amGroup();
}
post sync();
}
*/
/***************** Tasks ****************/
/**
* Attempt to synchronize our current settings with the CC2420
*/
task void sync() {
call CC2420Config.sync();
}
task void syncDone() {
atomic m_sync_busy = FALSE;
signal CC2420Config.syncDone( SUCCESS );
}
/***************** Functions ****************/
/**
* Write teh FSCTRL register
*/
void writeFsctrl() {
uint8_t channel;
atomic {
channel = m_channel;
}
call FSCTRL.write( ( 1 << CC2420_FSCTRL_LOCK_THR ) |
( ( (channel - 11)*5+357 ) << CC2420_FSCTRL_FREQ ) );
/*
call FSCTRL.write( ( 1 << CC2420_FSCTRL_LOCK_THR ) |
( channel << CC2420_FSCTRL_FREQ ) );
*/
}
/**
* Write the MDMCTRL0 register
*/
void writeMdmctrl0() {
atomic {
call MDMCTRL0.write( ( 1 << CC2420_MDMCTRL0_RESERVED_FRAME_MODE ) |
( addressRecognition << CC2420_MDMCTRL0_ADR_DECODE ) |
( 2 << CC2420_MDMCTRL0_CCA_HYST ) |
( 3 << CC2420_MDMCTRL0_CCA_MOD ) |
( 1 << CC2420_MDMCTRL0_AUTOCRC ) |
( (autoAckEnabled && hwAutoAckDefault) << CC2420_MDMCTRL0_AUTOACK ) |
( 0 << CC2420_MDMCTRL0_AUTOACK ) |
( 2 << CC2420_MDMCTRL0_PREAMBLE_LENGTH ) );
}
// Jon Green:
// MDMCTRL1.CORR_THR is defaulted to 20 instead of 0 like the datasheet says
// If we add in changes to MDMCTRL1, be sure to include this fix.
}
/**
* Write the PANID register
*/
void writeId() {
nxle_uint16_t id[ 2 ];
atomic {
id[ 0 ] = m_pan;
id[ 1 ] = m_short_addr;
}
call PANID.write(0, (uint8_t*)&id, sizeof(id));
}
/***************** Defaults ****************/
default event void CC2420Config.syncDone( error_t error ) {
}
default event void ReadRssi.readDone(error_t error, uint16_t data) {
}
/*
command error_t Read_rssi.read() {
return call RssiResource.request();
}
*/
}
--- NEW FILE: CC2420ReceiveC.nc ---
/*
* Copyright (c) 2005-2006 Arch Rock Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* - Neither the name of the Arch Rock Corporation nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* ARCHED ROCK OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE
*/
/**
* Implementation of the receive path for the ChipCon CC2420 radio.
*
* @author Jonathan Hui <jhui at archrock.com>
* @version $Revision: 1.1 $ $Date: 2008/02/11 17:41:25 $
*/
configuration CC2420ReceiveC {
provides interface StdControl;
provides interface Receiveframe;
provides interface AddressFilter;
}
implementation {
components MainC;
components CC2420ReceiveP;
components new CC2420SpiC() as Spi;
components CC2420ControlC;
components HplCC2420PinsC as Pins;
components HplCC2420InterruptsC as InterruptsC;
components LedsC as Leds;
CC2420ReceiveP.Leds -> Leds;
StdControl = CC2420ReceiveP;
Receiveframe = CC2420ReceiveP;
AddressFilter = CC2420ReceiveP;
MainC.SoftwareInit -> CC2420ReceiveP;
CC2420ReceiveP.CSN -> Pins.CSN;
CC2420ReceiveP.FIFO -> Pins.FIFO;
CC2420ReceiveP.FIFOP -> Pins.FIFOP;
CC2420ReceiveP.InterruptFIFOP -> InterruptsC.InterruptFIFOP;
CC2420ReceiveP.SpiResource -> Spi;
CC2420ReceiveP.RXFIFO -> Spi.RXFIFO;
CC2420ReceiveP.SFLUSHRX -> Spi.SFLUSHRX;
CC2420ReceiveP.SACK -> Spi.SACK;
CC2420ReceiveP.CC2420Config -> CC2420ControlC;
}
--- NEW FILE: CC2420ReceiveP.nc ---
/*
* Copyright (c) 2005-2006 Arch Rock Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* - Neither the name of the Arch Rock Corporation nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
[...966 lines suppressed...]
m_missed_packets = 0;
call SpiResource.release();
}
}
}
/**
* Reset this component
*/
void reset_state() {
m_bytes_left = RXFIFO_SIZE;
atomic receivingPacket = FALSE;
//m_timestamp_head = 0;
//m_timestamp_size = 0;
m_missed_packets = 0;
}
}
--- NEW FILE: CC2420SpiP.nc ---
/*
* Copyright (c) 2005-2006 Arch Rock Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* - Neither the name of the Arch Rock Corporation nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* ARCHED ROCK OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE
*/
/**
* @author Jonathan Hui <jhui at archrock.com>
* @author David Moss
* @author Roman Lim
* @version $Revision: 1.1 $ $Date: 2008/02/11 17:41:25 $
*/
module CC2420SpiP {
provides {
interface ChipSpiResource;
interface Resource[ uint8_t id ];
interface CC2420Fifo as Fifo[ uint8_t id ];
interface CC2420Ram as Ram[ uint16_t id ];
interface CC2420Register as Reg[ uint8_t id ];
interface CC2420Strobe as Strobe[ uint8_t id ];
}
uses {
interface Resource as SpiResource;
interface SpiByte;
interface SpiPacket;
interface State as WorkingState;
interface Leds;
}
}
implementation {
enum {
RESOURCE_COUNT = uniqueCount( "CC2420Spi.Resource" ),
NO_HOLDER = 0xFF,
};
/** WorkingStates */
enum {
S_IDLE,
S_BUSY,
};
/** Address to read/write on the CC2420, also maintains caller's client id */
norace uint16_t m_addr;
/** Each bit represents a client ID that is requesting SPI bus access */
uint8_t m_requests = 0;
/** The current client that owns the SPI bus */
uint8_t m_holder = NO_HOLDER;
/** TRUE if it is safe to release the SPI bus after all users say ok */
bool release;
/***************** Prototypes ****************/
error_t attemptRelease();
task void grant();
/***************** ChipSpiResource Commands ****************/
/**
* Abort the release of the SPI bus. This must be called only with the
* releasing() event
*/
async command void ChipSpiResource.abortRelease() {
atomic release = FALSE;
}
/**
* Release the SPI bus if there are no objections
*/
async command error_t ChipSpiResource.attemptRelease() {
return attemptRelease();
}
/***************** Resource Commands *****************/
async command error_t Resource.request[ uint8_t id ]() {
atomic {
if ( call WorkingState.requestState(S_BUSY) == SUCCESS ) {
m_holder = id;
if(call SpiResource.isOwner()) {
post grant();
} else {
call SpiResource.request();
}
} else {
m_requests |= 1 << id;
}
}
return SUCCESS;
}
async command error_t Resource.immediateRequest[ uint8_t id ]() {
error_t error;
atomic {
if ( call WorkingState.requestState(S_BUSY) != SUCCESS ) {
return EBUSY;
}
if(call SpiResource.isOwner()) {
m_holder = id;
error = SUCCESS;
} else if ((error = call SpiResource.immediateRequest()) == SUCCESS ) {
m_holder = id;
} else {
call WorkingState.toIdle();
}
}
return error;
}
async command error_t Resource.release[ uint8_t id ]() {
uint8_t i;
atomic {
if ( m_holder != id ) {
return FAIL;
}
m_holder = NO_HOLDER;
if ( !m_requests ) {
call WorkingState.toIdle();
attemptRelease();
} else {
for ( i = m_holder + 1; ; i++ ) {
i %= RESOURCE_COUNT;
if ( m_requests & ( 1 << i ) ) {
m_holder = i;
m_requests &= ~( 1 << i );
post grant();
return SUCCESS;
}
}
}
}
return SUCCESS;
}
async command uint8_t Resource.isOwner[ uint8_t id ]() {
atomic return (m_holder == id);
}
/***************** SpiResource Events ****************/
event void SpiResource.granted() {
post grant();
}
/***************** Fifo Commands ****************/
async command cc2420_status_t Fifo.beginRead[ uint8_t addr ]( uint8_t* data,
uint8_t len ) {
cc2420_status_t status = 0;
atomic {
if(call WorkingState.isIdle()) {
return status;
}
}
m_addr = addr | 0x40;
status = call SpiByte.write( m_addr );
call Fifo.continueRead[ addr ]( data, len );
return status;
}
async command error_t Fifo.continueRead[ uint8_t addr ]( uint8_t* data,
uint8_t len ) {
return call SpiPacket.send( NULL, data, len );
}
async command cc2420_status_t Fifo.write[ uint8_t addr ]( uint8_t* data,
uint8_t len ) {
uint8_t status = 0;
atomic {
if(call WorkingState.isIdle()) {
return status;
}
}
m_addr = addr;
status = call SpiByte.write( m_addr );
call SpiPacket.send( data, NULL, len );
return status;
}
/***************** RAM Commands ****************/
async command cc2420_status_t Ram.read[ uint16_t addr ]( uint8_t offset,
uint8_t* data,
uint8_t len ) {
cc2420_status_t status = 0;
atomic {
if(call WorkingState.isIdle()) {
return status;
}
}
addr += offset;
call SpiByte.write( addr | 0x80 );
status = call SpiByte.write( ( ( addr >> 1 ) & 0xc0 ) | 0x20 );
for ( ; len; len-- ) {
*data++ = call SpiByte.write( 0 );
}
return status;
}
async command cc2420_status_t Ram.write[ uint16_t addr ]( uint8_t offset,
uint8_t* data,
uint8_t len ) {
cc2420_status_t status = 0;
atomic {
if(call WorkingState.isIdle()) {
return status;
}
}
addr += offset;
call SpiByte.write( addr | 0x80 );
call SpiByte.write( ( addr >> 1 ) & 0xc0 );
for ( ; len; len-- ) {
status = call SpiByte.write( *data++ );
}
return status;
}
/***************** Register Commands ****************/
async command cc2420_status_t Reg.read[ uint8_t addr ]( uint16_t* data ) {
cc2420_status_t status = 0;
atomic {
if(call WorkingState.isIdle()) {
return status;
}
}
status = call SpiByte.write( addr | 0x40 );
*data = (uint16_t)call SpiByte.write( 0 ) << 8;
*data |= call SpiByte.write( 0 );
return status;
}
async command cc2420_status_t Reg.write[ uint8_t addr ]( uint16_t data ) {
atomic {
if(call WorkingState.isIdle()) {
return 0;
}
}
call SpiByte.write( addr );
call SpiByte.write( data >> 8 );
return call SpiByte.write( data & 0xff );
}
/***************** Strobe Commands ****************/
async command cc2420_status_t Strobe.strobe[ uint8_t addr ]() {
atomic {
if(call WorkingState.isIdle()) {
return 0;
}
}
return call SpiByte.write( addr );
}
/***************** SpiPacket Events ****************/
async event void SpiPacket.sendDone( uint8_t* tx_buf, uint8_t* rx_buf,
uint16_t len, error_t error ) {
if ( m_addr & 0x40 ) {
signal Fifo.readDone[ m_addr & ~0x40 ]( rx_buf, len, error );
} else {
signal Fifo.writeDone[ m_addr ]( tx_buf, len, error );
}
}
/***************** Functions ****************/
error_t attemptRelease() {
atomic{
if(m_requests > 0
|| m_holder != NO_HOLDER
|| !call WorkingState.isIdle()) {
return FAIL;
}
}
atomic release = TRUE;
signal ChipSpiResource.releasing();
atomic {
if(release) {
call SpiResource.release();
return SUCCESS;
}
}
return EBUSY;
}
task void grant() {
uint8_t holder;
atomic {
holder = m_holder;
}
signal Resource.granted[ holder ]();
}
/***************** Defaults ****************/
default event void Resource.granted[ uint8_t id ]() {
}
default async event void Fifo.readDone[ uint8_t addr ]( uint8_t* rx_buf, uint8_t rx_len, error_t error ) {
}
default async event void Fifo.writeDone[ uint8_t addr ]( uint8_t* tx_buf, uint8_t tx_len, error_t error ) {
}
default async event void ChipSpiResource.releasing() {
}
}
--- NEW FILE: CC2420TransmitC.nc ---
/*
* Copyright (c) 2005-2006 Arch Rock Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* - Neither the name of the Arch Rock Corporation nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* ARCHED ROCK OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE
*/
/**
* Implementation of the transmit path for the ChipCon CC2420 radio.
*
* @author Jonathan Hui <jhui at archrock.com>
* @version $Revision: 1.1 $ $Date: 2008/02/11 17:41:25 $
*/
#include "IEEE802154.h"
configuration CC2420TransmitC {
provides {
interface StdControl;
interface ReceiveIndicator as EnergyIndicator;
interface ReceiveIndicator as ByteIndicator;
interface Sendframe;
}
}
implementation {
components CC2420TransmitP;
StdControl = CC2420TransmitP;
EnergyIndicator = CC2420TransmitP.EnergyIndicator;
ByteIndicator = CC2420TransmitP.ByteIndicator;
Sendframe = CC2420TransmitP;
components MainC;
MainC.SoftwareInit -> CC2420TransmitP;
components HplCC2420PinsC as Pins;
CC2420TransmitP.CCA -> Pins.CCA;
CC2420TransmitP.CSN -> Pins.CSN;
CC2420TransmitP.SFD -> Pins.SFD;
components HplCC2420InterruptsC as Interrupts;
CC2420TransmitP.CaptureSFD -> Interrupts.CaptureSFD;
components new CC2420SpiC() as Spi;
CC2420TransmitP.SpiResource -> Spi;
CC2420TransmitP.ChipSpiResource -> Spi;
CC2420TransmitP.SNOP -> Spi.SNOP;
CC2420TransmitP.STXON -> Spi.STXON;
CC2420TransmitP.STXONCCA -> Spi.STXONCCA;
CC2420TransmitP.SFLUSHTX -> Spi.SFLUSHTX;
CC2420TransmitP.TXCTRL -> Spi.TXCTRL;
CC2420TransmitP.TXFIFO -> Spi.TXFIFO;
CC2420TransmitP.TXFIFO_RAM -> Spi.TXFIFO_RAM;
CC2420TransmitP.MDMCTRL1 -> Spi.MDMCTRL1;
components LedsC;
CC2420TransmitP.Leds -> LedsC;
}
--- NEW FILE: CC2420TransmitP.nc ---
/*
* Copyright (c) 2005-2006 Arch Rock Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* - Neither the name of the Arch Rock Corporation nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* ARCHED ROCK OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE
*/
/**
* @author Jonathan Hui <jhui at archrock.com>
* @author David Moss
* @author Jung Il Choi Initial SACK implementation
* @version $Revision: 1.1 $ $Date: 2008/02/11 17:41:25 $
*/
module CC2420TransmitP {
provides interface Init;
provides interface StdControl;
provides interface Sendframe;
provides interface ReceiveIndicator as EnergyIndicator;
provides interface ReceiveIndicator as ByteIndicator;
uses interface GpioCapture as CaptureSFD;
uses interface GeneralIO as CCA;
uses interface GeneralIO as CSN;
uses interface GeneralIO as SFD;
uses interface Resource as SpiResource;
uses interface ChipSpiResource;
uses interface CC2420Fifo as TXFIFO;
uses interface CC2420Ram as TXFIFO_RAM;
uses interface CC2420Register as TXCTRL;
uses interface CC2420Strobe as SNOP;
uses interface CC2420Strobe as STXON;
uses interface CC2420Strobe as STXONCCA;
uses interface CC2420Strobe as SFLUSHTX;
uses interface CC2420Register as MDMCTRL1;
uses interface Leds;
}
implementation {
/** Byte reception/transmission indicator */
bool sfdHigh;
/***************** Prototypes ****************/
void attemptSend();
error_t acquireSpiResource();
error_t releaseSpiResource();
void signalDone( error_t err );
/***************** Init Commands *****************/
command error_t Init.init() {
call CCA.makeInput();
call CSN.makeOutput();
call SFD.makeInput();
return SUCCESS;
}
/***************** StdControl Commands ****************/
command error_t StdControl.start() {
atomic {
call CaptureSFD.captureRisingEdge();
}
return SUCCESS;
}
command error_t StdControl.stop() {
atomic {
call CaptureSFD.disable();
call SpiResource.release(); // REMOVE
call CSN.set();
}
return SUCCESS;
}
/**************** Send Commands ****************/
async command error_t Sendframe.send(uint8_t* frame, uint8_t frame_length)
{
//printfUART("Send Command\n", "");
if ( acquireSpiResource() == SUCCESS ) {
call CSN.clr();
call TXCTRL.write( ( 2 << CC2420_TXCTRL_TXMIXBUF_CUR ) |
( 3 << CC2420_TXCTRL_PA_CURRENT ) |
( 1 << CC2420_TXCTRL_RESERVED ) |
( (CC2420_DEF_RFPOWER & 0x1F) << CC2420_TXCTRL_PA_LEVEL ) );
call TXFIFO.write( (uint8_t*)frame, frame_length);
}
return SUCCESS;
}
/***************** Indicator Commands ****************/
command bool EnergyIndicator.isReceiving() {
return !(call CCA.get());
}
command bool ByteIndicator.isReceiving() {
bool high;
atomic high = sfdHigh;
return high;
}
/**
* The CaptureSFD event is actually an interrupt from the capture pin
* which is connected to timing circuitry and timer modules. This
* type of interrupt allows us to see what time (being some relative value)
* the event occurred, and lets us accurately timestamp our packets. This
* allows higher levels in our system to synchronize with other nodes.
*
* Because the SFD events can occur so quickly, and the interrupts go
* in both directions, we set up the interrupt but check the SFD pin to
* determine if that interrupt condition has already been met - meaning,
* we should fall through and continue executing code where that interrupt
* would have picked up and executed had our microcontroller been fast enough.
*/
async event void CaptureSFD.captured( uint16_t time ) {
}
/***************** ChipSpiResource Events ****************/
async event void ChipSpiResource.releasing() {
}
/***************** SpiResource Events ****************/
event void SpiResource.granted() {
attemptSend();
}
/***************** TXFIFO Events ****************/
/**
* The TXFIFO is used to load packets into the transmit buffer on the
* chip
*/
async event void TXFIFO.writeDone( uint8_t* tx_buf, uint8_t tx_len,error_t error )
{
call CSN.set();
attemptSend();
}
async event void TXFIFO.readDone( uint8_t* tx_buf, uint8_t tx_len,error_t error ) {
}
/***************** Functions ****************/
/**
* Attempt to send the packet we have loaded into the tx buffer on
* the radio chip. The STXONCCA will send the packet immediately if
* the channel is clear. If we're not concerned about whether or not
* the channel is clear (i.e. m_cca == FALSE), then STXON will send the
* packet without checking for a clear channel.
*
* If the packet didn't get sent, then congestion == TRUE. In that case,
* we reset the backoff timer and try again in a moment.
*
* If the packet got sent, we should expect an SFD interrupt to take
* over, signifying the packet is getting sent.
*/
void attemptSend() {
//printfUART("attempt Send Command\n", "");
atomic {
call CSN.clr();
call STXON.strobe();
call CSN.set();
releaseSpiResource();
}
signalDone(SUCCESS);
}
error_t acquireSpiResource() {
error_t error = call SpiResource.immediateRequest();
//printfUART("acquire spi\n", "");
if ( error != SUCCESS ) {
call SpiResource.request();
}
return error;
}
error_t releaseSpiResource() {
call SpiResource.release();
return SUCCESS;
}
void signalDone( error_t err ) {
call ChipSpiResource.attemptRelease();
signal Sendframe.sendDone( err );
}
}
--- NEW FILE: Receiveframe.nc ---
/**
* Low-level abstraction for the receive path implementaiton of the
* ChipCon CC2420 radio.
*
* @author
* @version
*/
interface Receiveframe {
/**
* Signal that a message has been received
*/
async event void receive(uint8_t* frame, uint8_t rssi);
}
--- NEW FILE: Sendframe.nc ---
/**
* Low-level abstraction for the transmit path implementaiton of the
* ChipCon CC2420 radio.
*
* @author
* @version
*/
interface Sendframe {
/**
* Send a message
* @return SUCCESS if the request was accepted, FAIL otherwise.
*/
async command error_t send(uint8_t* frame, uint8_t frame_length);
/**
* Signal that a message has been sent
*/
async event void sendDone(error_t error );
}
--- NEW FILE: readme.txt ---
Title: ZigBee
Author: André Cunha - IPP-HURRAY! http://www.open-zb.net
----------------------------------------------
Notes:
------
This folder contains the CC2420 modified files and other additional files.
More information about the Tinyos-2-commits
mailing list