RNode_Firmware/RNode_Firmware.ino

#include <SPI.h>
#include <LoRa.h>
#include "Config.h"
#include "Framing.h"
#include "Utilities.cpp"

void setup() {
  // Seed the PRNG
  randomSeed(analogRead(0));

  // Initialise serial communication
  Serial.begin(serial_baudrate);
  while (!Serial);

  // Configure input and output pins
  pinMode(pin_led_rx, OUTPUT);
  pinMode(pin_led_tx, OUTPUT);

  // Initialise buffers
  memset(pbuf, 0, sizeof(pbuf));
  memset(sbuf, 0, sizeof(sbuf));
  memset(cbuf, 0, sizeof(cbuf));
  
  #if QUEUE_SIZE > 0
    memset(qbuf, 0, sizeof(qbuf));
    memset(queued_lengths, 0, sizeof(queued_lengths));
  #endif

  // Set chip select, reset and interrupt
  // pins for the LoRa module
  LoRa.setPins(pin_cs, pin_reset, pin_dio);

  // Validate board health, EEPROM and config
  validateStatus();
}

bool startRadio() {
  update_radio_lock();
  if (!radio_online) {
    if (!radio_locked && hw_ready) {
      if (!LoRa.begin(lora_freq)) {
        // The radio could not be started.
        // Indicate this failure over both the
        // serial port and with the onboard LEDs
        kiss_indicate_error(ERROR_INITRADIO);
        led_indicate_error(0);
      } else {
        radio_online = true;

        setTXPower();
        setBandwidth();
        setSpreadingFactor();
        setCodingRate();
        getFrequency();

        LoRa.enableCrc();
        LoRa.onReceive(receiveCallback);

        LoRa.receive();

        // Flash an info pattern to indicate
        // that the radio is now on
        led_indicate_info(3);
      }

    } else {
      // Flash a warning pattern to indicate
      // that the radio was locked, and thus
      // not started
      led_indicate_warning(3);
    }
  } else {
    // If radio is already on, we silently
    // ignore the request.
  }
}

void stopRadio() {
  LoRa.end();
  radio_online = false;
}

void update_radio_lock() {
  if (lora_freq != 0 && lora_bw != 0 && lora_txp != 0xFF && lora_sf != 0) {
    radio_locked = false;
  } else {
    radio_locked = true;
  }
}

void receiveCallback(int packet_size) {
  uint8_t header   = LoRa.read(); packet_size--;
  uint8_t sequence = packetSequence(header);
  bool    ready    = false;

  if (isSplitPacket(header) && seq == SEQ_UNSET) {
    // This is the first part of a split
    // packet, so we set the seq variable
    // and add the data to the buffer
    read_len = 0;
    seq = sequence;
    last_rssi = LoRa.packetRssi();
    getPacketData(packet_size);
  } else if (isSplitPacket(header) && seq == sequence) {
    // This is the second part of a split
    // packet, so we add it to the buffer
    // and set the ready flag.
    last_rssi = (last_rssi+LoRa.packetRssi())/2;
    getPacketData(packet_size);
    seq = SEQ_UNSET;
    ready = true;
  } else if (isSplitPacket(header) && seq != sequence) {
    // This split packet does not carry the
    // same sequence id, so we must assume
    // that we are seeing the first part of
    // a new split packet.
    read_len = 0;
    seq = sequence;
    last_rssi = LoRa.packetRssi();
    getPacketData(packet_size);
  } else if (!isSplitPacket(header)) {
    // This is not a split packet, so we
    // just read it and set the ready
    // flag to true.

    if (seq != SEQ_UNSET) {
      // If we already had part of a split
      // packet in the buffer, we clear it.
      read_len = 0;
      seq = SEQ_UNSET;
    }

    last_rssi = LoRa.packetRssi();
    getPacketData(packet_size);
    ready = true;
  }

  if (ready) {
    // We first signal the RSSI of the
    // recieved packet to the host.
    Serial.write(FEND);
    Serial.write(CMD_STAT_RSSI);
    Serial.write((uint8_t)(last_rssi-rssi_offset));

    // And then write the entire packet
    Serial.write(FEND);
    Serial.write(CMD_DATA);
    for (int i = 0; i < read_len; i++) {
      uint8_t byte = pbuf[i];
      if (byte == FEND) { Serial.write(FESC); byte = TFEND; }
      if (byte == FESC) { Serial.write(FESC); byte = TFESC; }
      Serial.write(byte);
    }
    Serial.write(FEND);
    read_len = 0;
  }
}


