src/lib/LR1121Driver/LR1121_hal.cpp

   1 #ifndef UNIT_TEST
   2
   3 #include "LR1121_hal.h"
   4 #include "LR1121_Regs.h"
   5 #include "logging.h"
   6 #include <SPIEx.h>
   7
   8 LR1121Hal *LR1121Hal::instance = NULL;
   9
  10 LR1121Hal::LR1121Hal()
  11 {
  12     instance = this;
  13 }
  14
  15 void LR1121Hal::end()
  16 {
  17     detachInterrupt(GPIO_PIN_DIO1);
  18     if (GPIO_PIN_DIO1_2 != UNDEF_PIN)
  19     {
  20         detachInterrupt(GPIO_PIN_DIO1_2);
  21     }
  22     SPIEx.end();
  23     IsrCallback_1 = nullptr;
  24     IsrCallback_2 = nullptr;
  25 }
  26
  27 void LR1121Hal::init()
  28 {
  29     DBGLN("Hal Init");
  30
  31     pinMode(GPIO_PIN_BUSY, INPUT);
  32     if (GPIO_PIN_BUSY_2 != UNDEF_PIN)
  33     {
  34         pinMode(GPIO_PIN_BUSY_2, INPUT);
  35     }
  36
  37     pinMode(GPIO_PIN_DIO1, INPUT);
  38     if (GPIO_PIN_DIO1_2 != UNDEF_PIN)
  39     {
  40         pinMode(GPIO_PIN_DIO1_2, INPUT);
  41     }
  42
  43     pinMode(GPIO_PIN_NSS, OUTPUT);
  44     digitalWrite(GPIO_PIN_NSS, HIGH);
  45     if (GPIO_PIN_NSS_2 != UNDEF_PIN)
  46     {
  47         pinMode(GPIO_PIN_NSS_2, OUTPUT);
  48         digitalWrite(GPIO_PIN_NSS_2, HIGH);
  49     }
  50
  51 #ifdef PLATFORM_ESP32
  52     SPIEx.begin(GPIO_PIN_SCK, GPIO_PIN_MISO, GPIO_PIN_MOSI, GPIO_PIN_NSS); // sck, miso, mosi, ss (ss can be any GPIO)
  53     gpio_pullup_en((gpio_num_t)GPIO_PIN_MISO);
  54     SPIEx.setFrequency(17500000);
  55     SPIEx.setHwCs(true);
  56     if (GPIO_PIN_NSS_2 != UNDEF_PIN)
  57     {
  58         pinMode(GPIO_PIN_NSS_2, OUTPUT);
  59         digitalWrite(GPIO_PIN_NSS_2, HIGH);
  60         spiAttachSS(SPIEx.bus(), 1, GPIO_PIN_NSS_2);
  61     }
  62     spiEnableSSPins(SPIEx.bus(), SX12XX_Radio_All);
  63 #elif defined(PLATFORM_ESP8266)
  64     DBGLN("PLATFORM_ESP8266");
  65     SPIEx.begin();
  66     SPIEx.setHwCs(true);
  67     SPIEx.setBitOrder(MSBFIRST);
  68     SPIEx.setDataMode(SPI_MODE0);
  69     SPIEx.setFrequency(17500000);
  70 #endif
  71
  72     attachInterrupt(digitalPinToInterrupt(GPIO_PIN_DIO1), this->dioISR_1, RISING);
  73     if (GPIO_PIN_DIO1_2 != UNDEF_PIN)
  74     {
  75         attachInterrupt(digitalPinToInterrupt(GPIO_PIN_DIO1_2), this->dioISR_2, RISING);
  76     }
  77 }
  78
  79 void LR1121Hal::reset(bool bootloader)
  80 {
  81     DBGLN("LR1121 Reset");
  82
  83     if (GPIO_PIN_RST != UNDEF_PIN)
  84     {
  85         if (bootloader)
  86         {
  87             pinMode(GPIO_PIN_BUSY, OUTPUT);
  88             digitalWrite(GPIO_PIN_BUSY, LOW);
  89         }
  90         pinMode(GPIO_PIN_RST, OUTPUT);
  91         digitalWrite(GPIO_PIN_RST, LOW);
  92         if (GPIO_PIN_RST_2 != UNDEF_PIN)
  93         {
  94             if (bootloader)
  95             {
  96                 pinMode(GPIO_PIN_BUSY_2, OUTPUT);
  97                 digitalWrite(GPIO_PIN_BUSY_2, LOW);
  98             }
  99             pinMode(GPIO_PIN_RST_2, OUTPUT);
 100             digitalWrite(GPIO_PIN_RST_2, LOW);
 101         }
 102         delay(1);
 103         digitalWrite(GPIO_PIN_RST, HIGH);
 104         if (GPIO_PIN_RST_2 != UNDEF_PIN)
 105         {
 106             digitalWrite(GPIO_PIN_RST_2, HIGH);
 107         }
 108         delay(300); // LR1121 busy is high for 230ms after reset.  The WaitOnBusy timeout is only 1ms.  So this long delay is required.
 109         if (bootloader)
 110         {
 111             pinMode(GPIO_PIN_BUSY, INPUT);
 112             if (GPIO_PIN_RST_2 != UNDEF_PIN)
 113             {
 114                 pinMode(GPIO_PIN_BUSY_2, INPUT);
 115             }
 116             delay(100);
 117         }
 118     }
 119
 120     WaitOnBusy(SX12XX_Radio_All);
 121 }
 122
 123 void ICACHE_RAM_ATTR LR1121Hal::WriteCommand(uint16_t command, uint8_t *buffer, uint8_t size, SX12XX_Radio_Number_t radioNumber)
 124 {
 125     WORD_ALIGNED_ATTR uint8_t OutBuffer[WORD_PADDED(size + 2)] = {
 126         (uint8_t)((command & 0xFF00) >> 8),
 127         (uint8_t)(command & 0x00FF),
 128     };
 129
 130     memcpy(OutBuffer + 2, buffer, size);
 131
 132     WaitOnBusy(radioNumber);
 133     SPIEx.write(radioNumber, OutBuffer, size + 2);
 134 }
 135
 136 void ICACHE_RAM_ATTR LR1121Hal::WriteCommand(uint16_t command, SX12XX_Radio_Number_t radioNumber)
 137 {
 138     WORD_ALIGNED_ATTR uint8_t OutBuffer[WORD_PADDED(2)] = {
 139         (uint8_t)((command & 0xFF00) >> 8),
 140         (uint8_t)(command & 0x00FF)
 141     };
 142
 143     WaitOnBusy(radioNumber);
 144     SPIEx.write(radioNumber, OutBuffer, 2);
 145 }
 146
 147 void ICACHE_RAM_ATTR LR1121Hal::ReadCommand(uint8_t *buffer, uint8_t size, SX12XX_Radio_Number_t radioNumber)
 148 {
 149     WORD_ALIGNED_ATTR uint8_t InBuffer[WORD_PADDED(size)] = {0};
 150
 151     memcpy(InBuffer, buffer, size);
 152
 153     WaitOnBusy(radioNumber);
 154     SPIEx.read(radioNumber, InBuffer, size);
 155
 156     memcpy(buffer, InBuffer, size);
 157 }
 158
 159 bool ICACHE_RAM_ATTR LR1121Hal::WaitOnBusy(SX12XX_Radio_Number_t radioNumber)
 160 {
 161     constexpr uint32_t wtimeoutUS = 1000U;
 162     uint32_t startTime = 0;
 163
 164     while (true)
 165     {
 166         if (radioNumber == SX12XX_Radio_1)
 167         {
 168             if (digitalRead(GPIO_PIN_BUSY) == LOW) return true;
 169         }
 170         else if (radioNumber == SX12XX_Radio_2)
 171         {
 172             if (GPIO_PIN_BUSY_2 == UNDEF_PIN || digitalRead(GPIO_PIN_BUSY_2) == LOW) return true;
 173         }
 174         else if (radioNumber == SX12XX_Radio_All)
 175         {
 176             if (GPIO_PIN_BUSY_2 != UNDEF_PIN)
 177             {
 178                 if (digitalRead(GPIO_PIN_BUSY) == LOW && digitalRead(GPIO_PIN_BUSY_2) == LOW) return true;
 179             }
 180             else
 181             {
 182                 if (digitalRead(GPIO_PIN_BUSY) == LOW) return true;
 183             }
 184         }
 185         // Use this time to call micros().
 186         uint32_t now = micros();
 187         if (startTime == 0) startTime = now;
 188         if ((now - startTime) > wtimeoutUS) return false;
 189     }
 190 }
 191
 192 void ICACHE_RAM_ATTR LR1121Hal::dioISR_1()
 193 {
 194     if (instance->IsrCallback_1)
 195         instance->IsrCallback_1();
 196 }
 197
 198 void ICACHE_RAM_ATTR LR1121Hal::dioISR_2()
 199 {
 200     if (instance->IsrCallback_2)
 201         instance->IsrCallback_2();
 202 }
 203
 204 #endif // UNIT_TEST