Si446x.h

Go to the documentation of this file.

/*
 * Project: Si4463 Library for AVR and Arduino
 * Author: Zak Kemble, contact@zakkemble.co.uk
 * Copyright: (C) 2017 by Zak Kemble
 * License: GNU GPL v3 (see License.txt)
 * Web: http://blog.zakkemble.co.uk/si4463-radio-library-avr-arduino/
 */

#ifndef SI443X_H_
#define SI443X_H_

#ifdef ARDUINO
#include <Arduino.h>
#endif

#include <stdint.h>

#include "Si446x_config.h"

// Address matching doesnt really work very well as the FIFO still needs to be
// manually cleared after receiving a packet, so the MCU still needs to wakeup and
// do stuff instead of the radio doing things automatically :/
#if !DOXYGEN
#define SI446X_ENABLE_ADDRMATCHING      0
#endif

#define SI446X_MAX_PACKET_LEN   128 

#define SI446X_MAX_TX_POWER     127 

#define SI446X_WUT_RUN  1 
#define SI446X_WUT_BATT 2 
#define SI446X_WUT_RX   4 

#define SI446X_GPIO_PULL_EN     0x40 
#define SI446X_GPIO_PULL_DIS    0x00 
#define SI446X_NIRQ_PULL_EN     0x40 
#define SI446X_NIRQ_PULL_DIS    0x00 
#define SI446X_SDO_PULL_EN      0x40 
#define SI446X_SDO_PULL_DIS     0x00 
#define SI446X_PIN_PULL_EN      0x40 
#define SI446X_PIN_PULL_DIS     0x00 

#define SI446X_GPIO_DRV_HIGH        0x00 
#define SI446X_GPIO_DRV_MED_HIGH    0x20 
#define SI446X_GPIO_DRV_MED_LOW     0x40 
#define SI446X_GPIO_DRV_LOW         0x60 

#define SI446X_PROP_GROUP_GLOBAL        0x00 
#define SI446X_PROP_GROUP_INT           0x01 
#define SI446X_PROP_GROUP_FRR           0x02 
#define SI446X_PROP_GROUP_PREAMBLE      0x10 
#define SI446X_PROP_GROUP_SYNC          0x11 
#define SI446X_PROP_GROUP_PKT           0x12 
#define SI446X_PROP_GROUP_MODEM         0x20 
#define SI446X_PROP_GROUP_MODEM_CHFLT   0x21 
#define SI446X_PROP_GROUP_PA            0x22 
#define SI446X_PROP_GROUP_SYNTH         0x23 
#define SI446X_PROP_GROUP_MATCH         0x30 
#define SI446X_PROP_GROUP_FREQ_CONTROL  0x40 
#define SI446X_PROP_GROUP_RX_HOP        0x50 
#define SI446X_PROP_GROUP_PTI           0xF0 


typedef enum
{
    SI446X_GPIO_MODE_DONOTHING  = 0x00,
    SI446X_GPIO_MODE_TRISTATE   = 0x01,
    SI446X_GPIO_MODE_DRIVE0     = 0x02,
    SI446X_GPIO_MODE_DRIVE1     = 0x03,
    SI446X_GPIO_MODE_INPUT      = 0x04,
    SI446X_GPIO_MODE_32K_CLK    = 0x05,
    SI446X_GPIO_MODE_BOOT_CLK   = 0x06,
    SI446X_GPIO_MODE_DIV_CLK    = 0x07,
    SI446X_GPIO_MODE_CTS        = 0x08,
    SI446X_GPIO_MODE_INV_CTS    = 0x09,
    SI446X_GPIO_MODE_CMD_OVERLAP    = 0x0A,
    SI446X_GPIO_MODE_SDO        = 0x0B,
    SI446X_GPIO_MODE_POR        = 0x0C,
    SI446X_GPIO_MODE_CAL_WUT    = 0x0D,
    SI446X_GPIO_MODE_WUT        = 0x0E,
    SI446X_GPIO_MODE_EN_PA      = 0x0F,
    SI446X_GPIO_MODE_TX_DATA_CLK    = 0x10,
    SI446X_GPIO_MODE_RX_DATA_CLK    = 0x11,
    SI446X_GPIO_MODE_EN_LNA         = 0x12,
    SI446X_GPIO_MODE_TX_DATA        = 0x13,
    SI446X_GPIO_MODE_RX_DATA        = 0x14,
    SI446X_GPIO_MODE_RX_RAW_DATA        = 0x15,
    SI446X_GPIO_MODE_ANTENNA_1_SW       = 0x16,
    SI446X_GPIO_MODE_ANTENNA_2_SW       = 0x17,
    SI446X_GPIO_MODE_VALID_PREAMBLE     = 0x18,
    SI446X_GPIO_MODE_INVALID_PREAMBLE   = 0x19,
    SI446X_GPIO_MODE_SYNC_WORD_DETECT   = 0x1A,
    SI446X_GPIO_MODE_CCA            = 0x1B,
    SI446X_GPIO_MODE_IN_SLEEP       = 0x1C,
    SI446X_GPIO_MODE_PKT_TRACE      = 0x1D,
// Nothing for 0x1E (30)
    SI446X_GPIO_MODE_TX_RX_DATA_CLK = 0x1F,
    SI446X_GPIO_MODE_TX_STATE       = 0x20,
    SI446X_GPIO_MODE_RX_STATE       = 0x21,
    SI446X_GPIO_MODE_RX_FIFO_FULL   = 0x22,
    SI446X_GPIO_MODE_TX_FIFO_EMPTY  = 0x23,
    SI446X_GPIO_MODE_LOW_BATT       = 0x24,
    SI446X_GPIO_MODE_CCA_LATCH      = 0x25,
    SI446X_GPIO_MODE_HOPPED         = 0x26,
    SI446X_GPIO_MODE_HOP_TABLE_WRAP = 0x27
} si446x_gpio_mode_t;