bool outboundReady() {
  #if QUEUE_SIZE > 0
    if (queue_head != queue_tail) {
      return true;
    } else {
      return false;
    }
  #else
    return outbound_ready;
  #endif
}

bool queueFull() {
  size_t new_queue_head = (queue_head+1)%QUEUE_BUF_SIZE;
  if (new_queue_head == queue_tail) {
    return true;
  } else {
    return false;
  }
}

void enqueuePacket(size_t length) {
  size_t new_queue_head = (queue_head+1)%QUEUE_BUF_SIZE;
  if (new_queue_head != queue_tail) {
    queued_lengths[queue_head] = length;
    size_t insert_addr = queue_head * MTU;
    for (int i = 0; i < length; i++) {
      qbuf[insert_addr+i] = sbuf[i];
    }
    queue_head = new_queue_head;
  } else {
    kiss_indicate_error(ERROR_QUEUE_FULL);
  }
}

#if QUEUE_SIZE > 0
void processQueue() {
  size_t fetch_address = queue_tail*MTU;
  size_t fetch_length  = queued_lengths[queue_tail];

  for (int i = 0; i < fetch_length; i++) {
    tbuf[i] = qbuf[fetch_address+i];
    qbuf[fetch_address+i] = 0x00;
  }

  queued_lengths[queue_tail] = 0;

  queue_tail = ++queue_tail%QUEUE_BUF_SIZE;

  transmit(fetch_length);

  if (!queueFull()) {
    kiss_indicate_ready();
  }
}
#endif

void transmit(size_t size) {
  if (radio_online) {
    led_tx_on();
    size_t  written = 0;
    uint8_t header  = random(256) & 0xF0;

    if (size > SINGLE_MTU - HEADER_L) {
      header = header | FLAG_SPLIT;
    }

    LoRa.beginPacket();
    LoRa.write(header); written++;

    for (size_t i; i < size; i++) {
      #if QUEUE_SIZE > 0
        LoRa.write(tbuf[i]);
      #else
        LoRa.write(sbuf[i]);
      #endif

      written++;

      if (written == 255) {
        LoRa.endPacket();
        LoRa.beginPacket();
        LoRa.write(header);
        written = 1;
      }
    }

    LoRa.endPacket();
    led_tx_off();

    LoRa.receive();

  } else {
    kiss_indicate_error(ERROR_TXFAILED);
    led_indicate_error(5);
  }

  #if QUEUE_SIZE == 0
    if (FLOW_CONTROL_ENABLED)
        kiss_indicate_ready();
  #endif
}

