lora.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Manivannan Sadhasivam
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#ifndef ZEPHYR_INCLUDE_DRIVERS_LORA_H_
#define ZEPHYR_INCLUDE_DRIVERS_LORA_H_

 
#include <stdint.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif

enum lora_signal_bandwidth {
        BW_7_KHZ = 7,           
        BW_10_KHZ = 10,         
        BW_15_KHZ = 15,         
        BW_20_KHZ = 20,         
        BW_31_KHZ = 31,         
        BW_41_KHZ = 41,         
        BW_62_KHZ = 62,         
        BW_125_KHZ = 125,       
        BW_200_KHZ = 200,       
        BW_250_KHZ = 250,       
        BW_400_KHZ = 400,       
        BW_500_KHZ = 500,       
        BW_800_KHZ = 800,       
        BW_1000_KHZ = 1000,     
        BW_1600_KHZ = 1600,     
};

enum lora_datarate {
        SF_5 = 5,       
        SF_6 = 6,       
        SF_7 = 7,       
        SF_8 = 8,       
        SF_9 = 9,       
        SF_10 = 10,     
        SF_11 = 11,     
        SF_12 = 12,     
};

enum lora_coding_rate {
        CR_4_5 = 1,  
        CR_4_6 = 2,  
        CR_4_7 = 3,  
        CR_4_8 = 4,  
};

enum lora_cad_symbol_num {
        LORA_CAD_SYMB_1 = 1,    
        LORA_CAD_SYMB_2 = 2,    
        LORA_CAD_SYMB_4 = 4,    
        LORA_CAD_SYMB_8 = 8,    
        LORA_CAD_SYMB_16 = 16,  
};

enum lora_cad_mode {
        LORA_CAD_MODE_NONE = 0,

        LORA_CAD_MODE_RX,

        LORA_CAD_MODE_LBT,
};

enum lora_gfsk_pulse_shape {
        LORA_GFSK_PULSE_SHAPE_NONE,
        LORA_GFSK_PULSE_SHAPE_BT_0_3,
        LORA_GFSK_PULSE_SHAPE_BT_0_5,
        LORA_GFSK_PULSE_SHAPE_BT_0_7,
        LORA_GFSK_PULSE_SHAPE_BT_1_0,
};

#define LORA_GFSK_SYNC_WORD_MAX 8

#define LORA_GFSK_PREAMBLE_MAX (UINT16_MAX / BITS_PER_BYTE)

struct lora_modem_config_gfsk {
        uint32_t frequency;

        uint32_t bitrate;

        uint32_t freq_deviation;

        uint32_t bandwidth;

        enum lora_gfsk_pulse_shape pulse_shape;

        uint8_t sync_word[LORA_GFSK_SYNC_WORD_MAX];

        uint8_t sync_word_len;

        uint16_t preamble_len;

        int8_t tx_power;

        bool tx;

        bool whitening;

        bool fixed_len;

        uint8_t payload_len;

        bool packet_crc_disable;
};

struct lora_modem_config {
        uint32_t frequency;

        enum lora_signal_bandwidth bandwidth;

        enum lora_datarate datarate;

        enum lora_coding_rate coding_rate;

        uint16_t preamble_len;

        int8_t tx_power;

        uint8_t sync_word;

        bool tx;

        bool iq_inverted;

        bool public_network;

        bool packet_crc_disable;

        struct {
                enum lora_cad_mode mode;

                enum lora_cad_symbol_num symbol_num;

                uint8_t detection_peak;

                uint8_t detection_minimum;
        } cad;
};


typedef void (*lora_recv_cb)(const struct device *dev, uint8_t *data, uint16_t size,
                             int16_t rssi, int8_t snr, void *user_data);

typedef void (*lora_cad_cb)(const struct device *dev, bool activity_detected,
                            void *user_data);

typedef int (*lora_api_config)(const struct device *dev,
                               const struct lora_modem_config *config);

typedef int (*lora_api_config_gfsk)(const struct device *dev,
                                    const struct lora_modem_config_gfsk *config);

typedef uint32_t (*lora_api_airtime)(const struct device *dev, uint32_t data_len);

typedef int (*lora_api_send)(const struct device *dev,
                             uint8_t *data, uint32_t data_len);

typedef int (*lora_api_send_async)(const struct device *dev,
                                   uint8_t *data, uint32_t data_len,
                                   struct k_poll_signal *async);

typedef int (*lora_api_recv)(const struct device *dev, uint8_t *data,
                             uint8_t size,
                             k_timeout_t timeout, int16_t *rssi, int8_t *snr);

typedef int (*lora_api_recv_async)(const struct device *dev, lora_recv_cb cb,
                             void *user_data);

typedef int (*lora_api_cad)(const struct device *dev, k_timeout_t timeout);

typedef int (*lora_api_cad_async)(const struct device *dev, lora_cad_cb cb,
                                  void *user_data);

typedef int (*lora_api_rssi)(const struct device *dev, int16_t *rssi);

typedef int (*lora_api_recv_duty_cycle)(const struct device *dev,
                                        k_timeout_t rx_period,
                                        k_timeout_t sleep_period,
                                        uint8_t *data, uint8_t size,
                                        k_timeout_t timeout,
                                        int16_t *rssi, int8_t *snr);