typedef enum
{
    SI446X_NIRQ_MODE_DONOTHING  = 0x00,
    SI446X_NIRQ_MODE_TRISTATE   = 0x01,
    SI446X_NIRQ_MODE_DRIVE0     = 0x02,
    SI446X_NIRQ_MODE_DRIVE1     = 0x03,
    SI446X_NIRQ_MODE_INPUT      = 0x04,
//  SI446X_NIRQ_MODE_32K_CLK    = 0x05,
//  SI446X_NIRQ_MODE_BOOT_CLK   = 0x06,
    SI446X_NIRQ_MODE_DIV_CLK    = 0x07,
    SI446X_NIRQ_MODE_CTS        = 0x08,
//  SI446X_NIRQ_MODE_INV_CTS    = 0x09,
//  SI446X_NIRQ_MODE_CMD_OVERLAP    = 0x0A,
    SI446X_NIRQ_MODE_SDO        = 0x0B,
    SI446X_NIRQ_MODE_POR        = 0x0C,
//  SI446X_NIRQ_MODE_CAL_WUT    = 0x0D,
//  SI446X_NIRQ_MODE_WUT        = 0x0E,
    SI446X_NIRQ_MODE_EN_PA      = 0x0F,
    SI446X_NIRQ_MODE_TX_DATA_CLK    = 0x10,
    SI446X_NIRQ_MODE_RX_DATA_CLK    = 0x11,
    SI446X_NIRQ_MODE_EN_LNA         = 0x12,
    SI446X_NIRQ_MODE_TX_DATA        = 0x13,
    SI446X_NIRQ_MODE_RX_DATA        = 0x14,
    SI446X_NIRQ_MODE_RX_RAW_DATA    = 0x15,
    SI446X_NIRQ_MODE_ANTENNA_1_SW   = 0x16,
    SI446X_NIRQ_MODE_ANTENNA_2_SW   = 0x17,
    SI446X_NIRQ_MODE_VALID_PREAMBLE = 0x18,
    SI446X_NIRQ_MODE_INVALID_PREAMBLE   = 0x19,
    SI446X_NIRQ_MODE_SYNC_WORD_DETECT   = 0x1A,
    SI446X_NIRQ_MODE_CCA            = 0x1B,
//  SI446X_NIRQ_MODE_IN_SLEEP       = 0x1C,
    SI446X_NIRQ_MODE_PKT_TRACE      = 0x1D,
// Nothing for 0x1E (30)
    SI446X_NIRQ_MODE_TX_RX_DATA_CLK = 0x1F,
//  SI446X_NIRQ_MODE_TX_STATE       = 0x20,
//  SI446X_NIRQ_MODE_RX_STATE       = 0x21,
//  SI446X_NIRQ_MODE_RX_FIFO_FULL   = 0x22,
//  SI446X_NIRQ_MODE_TX_FIFO_EMPTY  = 0x23,
//  SI446X_NIRQ_MODE_LOW_BATT       = 0x24,
//  SI446X_NIRQ_MODE_CCA_LATCH      = 0x25,
//  SI446X_NIRQ_MODE_HOPPED         = 0x26,
    SI446X_NIRQ_MODE_NIRQ           = 0x27
} si446x_nirq_mode_t;

