ESP32 RTX via HAM Radio

[Rino664]

Hi, I'm trying to use your beautifull library to implement a repeter telemetry and commands.
I have modified the ESP32 RX including also the TX (now send only a fix text every 15 sec).
It works but with a strange effect in the RX, it double the receved string in the serial output.

Here the code:
`
// ### Analog Microphone
//
// | MCU | Mic |
// | ------- | --------- |
// | GND | GND |
// | 3.3V | VCC / VDD |
// | GPIO 35 | Out |
//

const int kPinSpeaker = 14;
#define MIC_ANALOG
#include <ggwave.h>
#include <soc/adc_channel.h>
#include <driver/i2s.h>

// Pin configuration
const int kPinLED0 = 2;

// Global GGwave instance
GGWave ggwave;

char txt[64];
#define P(str) (strcpy_P(txt, PSTR(str)), txt)

// Audio capture configuration
using TSample = int16_t;
using TSampleInput = int16_t;
const size_t kSampleSize_bytes = sizeof(TSample);
// High sample rate - better quality, but more CPU/Memory usage
const int sampleRate = 24000;
const int samplesPerFrame = 512;

TSample sampleBuffer[samplesPerFrame];
TSampleInput * sampleBufferRaw = sampleBuffer;

const i2s_port_t i2s_port = I2S_NUM_0;

// ADC configuration
const adc_unit_t adc_unit = ADC_UNIT_1;
const adc1_channel_t adc_channel = ADC1_GPIO35_CHANNEL;

// i2s config for using the internal ADC
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX | I2S_MODE_ADC_BUILT_IN),
.sample_rate = sampleRate,
.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_RIGHT,
.communication_format = I2S_COMM_FORMAT_I2S_LSB,
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 4,
.dma_buf_len = samplesPerFrame,
.use_apll = false,
.tx_desc_auto_clear = false,
.fixed_mclk = 0
};

// Helper function to output the generated GGWave waveform via a buzzer
void send_text(GGWave & ggwave, uint8_t pin, const char * text, GGWave::TxProtocolId protocolId) {

Serial.print(F("Sending text: "));
Serial.println(text);

ggwave.init(text, protocolId);
ggwave.encode();

const auto & protocol = GGWave::Protocols::tx()[protocolId];
const auto tones = ggwave.txTones();
const auto duration_ms = protocol.txDuration_ms(ggwave.samplesPerFrame(), ggwave.sampleRateOut());
for (auto & curTone : tones) {
    const auto freq_hz = (protocol.freqStart + curTone)*ggwave.hzPerSample();
    tone(pin, freq_hz);
    delay(duration_ms);
}

noTone(pin);
digitalWrite(pin, LOW);

}

void setup() {
Serial.begin(115200);
while (!Serial);
pinMode(kPinLED0, OUTPUT);
digitalWrite(kPinLED0, LOW);

// Initialize "ggwave"
{
    Serial.println(F("Trying to initialize the ggwave instance"));
    ggwave.setLogFile(nullptr);
    auto p = GGWave::getDefaultParameters();
    // Adjust the "ggwave" parameters to your needs.
    // Make sure that the "payloadLength" parameter matches the one used on the transmitting side.
    p.payloadLength   = 16;

    Serial.print(F("Using payload length: "));
    Serial.println(p.payloadLength);

    p.sampleRateInp   = sampleRate;
    p.sampleRateOut   = sampleRate;
    p.sampleRate      = sampleRate;
    p.samplesPerFrame = samplesPerFrame;
    p.sampleFormatInp = GGWAVE_SAMPLE_FORMAT_I16;
    p.sampleFormatOut = GGWAVE_SAMPLE_FORMAT_U8;
    p.operatingMode   = GGWAVE_OPERATING_MODE_RX | GGWAVE_OPERATING_MODE_TX | GGWAVE_OPERATING_MODE_USE_DSS | GGWAVE_OPERATING_MODE_TX_ONLY_TONES;

    GGWave::Protocols::tx().disableAll();
    //GGWave::Protocols::tx().toggle(GGWAVE_PROTOCOL_MT_NORMAL,  true);
    //GGWave::Protocols::tx().toggle(GGWAVE_PROTOCOL_MT_FAST,    true);
    GGWave::Protocols::tx().toggle(GGWAVE_PROTOCOL_MT_FASTEST, true);

    // Protocols to use for RX
    // Remove the ones that you don't need to reduce memory usage
    GGWave::Protocols::rx().disableAll();
    //GGWave::Protocols::rx().toggle(GGWAVE_PROTOCOL_DT_NORMAL,  true);

    GGWave::Protocols::rx().toggle(GGWAVE_PROTOCOL_DT_FASTEST, true);
    //GGWave::Protocols::rx().toggle(GGWAVE_PROTOCOL_MT_NORMAL,  true);

    GGWave::Protocols::rx().toggle(GGWAVE_PROTOCOL_MT_FASTEST, true);
    ggwave.prepare(p, false);

    Serial.print(F("Required memory by the ggwave instance: "));
    Serial.print(ggwave.heapSize());
    Serial.println(F(" bytes"));

    // Initialize the "ggwave" instance:
    ggwave.prepare(p, true);
    Serial.print(F("Instance initialized successfully! Memory used: "));
}

// Start capturing audio
{
    Serial.println(F("Initializing I2S interface"));

    // Install and start i2s driver
    i2s_driver_install(i2s_port, &i2s_config, 0, NULL);


    Serial.println(F("Using analog input - initializing ADC"));

    // Init ADC pad
    i2s_set_adc_mode(adc_unit, adc_channel);

    // Enable the adc
    i2s_adc_enable(i2s_port);

    Serial.println(F("I2S ADC started"));

}

}

int niter = 0;
int tLastReceive = -10000;
GGWave::TxRxData result;

unsigned long t0=millis();

void loop() {

// Read from i2s
{
    size_t bytes_read = 0;
    i2s_read(i2s_port, sampleBufferRaw, sizeof(TSampleInput)*samplesPerFrame, &bytes_read, portMAX_DELAY);

    int nSamples = bytes_read/sizeof(TSampleInput);
    if (nSamples != samplesPerFrame) {
        Serial.println("Failed to read samples");
        return;
    }


    // the ADC samples are 12-bit so we need to do some massaging to make them 16-bit
    for (int i = 0; i < nSamples; i += 2) {
        auto & s0 = sampleBuffer[i];
        auto & s1 = sampleBuffer[i + 1];

        s0 = s0 & 0x0fff;
        s1 = s1 & 0x0fff;

        s0 = s0 ^ s1;
        s1 = s0 ^ s1;
        s0 = s0 ^ s1;
    }

}

// Try to decode any "ggwave" data:
auto tStart = millis();

if (ggwave.decode(sampleBuffer, samplesPerFrame*kSampleSize_bytes) == false) {
    Serial.println("Failed to decode");
}

auto tEnd = millis();
if (++niter % 10 == 0) {
    if (tEnd - tStart > 1000*(float(samplesPerFrame)/sampleRate)) {
        Serial.println(F("Warning: decode() took too long to execute!"));
    }
}

// Check if we have successfully decoded any data:
int nr = ggwave.rxTakeData(result);
if (nr > 0) {
    Serial.println("ecco");
    Serial.println((char *) result.data());
    tLastReceive = tEnd;
}

if(t0+15000<millis()){
send_text(ggwave, kPinSpeaker, P("Hello!"), GGWAVE_PROTOCOL_MT_FASTEST);
t0=millis(); 
size_t bytes_read = 0;
}

}`

