at86rf2xx.h

Go to the documentation of this file.

/*
 * Copyright (C) 2015 Freie Universität Berlin
 *
 * This file is subject to the terms and conditions of the GNU Lesser General
 * Public License v2.1. See the file LICENSE in the top level directory for more
 * details.
 */
 
#pragma once
 
#include <stdint.h>
#include <stdbool.h>
 
#include "board.h"
#include "kernel_defines.h"
#include "net/netdev.h"
#include "net/netdev/ieee802154.h"
#include "net/gnrc/nettype.h"
 
/* we need no peripherals for memory mapped radios */
#if !defined(MODULE_AT86RFA1) && !defined(MODULE_AT86RFR2)
#include "periph/spi.h"
#include "periph/gpio.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define AT86RF2XX_MAX_PKT_LENGTH        (IEEE802154_FRAME_LEN_MAX)
 
#ifdef MODULE_AT86RF212B
/* the AT86RF212B has a sub-1GHz radio */
#define AT86RF2XX_MIN_CHANNEL           (IEEE802154_CHANNEL_MIN_SUBGHZ)
#define AT86RF2XX_MAX_CHANNEL           (IEEE802154_CHANNEL_MAX_SUBGHZ)
#define AT86RF2XX_DEFAULT_CHANNEL       (CONFIG_IEEE802154_DEFAULT_SUBGHZ_CHANNEL)
/* Page 2 is O-QPSK 100 kbit/s (channel 0), or 250 kbit/s (channels 1-10) */
#define AT86RF2XX_DEFAULT_PAGE          (CONFIG_IEEE802154_DEFAULT_SUBGHZ_PAGE)
#else
#define AT86RF2XX_MIN_CHANNEL           (IEEE802154_CHANNEL_MIN)
#define AT86RF2XX_MAX_CHANNEL           (IEEE802154_CHANNEL_MAX)
#define AT86RF2XX_DEFAULT_CHANNEL       (CONFIG_IEEE802154_DEFAULT_CHANNEL)
#define AT86RF2XX_DEFAULT_PAGE          (0)
/* Only page 0 is supported in the 2.4 GHz band */
#endif
#define AT86RF2XX_DEFAULT_TXPOWER       (CONFIG_IEEE802154_DEFAULT_TXPOWER)
 
#if MODULE_AT86RF233
#   define RSSI_BASE_VAL                   (-94)
#elif MODULE_AT86RF212B
#   define RSSI_BASE_VAL                   (-98)
#elif MODULE_AT86RFA1 || MODULE_AT86RFR2
#   define RSSI_BASE_VAL                   (-90)
#else
#   define RSSI_BASE_VAL                   (-91)
#endif
 
#if MODULE_AT86RF233
#   define MIN_RX_SENSITIVITY              (-101)
#elif MODULE_AT86RF212B
#   define MIN_RX_SENSITIVITY              (-110)
#elif MODULE_AT86RFA1 || MODULE_AT86RFR2
#   define MIN_RX_SENSITIVITY              (-100)
#else
#   define MIN_RX_SENSITIVITY              (-101)
#endif
 
#if IS_USED(MODULE_AT86RFA1) || IS_USED(MODULE_AT86RFR2)
#define AT86RF2XX_IS_PERIPH (1)
#else
#define AT86RF2XX_IS_PERIPH (0)
#endif
 
#if defined(MODULE_AT86RF231) || IS_ACTIVE(AT86RF2XX_PERIPH)
#define AT86RF2XX_HAVE_ED_REGISTER (1)
#else
#define AT86RF2XX_HAVE_ED_REGISTER (0)
#endif
 
#ifdef MODULE_AT86RF212B
#define AT86RF2XX_HAVE_SUBGHZ (1)
#else
#define AT86RF2XX_HAVE_SUBGHZ (0)
#endif
 
#if defined(DOXYGEN) || defined(MODULE_AT86RF232) || defined(MODULE_AT86RF233) || defined(MODULE_AT86RFR2)
#define AT86RF2XX_HAVE_RETRIES             (1)
#else
#define AT86RF2XX_HAVE_RETRIES             (0)
#endif
 