typedef enum
{
    SI446X_SDO_MODE_DONOTHING   = 0x00,
    SI446X_SDO_MODE_TRISTATE    = 0x01,
    SI446X_SDO_MODE_DRIVE0      = 0x02,
    SI446X_SDO_MODE_DRIVE1      = 0x03,
    SI446X_SDO_MODE_INPUT       = 0x04,
    SI446X_SDO_MODE_32K_CLK = 0x05,
//  SI446X_SDO_MODE_BOOT_CLK    = 0x06,
    SI446X_SDO_MODE_DIV_CLK = 0x07,
    SI446X_SDO_MODE_CTS     = 0x08,
//  SI446X_SDO_MODE_INV_CTS = 0x09,
//  SI446X_SDO_MODE_CMD_OVERLAP = 0x0A,
    SI446X_SDO_MODE_SDO     = 0x0B,
    SI446X_SDO_MODE_POR     = 0x0C,
//  SI446X_SDO_MODE_CAL_WUT = 0x0D,
    SI446X_SDO_MODE_WUT     = 0x0E,
    SI446X_SDO_MODE_EN_PA       = 0x0F,
    SI446X_SDO_MODE_TX_DATA_CLK = 0x10,
    SI446X_SDO_MODE_RX_DATA_CLK = 0x11,
    SI446X_SDO_MODE_EN_LNA          = 0x12,
    SI446X_SDO_MODE_TX_DATA         = 0x13,
    SI446X_SDO_MODE_RX_DATA         = 0x14,
    SI446X_SDO_MODE_RX_RAW_DATA     = 0x15,
    SI446X_SDO_MODE_ANTENNA_1_SW        = 0x16,
    SI446X_SDO_MODE_ANTENNA_2_SW        = 0x17,
    SI446X_SDO_MODE_VALID_PREAMBLE      = 0x18,
    SI446X_SDO_MODE_INVALID_PREAMBLE    = 0x19,
    SI446X_SDO_MODE_SYNC_WORD_DETECT    = 0x1A,
    SI446X_SDO_MODE_CCA         = 0x1B,
//  SI446X_SDO_MODE_IN_SLEEP        = 0x1C,
//  SI446X_SDO_MODE_PKT_TRACE       = 0x1D,
// Nothing for 0x1E (30)
//  SI446X_SDO_MODE_TX_RX_DATA_CLK  = 0x1F,
//  SI446X_SDO_MODE_TX_STATE        = 0x20,
//  SI446X_SDO_MODE_RX_STATE        = 0x21,
//  SI446X_SDO_MODE_RX_FIFO_FULL    = 0x22,
//  SI446X_SDO_MODE_TX_FIFO_EMPTY   = 0x23,
//  SI446X_SDO_MODE_LOW_BATT        = 0x24,
//  SI446X_SDO_MODE_CCA_LATCH       = 0x25,
//  SI446X_SDO_MODE_HOPPED          = 0x26,
//  SI446X_SDO_MODE_HOP_TABLE_WRAP  = 0x27
} si446x_sdo_mode_t;

typedef struct {
    uint8_t chipRev; 
    uint16_t part; 
    uint8_t partBuild; 
    uint16_t id; 
    uint8_t customer; 
    uint8_t romId; 
    
    uint8_t revExternal; 
    uint8_t revBranch; 
    uint8_t revInternal; 
    uint16_t patch; 
    uint8_t func; 
} si446x_info_t;

typedef enum
{
    SI446X_GPIO0 = 0, 
    SI446X_GPIO1 = 1, 
    SI446X_GPIO2 = 2, 
    SI446X_GPIO3 = 3, 
    SI446X_NIRQ = 4, 
    SI446X_SDO = 5 
} si446x_gpio_t;

typedef enum
{
    SI446X_STATE_NOCHANGE   = 0x00,
    SI446X_STATE_SLEEP      = 0x01, 
    SI446X_STATE_SPI_ACTIVE = 0x02,
    SI446X_STATE_READY      = 0x03,
    SI446X_STATE_READY2     = 0x04, 
    SI446X_STATE_TX_TUNE    = 0x05, 
    SI446X_STATE_RX_TUNE    = 0x06, 
    SI446X_STATE_TX         = 0x07,
    SI446X_STATE_RX         = 0x08
} si446x_state_t;

