nes-proj/platform/seedeye/dev/mrf24j40/mrf24j40.c

975 lines
25 KiB
C
Raw Normal View History

/*
* Contiki SeedEye Platform project
*
* Copyright (c) 2012,
* Scuola Superiore Sant'Anna (http://www.sssup.it) and
* Consorzio Nazionale Interuniversitario per le Telecomunicazioni
* (http://www.cnit.it).
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. Neither the name of the Institute 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 INSTITUTE 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 INSTITUTE OR 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.
*
*/
/**
* \addtogroup mrf24j40 MRF24J40 Driver
*
* @{
*/
/**
* \file mrf24j40.c
*
* \brief MRF24J40 Driver
* \author Giovanni Pellerano <giovanni.pellerano@evilaliv3.org>
* \date 2012-03-21
*/
#include "contiki.h"
#include "mrf24j40.h"
#include "mrf24j40_arch.h"
#include <pic32_spi.h>
#include <pic32_irq.h>
#include "net/packetbuf.h"
#include "net/netstack.h"
#define DEBUG 0
#if DEBUG
#include <stdio.h>
#define PRINTF(...) printf(__VA_ARGS__)
#else
#define PRINTF(...)
#endif
/*---------------------------------------------------------------------------*/
PROCESS(mrf24j40_process, "MRF24J40 driver");
/*---------------------------------------------------------------------------*/
static volatile uint8_t mrf24j40_last_lqi;
static volatile uint8_t mrf24j40_last_rssi;
static volatile uint8_t status_tx;
static volatile uint8_t pending;
static volatile uint8_t receive_on;
/*---------------------------------------------------------------------------*/
static void
set_short_add_mem(uint8_t addr, uint8_t val)
{
const uint8_t tmp = MRF24J40_INTERRUPT_ENABLE_STAT();
uint8_t msg[2];
msg[0] = (addr << 1) | 0x01;
msg[1] = val;
if(tmp) {
MRF24J40_INTERRUPT_ENABLE_CLR();
}
MRF24J40_CSn_LOW();
MRF24J40_SPI_PORT_WRITE(msg, 2);
MRF24J40_CSn_HIGH();
if(tmp) {
MRF24J40_INTERRUPT_ENABLE_SET();
}
}
/*---------------------------------------------------------------------------*/
static void
set_long_add_mem(uint16_t addr, uint8_t val)
{
const uint8_t tmp = MRF24J40_INTERRUPT_ENABLE_STAT();
uint8_t msg[3];
msg[0] = (((uint8_t)(addr >> 3)) & 0x7F) | 0x80;
msg[1] = (((uint8_t)(addr << 5)) & 0xE0) | 0x10;
msg[2] = val;
if(tmp) {
MRF24J40_INTERRUPT_ENABLE_CLR();
}
MRF24J40_CSn_LOW();
MRF24J40_SPI_PORT_WRITE(msg, 3);
MRF24J40_CSn_HIGH();
if(tmp) {
MRF24J40_INTERRUPT_ENABLE_SET();
}
}
/*---------------------------------------------------------------------------*/
static uint8_t
get_short_add_mem(uint8_t addr)
{
const uint8_t tmp = MRF24J40_INTERRUPT_ENABLE_STAT();
uint8_t ret_val;
addr <<= 1;
if(tmp) {
MRF24J40_INTERRUPT_ENABLE_CLR();
}
MRF24J40_CSn_LOW();
MRF24J40_SPI_PORT_WRITE(&addr, 1);
MRF24J40_SPI_PORT_READ(&ret_val, 1);
MRF24J40_CSn_HIGH();
if(tmp) {
MRF24J40_INTERRUPT_ENABLE_SET();
}
return ret_val;
}
/*---------------------------------------------------------------------------*/
static uint8_t
get_long_add_mem(uint16_t addr)
{
const uint8_t tmp = MRF24J40_INTERRUPT_ENABLE_STAT();
uint8_t ret_val;
uint8_t msg[2];
msg[0] = (((uint8_t)(addr >> 3)) & 0x7F) | 0x80;
msg[1] = ((uint8_t)(addr << 5)) & 0xE0;
if(tmp) {
MRF24J40_INTERRUPT_ENABLE_CLR();
}
MRF24J40_CSn_LOW();
MRF24J40_SPI_PORT_WRITE(msg, 2);
MRF24J40_SPI_PORT_READ(&ret_val, 1);
MRF24J40_CSn_HIGH();
if(tmp) {
MRF24J40_INTERRUPT_ENABLE_SET();
}
return ret_val;
}
/*---------------------------------------------------------------------------*/
static void
reset_rf_state_machine(void)
{
/*
* Reset RF state machine
*/
const uint8_t rfctl = get_short_add_mem(MRF24J40_RFCTL);
set_short_add_mem(MRF24J40_RFCTL, rfctl | 0b00000100);
set_short_add_mem(MRF24J40_RFCTL, rfctl & 0b11111011);
clock_delay_usec(2500);
}
/*---------------------------------------------------------------------------*/
void
flush_rx_fifo(void)
{
set_short_add_mem(MRF24J40_RXFLUSH, get_short_add_mem(MRF24J40_RXFLUSH) | 0b00000001);
}
/*---------------------------------------------------------------------------*/
/**
* \brief Set the channel
*
* This routine sets the rx/tx channel
*/
void
mrf24j40_set_channel(uint16_t ch)
{
set_long_add_mem(MRF24J40_RFCON0, ((ch - 11) << 4) | 0b00000011);
reset_rf_state_machine();
}
/*---------------------------------------------------------------------------*/
/**
* \brief Store MAC PAN ID
*
* This routine sets the MAC PAN ID in the MRF24J40.
*/
void
mrf24j40_set_panid(uint16_t id)
{
set_short_add_mem(MRF24J40_PANIDL, (uint8_t)id);
set_short_add_mem(MRF24J40_PANIDH, (uint8_t)(id >> 8));
}
/*---------------------------------------------------------------------------*/
/**
* \brief Store short MAC address
*
* This routine sets the short MAC address in the MRF24J40.
*/
void
mrf24j40_set_short_mac_addr(uint16_t addr)
{
set_short_add_mem(MRF24J40_SADRL, (uint8_t)addr);
set_short_add_mem(MRF24J40_SADRH, (uint8_t)(addr >> 8));
}
/*---------------------------------------------------------------------------*/
/**
* \brief Store extended MAC address
*
* This routine sets the extended MAC address in the MRF24J40.
*/
void
mrf24j40_set_extended_mac_addr(uint64_t addr)
{
set_short_add_mem(MRF24J40_EADR7, (uint8_t)addr);
set_short_add_mem(MRF24J40_EADR6, (uint8_t)(addr >> 8));
set_short_add_mem(MRF24J40_EADR5, (uint8_t)(addr >> 16));
set_short_add_mem(MRF24J40_EADR4, (uint8_t)(addr >> 24));
set_short_add_mem(MRF24J40_EADR3, (uint8_t)(addr >> 32));
set_short_add_mem(MRF24J40_EADR2, (uint8_t)(addr >> 40));
set_short_add_mem(MRF24J40_EADR1, (uint8_t)(addr >> 48));
set_short_add_mem(MRF24J40_EADR0, (uint8_t)(addr >> 56));
}
/*---------------------------------------------------------------------------*/
/**
* \brief Get short MAC address
*
* This routine gets the short MAC address stored in the MRF24J40.
*/
void
mrf24j40_get_short_mac_addr(uint16_t *addr)
{
*(((uint8_t *)& addr)) = get_short_add_mem(MRF24J40_SADRH);
*(((uint8_t *)& addr) + 1) = get_short_add_mem(MRF24J40_SADRL);
}
/*---------------------------------------------------------------------------*/
/**
* \brief Gets extended MAC address
*
* This routine gets the extended MAC address stored in the MRF24J40.
*/
void
mrf24j40_get_extended_mac_addr(uint64_t *addr)
{
*(((uint8_t *)& addr)) = get_short_add_mem(MRF24J40_EADR7);
*(((uint8_t *)& addr) + 1) = get_short_add_mem(MRF24J40_EADR6);
*(((uint8_t *)& addr) + 2) = get_short_add_mem(MRF24J40_EADR5);
*(((uint8_t *)& addr) + 3) = get_short_add_mem(MRF24J40_EADR4);
*(((uint8_t *)& addr) + 4) = get_short_add_mem(MRF24J40_EADR3);
*(((uint8_t *)& addr) + 5) = get_short_add_mem(MRF24J40_EADR2);
*(((uint8_t *)& addr) + 6) = get_short_add_mem(MRF24J40_EADR1);
*(((uint8_t *)& addr) + 7) = get_short_add_mem(MRF24J40_EADR0);
}
/*---------------------------------------------------------------------------*/
/**
* \brief Set TX power
*
* This routine sets the transmission power of the MRF24J40.
*/
void
mrf24j40_set_tx_power(uint8_t pwr)
{
set_long_add_mem(MRF24J40_RFCON3, pwr);
}
/*---------------------------------------------------------------------------*/
/**
* \brief Get radio status
*
* This routine returns the MRF24J40 status.
*/
uint8_t
mrf24j40_get_status(void)
{
return get_long_add_mem(MRF24J40_RFSTATE);
}
/*---------------------------------------------------------------------------*/
/**
* \brief Get the RSSI
*
* This routine returns the rssi value mesured in dbm
* Note: to convert the returned value to dBm, use the table 3-8 available
* in the MRF24J40 datasheet.
*/
uint8_t
mrf24j40_get_rssi(void)
{
/*
* 3.6.1 RSSI FIRMWARE REQUEST (RSSI MODE1)
* In this mode, the host microcontroller sends a request
* to calculate RSSI, then waits until it is done and then
* reads the RSSI value. The steps are:
*
* 1.
* Set RSSIMODE1 0x3E<7> Initiate RSSI
* calculation.
*
* 2.
* Wait until RSSIRDY 0x3E<0> is set to 1 RSSI
* calculation is complete.
*
* 3.
* Read RSSI 0x210<7:0> The RSSI register
* contains the averaged RSSI received power
* level for 8 symbol periods.
*/
/* Initiate RSSI calculation */
set_short_add_mem(MRF24J40_BBREG6, get_short_add_mem(MRF24J40_BBREG6) | 0b10000000);
/* Wait until RSSI calculation is done */
while(!(get_short_add_mem(MRF24J40_BBREG6) & 0b00000001)) {
;
}
mrf24j40_last_rssi = get_long_add_mem(MRF24J40_RSSI);
return mrf24j40_last_rssi;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Get the last read RSSI
*
* This routine returns the last rssi value mesured in dbm
* Note: to convert the returned value to dBm, use the table 3-8 available
* in the MRF24J40 datasheet.
*/
uint8_t
mrf24j40_get_last_rssi(void)
{
return mrf24j40_last_rssi;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Get the last read LQI
*
* This routine returns the last lqi
*/
uint8_t
mrf24j40_get_last_lqi(void)
{
return mrf24j40_last_lqi;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Store message
*
* This routine stores a buffer of buf_len bytes in the TX_FIFO
* buffer of the MRF24J40.
*/
int32_t
mrf24j40_set_txfifo(const uint8_t *buf, uint8_t buf_len)
{
uint8_t i;
if((buf_len == 0) || (buf_len > 128)) {
return -1;
}
set_long_add_mem(MRF24J40_NORMAL_TX_FIFO, 0);
set_long_add_mem(MRF24J40_NORMAL_TX_FIFO + 1, buf_len);
for(i = 0; i < buf_len; ++i) {
set_long_add_mem(MRF24J40_NORMAL_TX_FIFO + 2 + i, buf[i]);
}
return 0;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Get message
*
* This routine is used to retrieve a message stored in the RX_FIFO
*/
int32_t
mrf24j40_get_rxfifo(uint8_t *buf, uint8_t buf_len)
{
uint8_t i, len;
MRF24J40_INTERRUPT_ENABLE_CLR();
/* Disable packet reception */
set_short_add_mem(MRF24J40_BBREG1, 0b00000100);
/* Get packet length discarding 2 bytes (LQI, RSSI) */
len = get_long_add_mem(MRF24J40_RX_FIFO) - 2;
if(len <= buf_len) {
/* Get the packet */
for(i = 0; i < len; ++i) {
buf[i] = get_long_add_mem(MRF24J40_RX_FIFO + i + 1);
}
/*
* packet len includes = header + paylod + LQI + RSSI
*/
#ifdef ADD_RSSI_AND_LQI_TO_PACKET
mrf24j40_last_lqi = get_long_add_mem(MRF24J40_RX_FIFO + len + 3);
mrf24j40_last_rssi = get_long_add_mem(MRF24J40_RX_FIFO + len + 4);
#endif
} else {
len = 0;
}
/* Enable packet reception */
set_short_add_mem(MRF24J40_BBREG1, 0b00000000);
pending = 0;
#ifdef MRF24J40_PROMISCUOUS_MODE
/*
* Flush RX FIFO as suggested by the work around 1 in
* MRF24J40 Silicon Errata.
*/
flush_rx_fifo();
#endif
MRF24J40_INTERRUPT_ENABLE_SET();
return len == 0 ? -1 : len;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Start sleep
*
* This routine puts the radio in sleep mode.
*/
static void
put_to_sleep(void)
{
/* Prepare WAKE pin: */
MRF24J40_WAKE = 0;
/* Enable Immediate Wake-up mode */
set_short_add_mem(MRF24J40_WAKECON, 0b10000000);
set_short_add_mem(MRF24J40_SOFTRST, 0b00000100);
set_short_add_mem(MRF24J40_RXFLUSH, 0b01100000);
/* Put to sleep */
set_short_add_mem(MRF24J40_SLPACK, 0b10000000);
}
/*---------------------------------------------------------------------------*/
/**
* \brief Awake the radio
*
* This routine turns on and sets the radio on receiving mode.
* Note: After performing this routine the radio is in the receiving state.
*/
static void
wake(void)
{
/* Wake-up */
MRF24J40_WAKE = 1;
/* RF State Machine reset */
set_short_add_mem(MRF24J40_RFCTL, 0b00000100);
set_short_add_mem(MRF24J40_RFCTL, 0b00000000);
clock_delay_usec(2500);
}
/*---------------------------------------------------------------------------*/
int
mrf24j40_on(void)
{
if(!receive_on) {
wake();
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
receive_on = 1;
}
return 1;
}
/*---------------------------------------------------------------------------*/
int
mrf24j40_off(void)
{
if(receive_on) {
ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
receive_on = 0;
put_to_sleep();
}
return 1;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Init transceiver
*
* This routine initializes the radio transceiver
*/
int
mrf24j40_init(void)
{
uint8_t i;
/* Set the IO pins direction */
MRF24J40_PINDIRECTION_INIT();
/* Set interrupt registers and reset flags */
MRF24J40_INTERRUPT_INIT(6, 3);
if(MRF24J40_SPI_PORT_INIT(10000000, SPI_DEFAULT) < 0)
return -1;
PRINTF("MRF24J40 Initialization started\n");
MRF24J40_HARDRESET_LOW();
clock_delay_usec(2500);
MRF24J40_HARDRESET_HIGH();
clock_delay_usec(2500);
/*
* bit 7:3 reserved: Maintain as 0
* bit 2 RSTPWR: Power Management Reset bit
* 1 = Reset power management circuitry (bit is automatically cleared to 0 by hardware)
* bit 1 RSTBB: Baseband Reset bit
* 1 = Reset baseband circuitry (bit is automatically cleared to 0 by hardware)
* bit 0 RSTMAC: MAC Reset bit
* 1 = Reset MAC circuitry (bit is automatically cleared to 0 by hardware)
*/
set_short_add_mem(MRF24J40_SOFTRST, 0b00000111);
/*
* wait until the radio reset is completed
*/
do {
i = get_short_add_mem(MRF24J40_SOFTRST);
} while((i & 0b0000111) != 0);
clock_delay_usec(2500);
/*
* bit 7 FIFOEN: FIFO Enable bit 1 = Enabled (default). Always maintain this bit as a 1.
* bit 6 reserved: Maintain as 0
* bit 5:2 TXONTS<3:0>: Transmitter Enable On Time Symbol bits(1)
* Transmitter on time before beginning of packet. Units: symbol period (16 μs).
* Minimum value: 0x1. Default value: 0x2 (2 * 16 μs = 32 μs). Recommended value: 0x6 (6 * 16 μs = 96 μs).
* bit 1:0 TXONT<8:7>: Transmitter Enable On Time Tick bits(1)
* Transmitter on time before beginning of packet. TXONT is a 9-bit value. TXONT<6:0> bits are located
* in SYMTICKH<7:1>. Units: tick (50 ns). Default value = 0x028 (40 * 50 ns = 2 μs).
*/
set_short_add_mem(MRF24J40_PACON2, 0b10011000);
mrf24j40_set_channel(MRF24J40_DEFAULT_CHANNEL);
set_long_add_mem(MRF24J40_RFCON1, 0b00000010); /* program the RF and Baseband Register */
/* as suggested by the datasheet */
set_long_add_mem(MRF24J40_RFCON2, 0b10000000); /* enable PLL */
mrf24j40_set_tx_power(0b00000000); /* set power 0dBm (plus 20db power amplifier 20dBm)*/
/*
* Set up
*
* bit 7 '1' as suggested by the datasheet
* bit 6:5 '00' reserved
* bit 4 '1' recovery from sleep 1 usec
* bit 3 '0' battery monitor disabled
* bit 2:0 '000' reserved
*/
set_long_add_mem(MRF24J40_RFCON6, 0b10010000);
set_long_add_mem(MRF24J40_RFCON7, 0b10000000); /* Sleep clock = 100kHz */
set_long_add_mem(MRF24J40_RFCON8, 0b00000010); /* as suggested by the datasheet */
set_long_add_mem(MRF24J40_SLPCON1, 0b00100001); /* as suggested by the datasheet */
/* Program CCA, RSSI threshold values */
set_short_add_mem(MRF24J40_BBREG2, 0b01111000); /* Recommended value by the datashet */
set_short_add_mem(MRF24J40_CCAEDTH, 0b01100000); /* Recommended value by the datashet */
#ifdef MRF24J40MB
/* Activate the external amplifier needed by the MRF24J40MB */
set_long_add_mem(MRF24J40_TESTMODE, 0b0001111);
PRINTF("MRF24J40 Init Amplifier activated \n");
#endif
#ifdef ADD_RSSI_AND_LQI_TO_PACKET
/* Enable the packet RSSI */
set_short_add_mem(MRF24J40_BBREG6, 0b01000000);
PRINTF("MRF24J40 Init append RSSI and LQI to packet\n");
#endif
/*
* Wait until the radio state machine is not on rx mode
*/
do {
i = get_long_add_mem(MRF24J40_RFSTATE);
} while((i & 0xA0) != 0xA0);
i = 0;
#ifdef MRF24J40_DISABLE_AUTOMATIC_ACK
i = i | 0b00100000;
PRINTF("MRF24J40 Init NO_AUTO_ACK\n");
#endif
#ifdef MRF24J40_PAN_COORDINATOR
i = i | 0b00001000;
PRINTF("MRF24J40 Init PAN COORD\n");
set_short_add_mem(MRF24J40_ORDER, 0b11111111);
#endif
#ifdef MRF24J40_COORDINATOR
i = i | 0b00000100;
PRINTF("MRF24J40 Init COORD\n");
#endif
#ifdef MRF24J40_ACCEPT_WRONG_CRC_PKT
i = i | 0b00000010;
PRINTF("MRF24J40 Init Accept Wrong CRC\n");
#endif
#ifdef MRF24J40_PROMISCUOUS_MODE
i = i | 0b00000001;
PRINTF("MRF24J40 Init PROMISCUOUS MODE\n");
#endif
/*
* Set the RXMCR register.
* Default setting i = 0x00, which means:
* - Automatic ACK;
* - Device is not a PAN coordinator;
* - Device is not a coordinator;
* - Accept only packets with good CRC
* - Discard packet when there is a MAC address mismatch,
* illegal frame type, dPAN/sPAN or MAC short address mismatch.
*/
set_short_add_mem(MRF24J40_RXMCR, i);
PRINTF("RXMCR 0x%X\n", i);
/*
* Set the TXMCR register.
* bit 7 '0' Enable No Carrier Sense Multiple Access (CSMA) Algorithm.
* bit 6 '0' Disable Battery Life Extension Mode bit.
* bit 5 '0' Disable Slotted CSMA-CA Mode bit.
* bit 4:3 '11' MAC Minimum Backoff Exponent bits (macMinBE).
* bit 2:0 '100' CSMA Backoff bits (macMaxCSMABackoff)
*/
set_short_add_mem(MRF24J40_TXMCR, 0b00011100);
i = get_short_add_mem(MRF24J40_TXMCR);
PRINTF("TXMCR 0x%X\n", i);
/*
* Set TX turn around time as defined by IEEE802.15.4 standard
*/
set_short_add_mem(MRF24J40_TXSTBL, 0b10010101);
set_short_add_mem(MRF24J40_TXTIME, 0b00110000);
#ifdef INT_POLARITY_HIGH
/* Set interrupt edge polarity high */
set_long_add_mem(MRF24J40_SLPCON0, 0b00000011);
PRINTF("MRF24J40 Init INT Polarity High\n");
#else
set_long_add_mem(MRF24J40_SLPCON0, 0b00000001);
PRINTF("MRF24J40 Init INT Polarity Low\n");
#endif
PRINTF("MRF24J40 Inititialization completed\n");
mrf24j40_last_lqi = 0;
mrf24j40_last_rssi = 0;
status_tx = MRF24J40_TX_ERR_NONE;
pending = 0;
receive_on = 1;
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
reset_rf_state_machine();
/* Flush RX FIFO */
flush_rx_fifo();
process_start(&mrf24j40_process, NULL);
/*
*
* Setup interrupts.
*
* set INTCON
* bit 7 '1' Disables the sleep alert interrupt
* bit 6 '1' Disables the wake-up alert interrupt
* bit 5 '1' Disables the half symbol timer interrupt
* bit 4 '1' Disables the security key request interrupt
* bit 3 '0' Enables the RX FIFO reception interrupt
* bit 2 '1' Disables the TX GTS2 FIFO transmission interrupt
* bit 1 '1' Disables the TX GTS1 FIFO transmission interrupt
* bit 0 '0' Enables the TX Normal FIFO transmission interrupt
*/
set_short_add_mem(MRF24J40_INTCON, 0b11110110);
return 0;
}
/*---------------------------------------------------------------------------*/
int
mrf24j40_prepare(const void *data, unsigned short len)
{
PRINTF("PREPARE %u bytes\n", len);
uint8_t receive_was_on = receive_on;
mrf24j40_on();
ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
mrf24j40_set_txfifo(data, len);
ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT);
if(!receive_was_on) {
mrf24j40_off();
} else {
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
}
return 0;
}
/*---------------------------------------------------------------------------*/
int
mrf24j40_transmit(unsigned short len)
{
PRINTF("TRANSMIT %u bytes\n", len);
uint8_t receive_was_on = receive_on;
mrf24j40_on();
ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
status_tx = MRF24J40_TX_WAIT;
set_short_add_mem(MRF24J40_TXNCON, 0b00000001);
/* Wait until the transmission has finished. */
while(status_tx == MRF24J40_TX_WAIT) {
;
}
ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT);
if(!receive_was_on) {
mrf24j40_off();
} else {
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
}
switch(status_tx) {
case MRF24J40_TX_ERR_NONE:
return RADIO_TX_OK;
case MRF24J40_TX_ERR_COLLISION:
return RADIO_TX_COLLISION;
case MRF24J40_TX_ERR_MAXRETRY:
return RADIO_TX_NOACK;
default:
return RADIO_TX_ERR;
}
}
/*---------------------------------------------------------------------------*/
int
mrf24j40_write(const void *data, uint16_t len)
{
int ret = -1;
PRINTF("PREPARE & TRANSMIT %u bytes\n", len);
if(mrf24j40_prepare(data, len))
return ret;
ret = mrf24j40_transmit(len);
return ret;
}
/*---------------------------------------------------------------------------*/
int
mrf24j40_read(void *data, uint16_t len)
{
return mrf24j40_get_rxfifo(data, len);
}
/*---------------------------------------------------------------------------*/
int
mrf24j40_cca(void)
{
uint8_t ret;
uint8_t receive_was_on = receive_on;
mrf24j40_on();
ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
ret = mrf24j40_get_rssi() <= 95; /* -69dbm */
if(!receive_was_on) {
mrf24j40_off();
} else {
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
}
return ret;
}
/*---------------------------------------------------------------------------*/
int
mrf24j40_receiving_packet(void)
{
return 0;
}
/*---------------------------------------------------------------------------*/
int
mrf24j40_pending_packet(void)
{
return pending;
}
/*---------------------------------------------------------------------------*/
MRF24J40_ISR()
{
INT_status int_status;
TX_status tx_status;
ENERGEST_ON(ENERGEST_TYPE_IRQ);
int_status.val = get_short_add_mem(MRF24J40_INTSTAT);
if(!int_status.val) {
return;
}
if(int_status.bits.RXIF) {
pending = 1;
process_poll(&mrf24j40_process);
}
if(int_status.bits.TXNIF) {
tx_status.val = get_short_add_mem(MRF24J40_TXSTAT);
if(tx_status.bits.TXNSTAT) {
if(tx_status.bits.CCAFAIL) {
status_tx = MRF24J40_TX_ERR_COLLISION;
} else {
status_tx = MRF24J40_TX_ERR_MAXRETRY;
}
} else {
status_tx = MRF24J40_TX_ERR_NONE;
}
}
MRF24J40_INTERRUPT_FLAG_CLR();
ENERGEST_OFF(ENERGEST_TYPE_IRQ);
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(mrf24j40_process, ev, data)
{
PROCESS_BEGIN();
uint8_t ret;
while(1) {
PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL);
if(!pending) {
continue;
}
packetbuf_clear();
ret = mrf24j40_read(packetbuf_dataptr(), PACKETBUF_SIZE);
packetbuf_set_datalen(ret);
#ifdef ADD_RSSI_AND_LQI_TO_PACKET
packetbuf_set_attr(PACKETBUF_ATTR_RSSI, mrf24j40_last_rssi);
packetbuf_set_attr(PACKETBUF_ATTR_LINK_QUALITY, mrf24j40_last_lqi);
#endif
NETSTACK_RDC.input();
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
static radio_result_t
get_value(radio_param_t param, radio_value_t *value)
{
return RADIO_RESULT_NOT_SUPPORTED;
}
/*---------------------------------------------------------------------------*/
static radio_result_t
set_value(radio_param_t param, radio_value_t value)
{
return RADIO_RESULT_NOT_SUPPORTED;
}
/*---------------------------------------------------------------------------*/
static radio_result_t
get_object(radio_param_t param, void *dest, size_t size)
{
return RADIO_RESULT_NOT_SUPPORTED;
}
/*---------------------------------------------------------------------------*/
static radio_result_t
set_object(radio_param_t param, const void *src, size_t size)
{
return RADIO_RESULT_NOT_SUPPORTED;
}
/*---------------------------------------------------------------------------*/
const struct radio_driver mrf24j40_driver = {
mrf24j40_init,
mrf24j40_prepare,
mrf24j40_transmit,
mrf24j40_write,
mrf24j40_read,
mrf24j40_cca,
mrf24j40_receiving_packet,
mrf24j40_pending_packet,
mrf24j40_on,
mrf24j40_off,
get_value,
set_value,
get_object,
set_object
};
/*---------------------------------------------------------------------------*/
/** @} */