SX1278Common.h

Go to the documentation of this file.

/* Copyright (c) 2022 Skyward Experimental Rocketry
 * Author: Davide Mor
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
 
#pragma once
 
#include <drivers/interrupt/external_interrupts.h>
#include <drivers/spi/SPIDriver.h>
#include <miosix.h>
#include <radio/Transceiver.h>
 
#include <cmath>
#include <memory>
 
#include "SX1278Defs.h"
 
namespace Boardcore
{
 
namespace SX1278
{
// The minimum required thread priority to ensure IRQs are handled in a timely
// manner, to avoid packet loss because of high data retrieval latency
static constexpr auto MIN_IRQ_PRIORITY = miosix::PRIORITY_MAX - 2;
 
using DioMapping = RegDioMapping::Mapping;
 
class ISX1278 : public Transceiver
{
public:
    virtual float getLastRxRssi() = 0;
 
    virtual float getLastRxFei() { return std::nanf(""); }
 
    virtual float getLastRxSnr() { return std::nanf(""); }
 
protected:
    /*
     * Stuff used internally by SX1278Common
     */
 
    using IrqFlags = int;
    using Mode     = int;
 
    virtual void setMode(Mode mode)             = 0;
    virtual void setMapping(DioMapping mapping) = 0;
 
    virtual IrqFlags getIrqFlags()             = 0;
    virtual void resetIrqFlags(IrqFlags flags) = 0;
};
 
class ISX1278Frontend
{
public:
    virtual bool isOnPaBoost() = 0;
 
    virtual int maxInPower() = 0;
 
    virtual void enableRx()  = 0;
    virtual void disableRx() = 0;
    virtual void enableTx()  = 0;
    virtual void disableTx() = 0;
};
 
class SX1278Common : public ISX1278
{
private:
    struct DeviceState
    {
        // Current device mode (dummy number to signal no mode)
        Mode mode = -1;
        // Current Dio mapping
        DioMapping mapping = DioMapping();
        // Thread waiting listening for interrupts
        miosix::Thread* irq_wait_thread = nullptr;
        // True if the RX frontend is enabled
        bool is_rx_frontend_on = false;
        // True if the TX frontend is enabled
        bool is_tx_frontend_on = false;
        // Mode of trigger for dio1
        InterruptTrigger dio1_trigger = InterruptTrigger::RISING_EDGE;
    };
 
    // This is reasonably the maximum we should wait for an interrupt
    static constexpr int IRQ_TIMEOUT = 100;
 
public:
    void handleDioIRQ();
 
protected:
    explicit SX1278Common(SPIBus& bus, miosix::GpioPin cs, miosix::GpioPin dio0,
                          miosix::GpioPin dio1, miosix::GpioPin dio3,
                          SPI::ClockDivider clock_divider,
                          std::unique_ptr<ISX1278Frontend> frontend)
        : slave(SPISlave(bus, cs, getSpiBusConfig(clock_divider))), dio0(dio0),
          dio1(dio1), dio3(dio3), frontend(std::move(frontend))
    {
        enableIrqs();
    }
 
    ~SX1278Common() { disableIrqs(); }
 
    class Lock
    {
    public:
        explicit Lock(SX1278Common& driver) : driver(driver) { driver.lock(); }
 
        ~Lock() { driver.unlock(); }
 
    private:
        SX1278Common& driver;
    };
 
    class LockMode
    {
    public:
        LockMode(SX1278Common& driver, Lock& lock, Mode mode,
                 DioMapping mapping, InterruptTrigger dio1_trigger,
                 bool set_tx_frontend_on = false,
                 bool set_rx_frontend_on = false)
            : driver(driver), lock(lock)
        {
            // cppcheck-suppress useInitializationList
            old_state = driver.lockMode(mode, mapping, dio1_trigger,
                                        set_tx_frontend_on, set_rx_frontend_on);
        }
 
        ~LockMode() { driver.unlockMode(old_state); }
 
    private:
        SX1278Common& driver;
        Lock& lock;
        DeviceState old_state;
    };
 
    void setDefaultMode(Mode mode, DioMapping mapping,
                        InterruptTrigger dio1_trigger, bool set_tx_frontend_on,
                        bool set_rx_frontend_on);
 
    IrqFlags waitForIrq(LockMode& guard, IrqFlags set_irq, IrqFlags reset_irq,
                        bool unlock = false);
 
    IrqFlags waitForIrqBusy(LockMode& guard, IrqFlags set_irq,
                            IrqFlags reset_irq, int timeout);
 
    IrqFlags checkForIrqAndReset(IrqFlags set_irq, IrqFlags reset_irq);
 
    ISX1278Frontend& getFrontend();
 
    SPISlave& getSpiSlave();
 
private:
    void enableIrqs();
    void disableIrqs();
 
    bool waitForIrqInner(LockMode& guard, bool unlock);
 
    DeviceState lockMode(Mode mode, DioMapping mapping,
                         InterruptTrigger dio1_trigger, bool set_tx_frontend_on,
                         bool set_rx_frontend_on);
    void unlockMode(DeviceState old_state);
 
    void lock();
    void unlock();
 
    void enterMode(Mode mode, DioMapping mapping, InterruptTrigger dio1_trigger,
                   bool set_tx_frontend_on, bool set_rx_frontend_on);
 
    miosix::FastMutex mutex;
    DeviceState state;
    SPISlave slave;
    miosix::GpioPin dio0;
    miosix::GpioPin dio1;
    miosix::GpioPin dio3;
    std::unique_ptr<ISX1278Frontend> frontend;
};
 
}  // namespace SX1278
 
}  // namespace Boardcore