#if AT86RF2XX_HAVE_RETRIES && defined(AT86RF2XX_REG__XAH_CTRL_2)
#define AT86RF2XX_HAVE_RETRIES_REG         (1)
#else
#define AT86RF2XX_HAVE_RETRIES_REG         (0)
#endif
 
#ifdef AT86RF2XX_REG__IRQ_MASK1
#define AT86RF2XX_HAVE_TX_START_IRQ        (1)
#else
#define AT86RF2XX_HAVE_TX_START_IRQ        (0)
#endif
 
#if defined(MODULE_AT86RF233) || defined(MODULE_AT86RF231) || defined(MODULE_AT86RFA1) || defined(MODULE_AT86RFR2)
#ifndef AT86RF2XX_RANDOM_NUMBER_GENERATOR
#define AT86RF2XX_RANDOM_NUMBER_GENERATOR  (1)
#endif
#else
#ifndef AT86RF2XX_RANDOM_NUMBER_GENERATOR
#define AT86RF2XX_RANDOM_NUMBER_GENERATOR  (0)
#endif
#endif
 
#if defined(MODULE_AT86RF233) || defined(MODULE_AT86RFR2)
#ifndef AT86RF2XX_SMART_IDLE_LISTENING
#define AT86RF2XX_SMART_IDLE_LISTENING     (1)
#endif
#else
#define AT86RF2XX_SMART_IDLE_LISTENING     (0)
#endif
 
#define AT86RF2XX_STATE_P_ON           (0x00)     
#define AT86RF2XX_STATE_BUSY_RX        (0x01)     
#define AT86RF2XX_STATE_BUSY_TX        (0x02)     
#define AT86RF2XX_STATE_FORCE_TRX_OFF  (0x03)     
#define AT86RF2XX_STATE_RX_ON          (0x06)     
#define AT86RF2XX_STATE_TRX_OFF        (0x08)     
#define AT86RF2XX_STATE_PLL_ON         (0x09)     
#define AT86RF2XX_STATE_SLEEP          (0x0f)     
#define AT86RF2XX_STATE_BUSY_RX_AACK   (0x11)     
#define AT86RF2XX_STATE_BUSY_TX_ARET   (0x12)     
#define AT86RF2XX_STATE_RX_AACK_ON     (0x16)     
#define AT86RF2XX_STATE_TX_ARET_ON     (0x19)     
#define AT86RF2XX_STATE_IN_PROGRESS    (0x1f)     
#define AT86RF2XX_OPT_CSMA           (0x0010)       
#define AT86RF2XX_OPT_PROMISCUOUS    (0x0020)       
#define AT86RF2XX_OPT_PRELOADING     (0x0040)       
#define AT86RF2XX_OPT_AUTOACK        (0x0080)       
#define AT86RF2XX_OPT_ACK_PENDING    (0x0100)       
#if IS_ACTIVE(AT86RF2XX_BASIC_MODE) || defined(DOXYGEN)
#define AT86RF2XX_PHY_STATE_RX       AT86RF2XX_STATE_RX_ON
#define AT86RF2XX_PHY_STATE_RX_BUSY  AT86RF2XX_STATE_BUSY_RX
#define AT86RF2XX_PHY_STATE_TX       AT86RF2XX_STATE_PLL_ON
#define AT86RF2XX_PHY_STATE_TX_BUSY  AT86RF2XX_STATE_BUSY_TX
#else
#define AT86RF2XX_PHY_STATE_RX       AT86RF2XX_STATE_RX_AACK_ON
#define AT86RF2XX_PHY_STATE_RX_BUSY  AT86RF2XX_STATE_BUSY_RX_AACK
#define AT86RF2XX_PHY_STATE_TX       AT86RF2XX_STATE_TX_ARET_ON
#define AT86RF2XX_PHY_STATE_TX_BUSY  AT86RF2XX_STATE_BUSY_TX_ARET
#endif /* IS_ACTIVE(AT86RF2XX_BASIC_MODE) */
 