typedef int (*lora_api_recv_duty_cycle_async)(const struct device *dev,
                                              k_timeout_t rx_period,
                                              k_timeout_t sleep_period,
                                              lora_recv_cb cb, void *user_data);

typedef int (*lora_api_test_cw)(const struct device *dev, uint32_t frequency,
                                int8_t tx_power, uint16_t duration);

__subsystem struct lora_driver_api {
        lora_api_config config;
        lora_api_config_gfsk config_gfsk;
        lora_api_airtime airtime;
        lora_api_send send;
        lora_api_send_async send_async;
        lora_api_recv recv;
        lora_api_recv_async recv_async;
        lora_api_cad cad;
        lora_api_cad_async cad_async;
        lora_api_rssi rssi;
        lora_api_recv_duty_cycle_async recv_duty_cycle_async;
        lora_api_recv_duty_cycle recv_duty_cycle;
        lora_api_test_cw test_cw;
};


static inline int lora_config(const struct device *dev,
                              const struct lora_modem_config *config)
{
        return DEVICE_API_GET(lora, dev)->config(dev, config);
}

static inline int lora_config_gfsk(const struct device *dev,
                                   const struct lora_modem_config_gfsk *config)
{
        const struct lora_driver_api *api = DEVICE_API_GET(lora, dev);
 
        if (api->config_gfsk == NULL) {
                return -ENOSYS;
        }
 
        return api->config_gfsk(dev, config);
}

static inline uint32_t lora_airtime(const struct device *dev, uint32_t data_len)
{
        return DEVICE_API_GET(lora, dev)->airtime(dev, data_len);
}

static inline int lora_send(const struct device *dev,
                            uint8_t *data, uint32_t data_len)
{
        return DEVICE_API_GET(lora, dev)->send(dev, data, data_len);
}

static inline int lora_send_async(const struct device *dev,
                                  uint8_t *data, uint32_t data_len,
                                  struct k_poll_signal *async)
{
        return DEVICE_API_GET(lora, dev)->send_async(dev, data, data_len, async);
}

static inline int lora_recv(const struct device *dev, uint8_t *data,
                            uint8_t size,
                            k_timeout_t timeout, int16_t *rssi, int8_t *snr)
{
        return DEVICE_API_GET(lora, dev)->recv(dev, data, size, timeout, rssi, snr);
}

static inline int lora_recv_async(const struct device *dev, lora_recv_cb cb,
                               void *user_data)
{
        return DEVICE_API_GET(lora, dev)->recv_async(dev, cb, user_data);
}

static inline int lora_cad(const struct device *dev, k_timeout_t timeout)
{
        const struct lora_driver_api *api = DEVICE_API_GET(lora, dev);
 
        if (api->cad == NULL) {
                return -ENOSYS;
        }
 
        return api->cad(dev, timeout);
}

static inline int lora_cad_async(const struct device *dev, lora_cad_cb cb,
                                 void *user_data)
{
        const struct lora_driver_api *api = DEVICE_API_GET(lora, dev);
 
        if (api->cad_async == NULL) {
                return -ENOSYS;
        }
 
        return api->cad_async(dev, cb, user_data);
}

static inline int lora_rssi(const struct device *dev, int16_t *rssi)
{
        const struct lora_driver_api *api = DEVICE_API_GET(lora, dev);
 
        if (api->rssi == NULL) {
                return -ENOSYS;
        }
 
        return api->rssi(dev, rssi);
}

int lora_energy_detect(const struct device *dev, int16_t rssi_threshold, k_timeout_t duration);

static inline int lora_recv_duty_cycle(const struct device *dev,
                                       k_timeout_t rx_period,
                                       k_timeout_t sleep_period,
                                       uint8_t *data, uint8_t size,
                                       k_timeout_t timeout,
                                       int16_t *rssi, int8_t *snr)
{
        const struct lora_driver_api *api = DEVICE_API_GET(lora, dev);
 
        if (api->recv_duty_cycle == NULL) {
                return -ENOSYS;
        }
 
        return api->recv_duty_cycle(dev, rx_period, sleep_period,
                                    data, size, timeout, rssi, snr);
}

static inline int lora_recv_duty_cycle_async(const struct device *dev,
                                             k_timeout_t rx_period,
                                             k_timeout_t sleep_period,
                                             lora_recv_cb cb, void *user_data)
{
        const struct lora_driver_api *api = DEVICE_API_GET(lora, dev);
 
        if (api->recv_duty_cycle_async == NULL) {
                return -ENOSYS;
        }
 
        return api->recv_duty_cycle_async(dev, rx_period, sleep_period, cb, user_data);
}

static inline int lora_test_cw(const struct device *dev, uint32_t frequency,
                               int8_t tx_power, uint16_t duration)
{
        const struct lora_driver_api *api = DEVICE_API_GET(lora, dev);
 
        if (api->test_cw == NULL) {
                return -ENOSYS;
        }
 
        return api->test_cw(dev, frequency, tx_power, duration);
}
 
#ifdef __cplusplus
}
#endif

 
#endif  /* ZEPHYR_INCLUDE_DRIVERS_LORA_H_ */