#if SI446X_ENABLE_ADDRMATCHING
/*-*
* @brief Address modes (NOT SUPPORTED)
*/
typedef enum
{
    SI446X_ADDRMODE_DISABLE,        
    SI446X_ADDRMODE_ADDR,           
    SI446X_ADDRMODE_ADDRBROADCAST   
} si446x_addrMode_t;

#define SI446X_CBS_ADDRMATCH        _BV(7+8)
#define SI446X_CBS_ADDRMISS         _BV(6+8)
#endif

#define SI446X_CBS_SENT             _BV(5+8) 
//#define SI446X_CBS_RXCOMPLETE     _BV(4+8)
//#define SI446X_CBS_RXINVALID      _BV(3+8)
#define SI446X_CBS_RXBEGIN          _BV(0) 
//#define SI446X_CBS_INVALIDSYNC        _BV(5) 

#if defined(__cplusplus)
extern "C" {
#endif

void Si446x_init(void);

void Si446x_getInfo(si446x_info_t* info);

int16_t Si446x_getRSSI(void);

void Si446x_setTxPower(uint8_t pwr);

void Si446x_setupCallback(uint16_t callbacks, uint8_t state);

void Si446x_read(void* buff, uint8_t len);

uint8_t Si446x_TX(void* packet, uint8_t len, uint8_t channel, si446x_state_t onTxFinish);

void Si446x_RX(uint8_t channel);

/*-*
* @brief Changes will be applied next time the radio enters RX mode (NOT SUPPORTED)
*
* @param [mode] TODO
* @param [address] TODO
* @return (none)
*/
//void Si446x_setAddress(si446x_addrMode_t mode, uint8_t address);

void Si446x_setLowBatt(uint16_t voltage);

void Si446x_setupWUT(uint8_t r, uint16_t m, uint8_t ldc, uint8_t config);

void Si446x_disableWUT(void);

uint8_t Si446x_sleep(void);

si446x_state_t Si446x_getState(void);

uint16_t Si446x_adc_gpio(uint8_t pin);

uint16_t Si446x_adc_battery(void);

float Si446x_adc_temperature(void);

void Si446x_writeGPIO(si446x_gpio_t pin, uint8_t value);

uint8_t Si446x_readGPIO(void);

uint8_t Si446x_dump(void* buff, uint8_t group);

#if DOXYGEN || defined(ARDUINO) || SI446X_INTERRUPTS == 0
void Si446x_SERVICE(void);
#else
#define Si446x_SERVICE() ((void)(0))
#endif

#if SI446X_ENABLE_ADDRMATCHING
/*-*
* @brief Set the address in the first byte of the payload TODO
*
* @return (none)
*/
//inline void Si446x_setPacketAddress(uint8_t* data, uint8_t addr)
//{
//  data[0] = addr;
//}

/*-*
* @brief Set the MSB in the 2nd byte of the payload to signify that this is a broadcast transmission TODO
*
* @return (none)
*/
//inline void Si446x_setBroadcast(uint8_t* data)
//{
//  data[1] |= 0x80;
//}

/*-*
* @brief TODO (NOT SUPPORTED)
*
* @return (none)
*/
//inline void Si446x_clearBroadcast(uint8_t* data)
//{
//  data[1] &= ~(0x80);
//}

/*-*
* @brief TODO (NOT SUPPORTED)
*
* @return TODO
*/
//inline uint8_t Si446x_isBroadcast(uint8_t* data)
//{
//  return !!(data[1] & 0x80);
//}

/*-*
* @brief TODO (NOT SUPPORTED)
*
* @return The destination address of the packet
*/
//inline uint8_t Si446x_getPacketAddress(uint8_t* data)
//{
//  return data[0];
//}
#endif

uint8_t Si446x_irq_off(void);

void Si446x_irq_on(uint8_t origVal);

#if DOXYGEN || SI446X_INTERRUPTS != 0

#if !defined(DOXYGEN)
static inline void _Si446x_iRestore(const  uint8_t *__s)
{
    Si446x_irq_on(*__s);
    __asm__ volatile ("" ::: "memory");
}
#endif

#define SI446X_NO_INTERRUPT() \
    for(uint8_t si446x_irq __attribute__((__cleanup__(_Si446x_iRestore))) = Si446x_irq_off(), \
    si446x_tmp = 1; si446x_tmp ; si446x_tmp = 0)

#else
#define SI446X_NO_INTERRUPT() ((void)(0));
#endif

#if defined(__cplusplus)
}
#endif

#endif /* SI443X_H_ */