CSS.h

Go to the documentation of this file.

#pragma once
 
#include <ctype.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
 
#include "AudioTools.h"
#include "PacketStream.h"
#include "ReedSolomon.h"
 
namespace tinymodem {

struct CSSConfig : public audio_tools::AudioInfo {
  CSSConfig() {
    sample_rate = 48000;
    channels = 1;
    bits_per_sample = 16;
  }

  int spreading_factor = 7;
  float bandwidth = 1000.0f;
  float center_freq = 1500.0f;
  float volume = 1.0f;
  int preamble_symbols = 8;
  int max_frame = 64;
  int ecc_bytes = 8;
  float detect_threshold = 8.0f;
  bool rx_one = false;
  uint8_t channel = 0;
  float rx_noise = 0.0f;

  bool setMode(const char* mode) {
    int sf;
    float bw;
    if (!parseMode(mode, sf, bw)) return false;
    spreading_factor = sf;
    bandwidth = bw;
    return true;
  }

  static bool isMode(const char* mode) {
    int sf;
    float bw;
    return parseMode(mode, sf, bw);
  }

  int chips() const { return 1 << spreading_factor; }

  float symbolTime() const { return chips() / bandwidth; }

  float symbolRate() const { return bandwidth / chips(); }

  float lowFreq() const { return center_freq - bandwidth / 2; }

  bool isValid() const {
    if (spreading_factor < 5 || spreading_factor > 10) {
      LOGE("CSS: the spreading factor must be 5 - 10");
      return false;
    }
    if (bandwidth <= 0 || lowFreq() <= 0) {
      LOGE("CSS: invalid bandwidth or center frequency");
      return false;
    }
    if (center_freq + bandwidth / 2 >= 0.45f * sample_rate) {
      LOGE("CSS: the highest frequency must be below %.1f Hz",
           (double)(0.45f * sample_rate));
      return false;
    }
    if (preamble_symbols < 4 || max_frame < 1 || max_frame > MAX_FRAME ||
        ecc_bytes < 2 || ecc_bytes > RSCodec::MAX_ECC) {
      LOGE("CSS: invalid preamble_symbols, max_frame or ecc_bytes");
      return false;
    }
    return true;
  }

  static constexpr int MAX_FRAME = 200;
  static constexpr int HEADER_ECC = 4;
 
 protected:
  static bool parseMode(const char* mode, int& sf, float& bw) {
    if (mode == nullptr) return false;
    const char* prefix = "css";
    for (int j = 0; j < 3; j++)
      if (tolower(mode[j]) != prefix[j]) return false;
    sf = 7;
    bw = 1000.0f;
    const char* rest = mode + 3;
    if (*rest == 0) return true;
    char* end;
    sf = strtol(rest, &end, 10);
    if (end == rest || sf < 5 || sf > 10) return false;
    if (*end == '-') {
      const char* number = end + 1;
      bw = strtol(number, &end, 10);
      if (end == number || bw < 100) return false;
    }
    return *end == 0;
  }
};

class CSSFrame {
 public:
  static constexpr int HEADER_BYTES = 1 + CSSConfig::HEADER_ECC;

  static int symbols(int bytes, int sf) { return (bytes * 8 + sf - 1) / sf; }

  static int payloadBytes(int len, int ecc) { return len + 2 + ecc; }

  static void header(int len, uint8_t* out) {
    uint8_t msg = len;
    RSCodec::encode(&msg, 1, CSSConfig::HEADER_ECC, out);
  }

  static int decodeHeader(uint8_t* data) {
    if (RSCodec::correct(data, 1, CSSConfig::HEADER_ECC) < 0) return -1;
    int len = data[0];
    return len >= 1 && len <= CSSConfig::MAX_FRAME ? len : -1;
  }

  static void payload(const uint8_t* data, int len, int ecc, uint8_t* out) {
    uint8_t msg[CSSConfig::MAX_FRAME + 2];
    memcpy(msg, data, len);
    uint16_t crc = crc16(data, len);
    msg[len] = crc >> 8;
    msg[len + 1] = crc & 0xFF;
    RSCodec::encode(msg, len + 2, ecc, out);
  }

  static int decodePayload(uint8_t* data, int len, int ecc) {
    int corrected = RSCodec::correct(data, len + 2, ecc);
    if (corrected < 0) return -1;
    uint16_t crc = crc16(data, len);
    if (data[len] != (crc >> 8) || data[len + 1] != (crc & 0xFF)) return -1;
    return corrected;
  }

  static int toSymbols(const uint8_t* data, int len, int sf, uint16_t* out) {
    int n = symbols(len, sf);
    for (int s = 0; s < n; s++) {
      int value = 0;
      for (int b = 0; b < sf; b++) {
        int bit = s * sf + b;
        int v = bit < len * 8 ? (data[bit / 8] >> (7 - bit % 8)) & 1 : 0;
        value = (value << 1) | v;
      }
      out[s] = inverseGray(value);
    }
    return n;
  }

  static void fromSymbols(const uint16_t* symbols, int n, int sf,
                          uint8_t* data, int len) {
    memset(data, 0, len);
    for (int s = 0; s < n; s++) {
      int value = symbols[s] ^ (symbols[s] >> 1);  // Gray code
      for (int b = 0; b < sf; b++) {
        int bit = s * sf + b;
        if (bit >= len * 8) return;
        if ((value >> (sf - 1 - b)) & 1) data[bit / 8] |= 0x80 >> (bit % 8);
      }
    }
  }
 
  static int inverseGray(int g) {
    g ^= g >> 1;
    g ^= g >> 2;
    g ^= g >> 4;
    g ^= g >> 8;
    return g;
  }
};
 
}  // namespace tinymodem