ares_lora_serial.hpp

Go to the documentation of this file.

 
#ifndef ARES_ARES_LORA_SERIAL_HPP
#define ARES_ARES_LORA_SERIAL_HPP
 
#include <ares-lora-serial/ares_frame.hpp>
#include <ares/data-structures/queue.hpp>
#include <ares/serial/serial.hpp>
#include <ares/synchronization/semaphore.hpp>
#include <ares/synchronization/spinlock.hpp>
#include <ares/work-q/task.hpp>
#include <ares/work-q/work_q.hpp>
#include <atomic>
#include <chrono>
#include <exception>
#include <functional>
#include <future>
#include <mutex>
#include <pybind11/pybind11.h>
#include <random>
#include <string>
#include <utility>
 
namespace py = pybind11;
using namespace std::chrono_literals;

class AresTimeoutError : public std::exception {
  public:
    explicit AresTimeoutError(std::string msg) : _msg(std::move(msg)) {}

    [[nodiscard]] const char *what() const noexcept override {
        return _msg.c_str();
    }
 
  private:
    std::string _msg;
};

struct AresSerialConfigs {
    AresSerialConfigs() = default;

    explicit AresSerialConfigs(const py::kwargs &kwargs);

    std::string port;

    std::chrono::milliseconds serial_timeout = 100ms;

    std::chrono::milliseconds response_timeout = 2000ms;

    std::chrono::milliseconds rx_period = 100ms;

    bool master = false;

    std::function<void(int64_t, uint64_t, uint16_t, bool, uint8_t, uint16_t)>
        start_callback = nullptr;

    std::function<void(uint16_t, bool, bool)> heartbeat_callback = nullptr;

    std::function<void(uint16_t)> claim_callback = nullptr;

    std::function<void(uint16_t, uint16_t, uint8_t, uint8_t,
                       const std::string &)>
        log_callback = nullptr;

    double alpha = 1.0;

    double beta = 2.0;

    std::function<void(uint8_t, uint16_t, uint16_t)> packet_rx_callback =
        nullptr;

    std::function<void(uint32_t)> packet_tx_callback = nullptr;
};

struct AresLoraConfig {
    AresLoraConfig() = default;

    explicit AresLoraConfig(const py::kwargs &kwargs);

    uint32_t frequency = 0;

    uint16_t preamble_length = 0;

    uint8_t bandwidth = 0;

    uint8_t datarate = 0;

    uint8_t coding_rate = 0;

    int8_t tx_power = 0;

    [[nodiscard]] AresFrame generate_frame() const;
};

class AresSerial {
  public:
    explicit AresSerial(const AresSerialConfigs &configs);

    ~AresSerial();

    int setting_set(uint16_t id, uint32_t value);

    py::tuple setting_get(uint16_t id);

    int send_start(int64_t sec, uint64_t nsec, uint16_t id, bool broadcast);

    int lora_config(const AresLoraConfig &config);

    void set_response_timeout(const std::chrono::milliseconds &timeout);

    [[nodiscard]] std::chrono::milliseconds get_response_timeout() const;

    py::tuple led(uint8_t id, uint8_t state);

    int send_heartbeat(bool ready, uint8_t tx_cnt);

    py::tuple send_log(const std::string &log_msg, bool broadcast,
                       uint8_t tx_cnt, uint16_t id);

    py::tuple version();

    void set_logging_level(uint32_t level);

    void start();

    void stop();
 
  private:
    Serial::Serial _serial;
    WorkQ _work_q;
    SpinLock _command_lock;
    std::exception_ptr _exception;
 
    void _check_crash();
 
    std::chrono::milliseconds _response_timeout;
    std::chrono::milliseconds _rx_period;
 
    void _process_frames_helper();
    void _process_frames();
 
    void _process_rx_buffer(std::vector<uint8_t> &buf);
    void _read_serial_helper();
    void _read_serial();
 
