MeshCore/src/helpers/radiolib/RadioLibWrappers.h at 9e03dc63664dba0c483e797bee437d44a6f63d51 · meshcore-dev/MeshCore · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#pragma once

#include <Mesh.h>
#include <RadioLib.h>

class RadioLibWrapper : public mesh::Radio {
protected:
  PhysicalLayer* _radio;
  mesh::MainBoard* _board;
  uint32_t n_recv, n_sent, n_recv_errors;
  int16_t _noise_floor, _threshold;
  uint8_t _busy_count;  // consecutive busy detections for exponential backoff
  uint16_t _num_floor_samples;
  int32_t _floor_sample_sum;

  void idle();
  void startRecv();
  float packetScoreInt(float snr, int sf, int packet_len);
  virtual bool isReceivingPacket() =0;
  virtual void doResetAGC();

public:
  RadioLibWrapper(PhysicalLayer& radio, mesh::MainBoard& board) : _radio(&radio), _board(&board) { n_recv = n_sent = 0; }

  void begin() override;
  virtual void powerOff() { _radio->sleep(); }
  int recvRaw(uint8_t* bytes, int sz) override;
  uint32_t getEstAirtimeFor(int len_bytes) override;
  bool startSendRaw(const uint8_t* bytes, int len) override;
  bool isSendComplete() override;
  void onSendFinished() override;
  bool isInRecvMode() const override;
  bool isChannelActive();

  bool isReceiving() override {
    if (isReceivingPacket()) return true;

    return isChannelActive();
  }

  virtual float getCurrentRSSI() =0;
  virtual uint8_t getCodingRate() const { return 8; }   // default CR4/8, override in subclass
  virtual float getFreqMHz() const { return 0.0f; }     // default unknown, override in subclass
						      //
  bool isJapanMode() const {
    float freq = getFreqMHz();
    return (fabsf(freq - 920.800f) < 0.05f ||
            fabsf(freq - 921.000f) < 0.05f ||
            fabsf(freq - 921.200f) < 0.05f);
  }

  int getMaxTextLen() const {
    if (!isJapanMode()) return 10 * 16;  // default 160 bytes
    uint8_t cr = getCodingRate();
    if (cr <= 5) return 64;  // 3874ms @ SF12/BW125/CR4-5
    if (cr == 6) return 48;  // 3874ms @ SF12/BW125/CR4-6
    if (cr == 7) return 32;  // 3678ms @ SF12/BW125/CR4-7
    return 24;               // 3547ms @ SF12/BW125/CR4-8
  }

  int getMaxGroupTextLen() const {
    if (!isJapanMode()) return 10 * 16;  // default 160 bytes
    uint8_t cr = getCodingRate();
    if (cr <= 5) return 64;  // 3710ms @ SF12/BW125/CR4-5
    if (cr == 6) return 48;  // 3678ms @ SF12/BW125/CR4-6
    if (cr == 7) return 39;  // 3907ms @ SF12/BW125/CR4-7
    return 29;               // 3809ms @ SF12/BW125/CR4-8
  }

  virtual int16_t performChannelScan();

  int getNoiseFloor() const override { return _noise_floor; }
  void triggerNoiseFloorCalibrate(int threshold) override;
  void resetAGC() override;

  void loop() override;

  uint32_t getPacketsRecv() const { return n_recv; }
  uint32_t getPacketsRecvErrors() const { return n_recv_errors; }
  uint32_t getPacketsSent() const { return n_sent; }
  void resetStats() { n_recv = n_sent = n_recv_errors = 0; }

  virtual float getLastRSSI() const override;
  virtual float getLastSNR() const override;

  float packetScore(float snr, int packet_len) override { return packetScoreInt(snr, 10, packet_len); }  // assume sf=10

  virtual void setRxBoostedGainMode(bool) { }
  virtual bool getRxBoostedGainMode() const { return false; }
};

/**
 * \brief  an RNG impl using the noise from the LoRa radio as entropy.
 *         NOTE: this is VERY SLOW!  Use only for things like creating new LocalIdentity
*/
class RadioNoiseListener : public mesh::RNG {
  PhysicalLayer* _radio;
public:
  RadioNoiseListener(PhysicalLayer& radio): _radio(&radio) { }

  void random(uint8_t* dest, size_t sz) override {
    for (int i = 0; i < sz; i++) {
      dest[i] = _radio->randomByte() ^ (::random(0, 256) & 0xFF);
    }
  }
};