#if AT86RF2XX_IS_PERIPH
typedef void at86rf2xx_params_t;
#else
typedef struct at86rf2xx_params {
    spi_t spi;              
    spi_clk_t spi_clk;      
    spi_cs_t cs_pin;        
    gpio_t int_pin;         
    gpio_t sleep_pin;       
    gpio_t reset_pin;       
} at86rf2xx_params_t;
#endif
 
typedef struct {
    netdev_ieee802154_t netdev;             
#if AT86RF2XX_IS_PERIPH
    /* ATmega256rfr2 signals transceiver events with different interrupts
     * they have to be stored to mimic the same flow as external transceiver
     * Use irq_status to map saved interrupts of SOC transceiver,
     * as they clear after IRQ callback.
     *
     *  irq_status = IRQ_STATUS
     */
    uint8_t irq_status;                     
#else
    /* device specific fields */
    at86rf2xx_params_t params;              
#endif
    uint16_t flags;                         
    uint8_t state;                          
    uint8_t tx_frame_len;                   
#ifdef MODULE_AT86RF212B
    /* Only AT86RF212B supports multiple pages (PHY modes) */
    uint8_t page;                       
#endif
    uint8_t idle_state;                 
    uint8_t pending_tx;                 
#if AT86RF2XX_HAVE_RETRIES
    /* Only radios with the XAH_CTRL_2 register support frame retry reporting */
    int8_t tx_retries;                  
#endif
} at86rf2xx_t;
 
void at86rf2xx_setup(at86rf2xx_t *dev, const at86rf2xx_params_t *params, uint8_t index);
 
void at86rf2xx_reset(at86rf2xx_t *dev);
 
void at86rf2xx_set_addr_short(at86rf2xx_t *dev, const network_uint16_t *addr);
 
void at86rf2xx_set_addr_long(at86rf2xx_t *dev, const eui64_t *addr);
 
uint8_t at86rf2xx_get_phy_mode(at86rf2xx_t *dev);
 
uint8_t at86rf2xx_get_rate(at86rf2xx_t *dev);
 
int at86rf2xx_set_rate(at86rf2xx_t *dev, uint8_t rate);
 
void at86rf2xx_set_pan(at86rf2xx_t *dev, uint16_t pan);
 
void at86rf2xx_set_txpower(const at86rf2xx_t *dev, int16_t txpower, uint8_t channel);
 
int8_t at86rf2xx_get_rxsensitivity(const at86rf2xx_t *dev);
 
void at86rf2xx_set_rxsensitivity(const at86rf2xx_t *dev, int8_t rxsens);
 
uint8_t at86rf2xx_get_max_retries(const at86rf2xx_t *dev);
 
void at86rf2xx_set_max_retries(const at86rf2xx_t *dev, uint8_t max);
 
uint8_t at86rf2xx_get_csma_max_retries(const at86rf2xx_t *dev);
 
void at86rf2xx_set_csma_max_retries(const at86rf2xx_t *dev, int8_t retries);
 
void at86rf2xx_set_csma_backoff_exp(const at86rf2xx_t *dev,
                                    uint8_t min, uint8_t max);
 
void at86rf2xx_set_csma_seed(const at86rf2xx_t *dev, const uint8_t entropy[2]);
 
int8_t at86rf2xx_get_cca_threshold(const at86rf2xx_t *dev);
 
void at86rf2xx_set_cca_threshold(const at86rf2xx_t *dev, int8_t value);
 
int8_t at86rf2xx_get_ed_level(at86rf2xx_t *dev);
 
void at86rf2xx_set_option(at86rf2xx_t *dev, uint16_t option, bool state);
 
uint8_t at86rf2xx_set_state(at86rf2xx_t *dev, uint8_t state);
 
void at86rf2xx_tx_prepare(at86rf2xx_t *dev);
 
size_t at86rf2xx_tx_load(at86rf2xx_t *dev, const uint8_t *data,
                         size_t len, size_t offset);
 
void at86rf2xx_tx_exec(at86rf2xx_t *dev);
 
bool at86rf2xx_cca(at86rf2xx_t *dev);
 
void at86rf2xx_enable_smart_idle(at86rf2xx_t *dev);
 
void at86rf2xx_disable_smart_idle(at86rf2xx_t *dev);
 
#ifdef __cplusplus
}
#endif