    struct AresResponse {
        enum ResponseType {
            COMMAND_SPECIFIC, // Command specific response (example: setting
                              // command)
            ACK,              // AresFrameAckErrorCode
            BAD_FRAME,        // AresFrameFramingError
        };
 
        ResponseType type;
        AresFrame::ResponseTypes payload;
    };
 
    void _publish_response(const AresFrame::Decoded &frame);
    void _send_frame(const std::vector<uint8_t> &tx);
    AresResponse _send_frame(AresFrame &frame,
                             const std::chrono::milliseconds &timeout);
    void _send_multi_frame(AresFrame &frame,
                           const std::chrono::milliseconds &timeout,
                           std::vector<AresResponse> &responses);
    AresResponse _wait_response(const std::chrono::milliseconds &timeout);
    AresResponse
    _wait_response_timeout(const std::chrono::milliseconds &timeout);
    AresResponse _wait_response_forever();
 
    std::atomic_bool _tasks_running = false;
 
    Task<void()> _rx_task;
    ares::bounded_queue<AresFrame::Decoded, 10, true> _frame_q;
 
    Task<void()> _processing_task;
    ares::bounded_queue<AresResponse> _response_queue;
 
    std::recursive_mutex _serial_lock;
 
    std::function<void(int64_t, uint64_t, uint16_t, bool, uint8_t, uint16_t)>
        _start_callback = nullptr;
    void _start_event(const AresFrame::Start &start_frame) const;
 
    static void _handle_bad_frame(const AresResponse &response);
 
    struct HeartbeatWork {
        HeartbeatWork(work_handler_t handler, AresSerial *ctx)
            : work(std::move(handler)), obj(ctx) {}
        ~HeartbeatWork() { work.work_flush(); }
        Work work;
        AresSerial *obj;
        uint16_t id = 0;
        ares::semaphore<> sem{};
    };
 
    bool _master;
    uint16_t _claimed_host = 0;
    std::function<void(uint16_t, bool, bool)> _heartbeat_callback = nullptr;
    void _heartbeat_event(const AresFrame::Heartbeat &heartbeat);
    static void _heartbeat_handler(Work *work);
    HeartbeatWork _heartbeat_work;
    int _heartbeat_claim_host(uint16_t destination_id);
 
    std::function<void(uint16_t)> _claim_callback = nullptr;
    void _claim_event(const AresFrame::Claim &claim);
 
    SpinLock _log_spinlock;
    uint16_t _log_id = 0;
    ares::bounded_queue<AresFrame::LogAck> _log_ack_signal;
    void _log_ack_event(const AresFrame::LogAck &ack);
    bool _log_ack_event_wait(const std::chrono::milliseconds &timeout,
                             size_t part, size_t num_parts, uint16_t id);
    void _send_log_frame_directed(AresFrame &frame,
                                  const std::chrono::milliseconds &ack_timeout,
                                  size_t max_attempts,
                                  std::vector<AresResponse> &responses,
                                  uint16_t target);
    std::gamma_distribution<double> _mac_backoff;
    std::random_device _rd;
    std::mt19937 _generator;
    void _handle_ack(uint16_t target, bool acked);
    std::function<void(uint16_t, uint16_t, uint8_t, uint8_t,
                       const std::string &msg)>
        _log_callback = nullptr;
    void _log_event(const AresFrame::Log &log) const;
 
    static py::tuple _decode_version(uint32_t version_num);
 
    static void _debug_event(const AresFrame::Dbg &msg);
 
    std::function<void(uint8_t, uint16_t, uint16_t)> _pkt_rx_cb = nullptr;
    void _packet_rx_event(const AresFrame::PktRx &msg) const;
 
    std::function<void(uint32_t)> _pkt_tx_cb = nullptr;
    void _packet_tx_event(const AresFrame::PktTx &msg) const;
};
 
#endif // ARES_ARES_LORA_SERIAL_HPP