LoraConnector.cs

using Fraunhofer.Fit.Iot.Lora.Events;
using System;
using System.Text;
using Unosquare.RaspberryIO;
using Unosquare.RaspberryIO.Gpio;

namespace Fraunhofer.Fit.Iot.Lora.lib
{
  public class LoraConnector {
    private Int64 _frequency = 0;
    private Byte _packetIndex = 0;
    private Boolean _implictHeaderMode = false;
    private GpioPin ssPin;
    private GpioPin dio0;
    private GpioPin RST;

    public delegate void DataUpdate(Object sender, DeviceUpdateEvent e);
    public event DataUpdate Update;

    enum Registers : Byte {
      FIFO                  = 0x00,
      OP_MODE               = 0x01,
      FRF_MSB               = 0x06,
      FRF_MID               = 0x07,
      FRF_LSB               = 0x08,
      PA_CONFIG             = 0x09,
      PRE_PA_RAMP           = 0x0A,
      LNA                   = 0x0C,
      FIFO_ADDR_PTR         = 0x0D,
      FIFO_TX_BASE_ADDR     = 0x0E,
      FIFO_RX_BASE_ADDR     = 0x0F,
      FIFO_RX_CURRENT_ADDR  = 0x10,
      IRQ_FLAGS             = 0x12,
      RX_NB_BYTES           = 0x13,
      PKT_SNR_VALUE         = 0x19,
      PKT_RSSI_VALUE        = 0x1A,
      RSSI_VALUE            = 0x1B,
      MODEM_CONFIG_1        = 0x1D,
      MODEM_CONFIG_2        = 0x1E,
      PREAMBLE_MSB          = 0x20,
      PREAMBLE_LSB          = 0x21,
      PAYLOAD_LENGTH        = 0x22,
      MODEM_CONFIG_3        = 0x26,
      FREQ_ERROR_MSB        = 0x28,
      FREQ_ERROR_MID        = 0x29,
      FREQ_ERROR_LSB        = 0x2A,
      RSSI_WIDEBAND         = 0x2C,
      DETECTION_OPTIMIZE    = 0x31,
      DEDECTION_THRESHOLD   = 0x37,
      SYNC_WORD             = 0x39,
      DIO_MAPPING_1         = 0x40,
      VERSION               = 0x42
    };

    enum Modes : Byte {
      SLEEP           = 0x00,
      STDBY           = 0x01,
      TX              = 0x03,
      RX_CONTINOUS    = 0x05,
      RX_SINGLE       = 0x06,
      LONG_RANGE_MODE = 0x80
    };

    enum Pa : Byte {
      BOOST = 0x80
    };

    enum Irq : Byte {
      TX_DONE_MASK = 0x08,
      PAYLOAD_CRC_ERROR_MASK = 0x20,
      RX_DONE_MASK = 0x40
    }

    public LoraConnector(Int64 freq, GpioPin ssPin, GpioPin dio0, GpioPin RST) {
      this.ssPin = ssPin;
      this.dio0 = dio0;
      this.RST = RST;
      this.SetupIO();
      this.Reset();
      Byte version = ReadRegister(Registers.VERSION);
      if(version != 0x12) {
        throw new Exception("Wrong Hardware!");
      }
      this.Sleep();
      this.SetFrequency(freq);
      //set base Addr
      this.WriteRegister(Registers.FIFO_TX_BASE_ADDR, 0);
      this.WriteRegister(Registers.FIFO_RX_BASE_ADDR, 0);
      //set LNA boost
      this.WriteRegister(Registers.LNA, (Byte)(ReadRegister(Registers.LNA) | 0x03));
      //set auto AGC
      this.WriteRegister(Registers.MODEM_CONFIG_3, 0x04);
      this.SetTxPower(17);
      this.Ilde();
    }
    
    #region Methods
    public void Sleep() {
      this.WriteRegister(Registers.OP_MODE, (Byte)Modes.LONG_RANGE_MODE | (Byte)Modes.SLEEP);
    }
    private void Ilde() {
      this.WriteRegister(Registers.OP_MODE, (Byte)Modes.LONG_RANGE_MODE | (Byte)Modes.STDBY);
    }
    public void SetFrequency(Int64 freq) {
      this._frequency = freq;

      UInt64 frf = ((UInt64)freq << 19) / 32000000;
      this.WriteRegister(Registers.FRF_MSB, (Byte)(frf >> 16));
      this.WriteRegister(Registers.FRF_MID, (Byte)(frf >> 8));
      this.WriteRegister(Registers.FRF_LSB, (Byte)(frf >> 0));
    }
    public void SetTxPower(Int32 level, Int32 outputPin = 1) {
      if (outputPin == 1) {
        if(level < 0) {
          level = 0;
        } else if(level > 14) {
          level = 14;
        }
        this.WriteRegister(Registers.PA_CONFIG, (Byte)(0x70 | level));
      } else {
        if(level < 2) {
          level = 2;
        } else if(level > 17) {
          level = 17;
        }
        this.WriteRegister(Registers.PA_CONFIG, (Byte)((Byte)Pa.BOOST | (level - 2)));
      }
    }
    public void EnableCrc() {
      this.WriteRegister(Registers.MODEM_CONFIG_2, (Byte)(this.ReadRegister(Registers.MODEM_CONFIG_2) | 0x04));
    }
    public void SetPrePaRamp() {
      this.WriteRegister(Registers.PRE_PA_RAMP, (Byte)((this.ReadRegister(Registers.PRE_PA_RAMP) & 0xF0) | 0x08));
    }
    public void Receive(Byte size) {
      if (size > 0) {
        this.ImplicitHeaderMode();
        this.WriteRegister(Registers.PAYLOAD_LENGTH, (Byte)(size & 0xff));
      } else {
        this.ExplicitHeaderMode();
      }
      this.WriteRegister(Registers.OP_MODE, (Byte)Modes.LONG_RANGE_MODE | (Byte)Modes.RX_CONTINOUS);
    }
    public void ExplicitHeaderMode() {
      this._implictHeaderMode = false;
      this.WriteRegister(Registers.MODEM_CONFIG_1, (Byte)(this.ReadRegister(Registers.MODEM_CONFIG_1) & 0xfe));
    }