Many thanks
Rino.

[ggerganov]

I guess it can sometimes decode the message from partial data while the sliding window is "viewing" part of the message. Probably the you can ignore messages that have been decoded in very quick succession, or you can add a message ID (or parity bit) to your payload to be able to recognize when a new message is received

[Rino664]

Many thanks for your suggestions; I have found the way: after one receves string I have resetted the "GGWave" istance like this:

`void reset_RX_Buffer(){
ggwave.setLogFile(nullptr);
auto p = GGWave::getDefaultParameters();
p.payloadLength = 16;
p.sampleRateInp = sampleRate;
p.sampleRateOut = sampleRate;
p.sampleRate = sampleRate;
p.samplesPerFrame = samplesPerFrame;
p.sampleFormatInp = GGWAVE_SAMPLE_FORMAT_I16;
p.sampleFormatOut = GGWAVE_SAMPLE_FORMAT_U8;
p.operatingMode = GGWAVE_OPERATING_MODE_RX | GGWAVE_OPERATING_MODE_TX | GGWAVE_OPERATING_MODE_USE_DSS | GGWAVE_OPERATING_MODE_TX_ONLY_TONES;

    GGWave::Protocols::tx().disableAll();
    GGWave::Protocols::tx().toggle(GGWAVE_PROTOCOL_MT_FASTEST, true);

    GGWave::Protocols::rx().disableAll();
    GGWave::Protocols::rx().toggle(GGWAVE_PROTOCOL_MT_FASTEST, true);
    ggwave.prepare(p, false);
    ggwave.prepare(p, true);

}`

Now I can receive only one string !

But, even before this modification @ the first TX text, I got an initialization error like this:
Sending text: Hello!
E (30113) ledc: ledc_get_duty(740): LEDC is not initialized
Sending text: Hello!
Sending text: Hello!
Sending text: Hello!

Do you know form my previous code where is the problem ?

Many thanks
Rino.