void serialCallback(uint8_t sbyte) {
  if (IN_FRAME && sbyte == FEND && command == CMD_DATA) {
    IN_FRAME = false;

    if (QUEUE_SIZE == 0) {
      if (outbound_ready) {
        kiss_indicate_error(ERROR_QUEUE_FULL);
      } else {
        outbound_ready = true;
      }
    } else {
      enqueuePacket(frame_len);
    }
  } else if (sbyte == FEND) {
    IN_FRAME = true;
    command = CMD_UNKNOWN;
    frame_len = 0;
  } else if (IN_FRAME && frame_len < MTU) {
    // Have a look at the command byte first
    if (frame_len == 0 && command == CMD_UNKNOWN) {
        command = sbyte;
    } else if (command == CMD_DATA) {
        if (sbyte == FESC) {
            ESCAPE = true;
        } else {
            if (ESCAPE) {
                if (sbyte == TFEND) sbyte = FEND;
                if (sbyte == TFESC) sbyte = FESC;
                ESCAPE = false;
            }
            sbuf[frame_len++] = sbyte;
        }
    } else if (command == CMD_FREQUENCY) {
      if (sbyte == FESC) {
            ESCAPE = true;
        } else {
            if (ESCAPE) {
                if (sbyte == TFEND) sbyte = FEND;
                if (sbyte == TFESC) sbyte = FESC;
                ESCAPE = false;
            }
            cbuf[frame_len++] = sbyte;
        }

        if (frame_len == 4) {
          uint32_t freq = (uint32_t)cbuf[0] << 24 | (uint32_t)cbuf[1] << 16 | (uint32_t)cbuf[2] << 8 | (uint32_t)cbuf[3];

          if (freq == 0) {
            kiss_indicate_frequency();
          } else {
            lora_freq = freq;
            if (op_mode == MODE_HOST) setFrequency();
            kiss_indicate_frequency();
          }
        }
    } else if (command == CMD_BANDWIDTH) {
      if (sbyte == FESC) {
            ESCAPE = true;
        } else {
            if (ESCAPE) {
                if (sbyte == TFEND) sbyte = FEND;
                if (sbyte == TFESC) sbyte = FESC;
                ESCAPE = false;
            }
            cbuf[frame_len++] = sbyte;
        }

        if (frame_len == 4) {
          uint32_t bw = (uint32_t)cbuf[0] << 24 | (uint32_t)cbuf[1] << 16 | (uint32_t)cbuf[2] << 8 | (uint32_t)cbuf[3];

          if (bw == 0) {
            kiss_indicate_bandwidth();
          } else {
            lora_bw = bw;
            if (op_mode == MODE_HOST) setBandwidth();
            kiss_indicate_bandwidth();
          }
        }
    } else if (command == CMD_TXPOWER) {
      if (sbyte == 0xFF) {
        kiss_indicate_txpower();
      } else {
        int txp = sbyte;
        if (txp > 17) txp = 17;

        lora_txp = txp;
        if (op_mode == MODE_HOST) setTXPower();
        kiss_indicate_txpower();
      }
    } else if (command == CMD_SF) {
      if (sbyte == 0xFF) {
        kiss_indicate_spreadingfactor();
      } else {
        int sf = sbyte;
        if (sf < 7) sf = 7;
        if (sf > 12) sf = 12;

        lora_sf = sf;
        if (op_mode == MODE_HOST) setSpreadingFactor();
        kiss_indicate_spreadingfactor();
      }
    } else if (command == CMD_CR) {
      if (sbyte == 0xFF) {
        kiss_indicate_codingrate();
      } else {
        int cr = sbyte;
        if (cr < 5) cr = 5;
        if (cr > 8) cr = 8;

        lora_cr = cr;
        if (op_mode == MODE_HOST) setCodingRate();
        kiss_indicate_codingrate();
      }
    } else if (command == CMD_RADIO_STATE) {
      if (sbyte == 0xFF) {
        kiss_indicate_radiostate();
      } else if (sbyte == 0x00) {
        stopRadio();
        kiss_indicate_radiostate();
      } else if (sbyte == 0x01) {
        startRadio();
        kiss_indicate_radiostate();
      }
    } else if (command == CMD_STAT_RX) {
      kiss_indicate_stat_rx();
    } else if (command == CMD_STAT_TX) {
      kiss_indicate_stat_tx();
    } else if (command == CMD_STAT_RSSI) {
      kiss_indicate_stat_rssi();
    } else if (command == CMD_RADIO_LOCK) {
      update_radio_lock();
      kiss_indicate_radio_lock();
    } else if (command == CMD_BLINK) {
      led_indicate_info(sbyte);
    } else if (command == CMD_RANDOM) {
      kiss_indicate_random(getRandom());
    } else if (command == CMD_DETECT) {
      if (sbyte == DETECT_REQ) {
        kiss_indicate_detect();
      }
    } else if (command == CMD_UNLOCK_ROM) {
      if (sbyte == ROM_UNLOCK_BYTE) {
        unlock_rom();
      }
    } else if (command == CMD_ROM_READ) {
      kiss_dump_eeprom();
    } else if (command == CMD_ROM_WRITE) {
      if (sbyte == FESC) {
            ESCAPE = true;
        } else {
            if (ESCAPE) {
                if (sbyte == TFEND) sbyte = FEND;
                if (sbyte == TFESC) sbyte = FESC;
                ESCAPE = false;
            }
            cbuf[frame_len++] = sbyte;
        }

        if (frame_len == 2) {
          eeprom_write(cbuf[0], cbuf[1]);
        }
    } else if (command == CMD_FW_VERSION) {
      kiss_indicate_version();
    } else if (command == CMD_CONF_SAVE) {
      eeprom_conf_save();
    } else if (command == CMD_CONF_DELETE) {
      eeprom_conf_delete();
    }
  }
}