    public void ImplicitHeaderMode() {
      this._implictHeaderMode = true;
      this.WriteRegister(Registers.MODEM_CONFIG_1, (Byte)(this.ReadRegister(Registers.MODEM_CONFIG_1) | 0x01));
    }

    private void OnDio0Rise() {
      Byte irqFlags = this.ReadRegister(Registers.IRQ_FLAGS);

      // clear IRQ's
      this.WriteRegister(Registers.IRQ_FLAGS, irqFlags);

      if ((irqFlags & (Byte)Irq.PAYLOAD_CRC_ERROR_MASK) == 0) {
        // received a packet
        this._packetIndex = 0;

        // read packet length
        Byte packetLength = this._implictHeaderMode ? this.ReadRegister(Registers.PAYLOAD_LENGTH) : this.ReadRegister(Registers.RX_NB_BYTES);

        // set FIFO address to current RX address
        this.WriteRegister(Registers.FIFO_ADDR_PTR, this.ReadRegister(Registers.FIFO_RX_CURRENT_ADDR));

        Byte[] ms = new Byte[packetLength];
        for(Byte i = 0; i < packetLength; i++) {
          Int16 c = this.Read();
          if(c != -1) {
            ms[i] = (Byte)c;
          } else {
            throw new Exception("Message to Short");
          }
        }
        Double snr = this.PacketSnr();
        Byte prssi = this.PacketRssi();
        Byte rssi = this.Rssi();
        this.Update?.Invoke(this, new DeviceUpdateEvent(packetLength, Encoding.ASCII.GetString(ms), snr, prssi, rssi));
        
        // reset FIFO address
        this.WriteRegister(Registers.FIFO_ADDR_PTR, 0);
      }
    }
    #endregion

    #region Communication
    private Byte ReadRegister(Byte address) {
      return this.SingleTransfer((Byte)(address & 0x7F), 0x00);
    }
    private Byte ReadRegister(Registers reg) {
      return ReadRegister((Byte)reg);
    }
    private void WriteRegister(Byte address, Byte value) {
      this.SingleTransfer((Byte)(address | 0x80), value);
    }
    private void WriteRegister(Registers reg, Byte value) {
      this.WriteRegister((Byte)reg, value);
    }
    public Int16 Read() {
      if (this.Available() == 0) {
        return -1;
      }
      this._packetIndex++;
      return this.ReadRegister(Registers.FIFO);
    }
    public Byte Available() {
      return (Byte)(this.ReadRegister(Registers.RX_NB_BYTES) - this._packetIndex);
    }
    public Double PacketSnr() {
      return ((SByte)this.ReadRegister(Registers.PKT_SNR_VALUE)) * 0.25;
    }
    public Byte PacketRssi() {
      return (Byte)(this.ReadRegister(Registers.PKT_RSSI_VALUE) - (this._frequency < 868E6 ? 164 : 157));
    }
    public Byte Rssi() {
      return (Byte)(this.ReadRegister(Registers.RSSI_VALUE) - (this._frequency < 868E6 ? 164 : 157));
    }
    #endregion

    #region Hardware IO
    private void Reset() {
      this.RST.Write(false);
      System.Threading.Thread.Sleep(100);
      this.RST.Write(true);
      System.Threading.Thread.Sleep(100);
    }

    private void SetupIO() {
      Pi.Spi.Channel0Frequency = SpiChannel.MinFrequency;
      this.ssPin.PinMode = GpioPinDriveMode.Output;
      this.dio0.PinMode = GpioPinDriveMode.Input;
      this.RST.PinMode = GpioPinDriveMode.Output;
    }

    private Byte SingleTransfer(Byte address, Byte value) {
      Selectreceiver();
      Byte[] spibuf = Pi.Spi.Channel0.SendReceive(new Byte[] { address, value });
      Unselectreceiver();
      return spibuf[1];
    }

    private void Selectreceiver() {
      this.ssPin.Write(false);
    }

    private void Unselectreceiver() {
      this.ssPin.Write(true);
    }

    public void OnReceive() {
      if (this.Update != null) {
        this.WriteRegister(Registers.DIO_MAPPING_1, 0x00);
        this.dio0.RegisterInterruptCallback(EdgeDetection.RisingEdge, this.OnDio0Rise);
      }
    }
    #endregion
  }
}