OFDM.h

Go to the documentation of this file.

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

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

  int carriers = 32;
  float carrier_spacing = 62.5f;
  float first_freq = 1000.0f;
  float guard = 0.25f;
  float volume = 1.0f;
  int max_frame = 512;
  float sync_threshold = 0.5f;
  bool rx_one = false;
  uint8_t channel = 0;
  float rx_noise = 0.0f;

  bool setMode(const char* mode) {
    int n = modeCarriers(mode);
    if (n == 0) return false;
    carriers = n;
    carrier_spacing = 2000.0f / n;
    first_freq = 1000.0f;
    return true;
  }

  static bool isMode(const char* mode) { return modeCarriers(mode) > 0; }

  int fftSize() const {
    int n = lroundf(sample_rate / carrier_spacing);
    return n + (n & 1);  // even, for the sync symbol
  }

  int prefixSize() const { return lroundf(fftSize() * guard); }

  int firstBin() const {
    int bin = lroundf(first_freq * fftSize() / sample_rate);
    return bin + (bin & 1);
  }

  float carrierFrequency(int idx) const {
    return (float)(firstBin() + idx) * sample_rate / fftSize();
  }

  float symbolRate() const {
    return (float)sample_rate / (fftSize() + prefixSize());
  }

  float bitRate() const { return symbolRate() * carriers * 2; }

  bool isValid() const {
    if (carriers < 4 || carriers > 128) {
      LOGE("OFDM: carriers must be between 4 and 128, not %d", carriers);
      return false;
    }
    if (carrier_spacing <= 0 || first_freq <= 0 || guard < 0 || guard > 0.5f) {
      LOGE("OFDM: invalid carrier_spacing, first_freq or guard");
      return false;
    }
    if (2 * (firstBin() + carriers) >= fftSize()) {
      LOGE("OFDM: the highest carrier %.1f Hz must be below %.1f Hz",
           (double)carrierFrequency(carriers - 1),
           (double)(sample_rate / 2.0f));
      return false;
    }
    if (max_frame < 1 || max_frame > 65535) {
      LOGE("OFDM: invalid max_frame: %d", max_frame);
      return false;
    }
    return true;
  }

  static int headerSymbols(int carriers) { return (32 + carriers - 1) / carriers; }

  static int knownPhase(int symbol, int carrier) {
    uint32_t x = (uint32_t)(carrier + 1) * 2654435761u + symbol * 40503u;
    x ^= x >> 13;
    x *= 0x5bd1e995u;
    x ^= x >> 15;
    return x & 3;
  }
 
 protected:
  static int modeCarriers(const char* mode) {
    if (mode == nullptr) return 0;
    const char* prefix = "ofdm";
    for (int j = 0; j < 4; j++)
      if (tolower(mode[j]) != prefix[j]) return 0;
    int n = atoi(mode + 4);
    return (n == 16 || n == 32 || n == 64) ? n : 0;
  }
};

class OFDMTable {
 public:
  void begin(int size) {
    this->size = size;
    cos_table.resize(size);
    sin_table.resize(size);
    for (int i = 0; i < size; i++) {
      double angle = 2.0 * M_PI * i / size;
      cos_table[i] = cos(angle);
      sin_table[i] = sin(angle);
    }
  }
  float cosine(int i) const { return cos_table[i]; }
  float sine(int i) const { return sin_table[i]; }
 
 protected:
  int size = 0;
  audio_tools::Vector<float> cos_table;
  audio_tools::Vector<float> sin_table;
};
 
}  // namespace tinymodem