void updateModemStatus() {
  uint8_t status = LoRa.modemStatus();
  last_status_update = millis();
  if (status & SIG_DETECT == 0x01) { stat_signal_detected = true; } else { stat_signal_detected = false; }
  if (status & SIG_SYNCED == 0x01) { stat_signal_synced = true; } else { stat_signal_synced = false; }
  if (status & RX_ONGOING == 0x01) { stat_rx_ongoing = true; } else { stat_rx_ongoing = false; }

  if (stat_signal_detected || stat_signal_synced || stat_rx_ongoing) {
    if (dcd_count < dcd_threshold) {
      dcd_count++;
      dcd = true;
    } else {
      dcd = true;
      dcd_led = true;
    }
  } else {
    if (dcd_count > 0) {
      dcd_count--;
    } else {
      dcd_led = false;
    }
    dcd = false;
  }

  if (dcd_led) {
    led_rx_on();
  } else {
    led_rx_off();
  }
}

void checkModemStatus() {
  if (millis()-last_status_update >= status_interval_ms) {
    updateModemStatus();
  }
}

void validateStatus() {
  if (eeprom_lock_set()) {
    if (eeprom_product_valid() && eeprom_model_valid() && eeprom_hwrev_valid()) {
      if (eeprom_checksum_valid()) {
        hw_ready = true;

        if (eeprom_have_conf()) {
          eeprom_conf_load();
          op_mode = MODE_TNC;
          startRadio();
        }
      }
    } else {
      hw_ready = false;
    }
  } else {
    hw_ready = false;
  }
}

void loop() {
  if (radio_online) {
    checkModemStatus();
    if (outboundReady() && !SERIAL_READING) {
      if (!dcd_waiting) updateModemStatus();
      if (!dcd && !dcd_led) {
        if (dcd_waiting) delay(lora_rx_turnaround_ms);
        updateModemStatus();
        if (!dcd) {
          dcd_waiting = false;
          #if QUEUE_SIZE > 0
            processQueue();
          #else
            outbound_ready = false;
            transmit(frame_len);
          #endif
        }
      } else {
        dcd_waiting = true;
      }
    }
  
  } else {
    if (hw_ready) {
      led_indicate_standby();
    } else {
      led_indicate_not_ready();
      stopRadio();
    }
  }

  if (Serial.available()) {
    SERIAL_READING = true;
    char sbyte = Serial.read();
    serialCallback(sbyte);
    last_serial_read = millis();
  } else {
    if (SERIAL_READING && millis()-last_serial_read >= serial_read_timeout_ms) {
      SERIAL_READING = false;
    }
  }
}