SX127X voice receive in FSK direct RX mode

[FLN1021]

The FSK direct RX mode of SX127X seems to give threshold limited raw output from the FM discriminator on the data pin (with bitsync off), though lost amplitude information, it seems possible to recover some of the low frequency amplitude (~3k) by sampling at a relatively high speed (~50-100k), then applying a low pass filter. So it may be possible to use SX127X to receive NBFM voice, SSTV, or even APRS, etc. Has anyone tried this yet?

[jgromes]

I'm not aware of his being done before, but it sounds really interesting. I did some experiments trying to get APRS work, but unfortunately without success - though probably due to my lack of DSP skills.

I would be very interested in including this in the library if possible/practical!

[FLN1021]

which method have you tried? did you take look at the correlation methods used by multimon-ng or tried similar methods? Cause I'm also thinking of demod AFSK using SX1276, I currently tried output the bitstream from sx1276 to computer, filter it and send to multimon, it worked. Due to lack of programming skills I don't know how to carry that process on the MCU yet, but it seems theoretically possible. I also tried sstv and voice, it's a bit noisy unfortunately...I can post the results here if you are interested.

[jgromes]

I described it (briefly) in #569, my approach was mostly based on this article, using cross-correlation demodulation, but I never managed to get it working.

[FLN1021]

Thanks for the information, looks like it's harder than I thought. I'll see if there's anything I can find.

[FLN1021]

After some modifications based on the code provided in #569 and code from multimon-ng, I was able to roughly demod AFSK1200 AX25 packet using ESP32+SX1276. I currently tested using a FM demodulated fragment from an APRS IQ sample by sigidwiki, transmitted the fragment through a UHF transceiver at 434mhz twice, and use SX1276 module which is toned to 868mhz to receive it. (unfortunately my sx1276 module is unable to receive LF bands) I was able to get this result from the serial output:

23:32:19.999 -> mode:DIO, clock div:1
23:32:19.999 -> load:0x3fff0030,len:1344
23:32:19.999 -> load:0x40078000,len:13964
23:32:19.999 -> load:0x40080400,len:3600
23:32:19.999 -> entry 0x400805f0
23:32:20.227 -> [SX1278] Initializing ... success!
23:32:28.710 -> RSSI: -64.50 dBm
23:32:30.397 -> 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 39 26 25 45 02 02 4f 75 26 69 05 45 02 86 55 0f 62 8a b0 47 42 7e 7e 7e a2 83 4e 56 19 e9 60 40 5c af 9f af 6d 67 9f f7 57 ed 3f 38 a7 fc 5f cc f3 f3 fc e0 f7 ff 33 af d7 d4 9e df 39 17 ff 6f f8 7d 48 7a a8 bf e1 ce fb 87 af cf 8b fd 7f e7 91 75 fa 87 11 35 9f ff 9f 9c 52 73 3d 22 19 61 0f 63 dd 66 a7 87 39 8e 10 bf f9 e7 3f cf f6 f9 fb 61 8a 4f 39 ff 65 95 7a 42 4e b9 e1 3f 5f f8 44 4e 2f c1 12 7c 63 f3 ff a2 79 3f f3 a8 4f fe de 2f 75 7d b9 b7 9f e7 38 01 27 90 16 02 3c e3 1e ec 9e 43 f3 af cf ad 67 f3 f0 ff f2 75 eb fd 7c 2d 59 fd 7f fe 6b f9 3f 9f fe 58 c8 bf fa ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff 00 
23:32:34.686 -> RSSI: -67.00 dBm
23:32:36.358 -> 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 39 26 25 45 02 02 4f 75 26 69 05 45 02 86 55 0f 62 8a b0 47 42 7e 7e 7e 7a e6 4e 66 19 ce 78 40 9c af f3 69 6e 7e 1c 91 4f 90 c3 4b fc e9 2f 17 ff 27 3c ff b0 7e 7c c2 a7 e6 bc f9 cf db f3 5f f2 79 c8 79 c2 bf 99 ff c3 e7 af d7 eb cf fe b9 04 69 49 47 27 e3 48 7f cc f2 38 4d e6 67 3f ba 8c af fe b9 77 3e ba 08 97 58 7c 81 ff 3c 3b 2a 0b 73 f3 ea 64 f8 73 09 69 e1 5f 6e 98 95 6f fa 11 e7 14 e0 89 0e 01 ff 33 c9 5c f8 bf fc 0f ff 0c e7 58 bf 5a d7 cc c3 90 14 9a c8 73 ce da f1 8f 62 57 26 79 af ff 15 bf 3f 81 95 39 3e 79 fc fe 1c 84 8a df f9 c5 fc ff fe 7f 2c 67 5f fd 7f ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff 00 

It was able to pickup the 0x7E sync, and looks like it was able to demod correctly. However since the current implementation is only to output 256 received bytes after sync is detected regardless of any format, I don't know if it's correct for sure.
Due to the lack of real APRS stations in my area, I was unable to test receiving in the actual scene, so the rx performance remains uncertain. I would appreciate it if anyone could help with testing.
Unfortunately due to usage of ESP32 dsp library it's currently impossible to run this code on platforms other than ESP32, I don't know how to fix that yet due to lack of programming skills.
The code and the test fragment are attached bellow.
APRS_Receive.ino.txt aprs_test.zip

[FLN1021]

small update - I've found this patent, which indicates that the lowpass filter might be unnecessary, that solves the platform-dependent issue if successfully implemented. I'll try this later.

[jgromes]

These are very interesting results indeed - thanks for sharing it! I will try to test this out for myself, it will be especially interesting to see whether we can receive APRS sent from another cheap SX127x transmitter. That would open the door for a closer integration of LoRa devices with the more "legacy" APRS network.

[FLN1021]

Thanks for the reply. Please let me know if you have any updates, especially for the test results. I'm really interested in whether it could work & how the rx performance will be compared to sdr / fm transceivers.

[FLN1021]

An idea came across my mind while reading sx1276's datasheet, that we actually don't need to struggle with the DIO output - the FEI value, which measures the frequency error / bias, is in fact a frequency discriminator. Different from the DIO output, the FEI has much better amplitude resolution. According to the datasheet, the FEI has a freq resolution of ~61Hz(Fstep), therefore we could calculate that in a 12.5khz channel the FEI could provide 12500/fstep which equal to ~203 steps, which is equivalent to ~7 bit resolution - not much, but better than the 1 bit DIO.

However, there's a sampling rate issue with FEI. the FEI is update every 4 bit (I don't find a way to change this), and the bitrate setting is limited to 2*Rxbw (I don't find a way to bypass this either), which gives us a max sampling rate at Rxbw/2, way slower than the DIO which has no limit after bitsync disabled. Fortunately, on a 12.5k channel, the FEI sample rate could reach 6.25k, barely enough to sample the 3k voice signal.

So I modified the previous code to test voice receive based on FEI, it still uses timer interrupt, but transfer the samples to serial instead of any filtering / dsp.

Click to expand

#include <Arduino.h>
#include <RadioLib.h>

// SX1278 has the following connections:
// NSS pin:   10
// DIO0 pin:  2
// RESET pin: 9
// DIO1 pin:  3
SX1276 radio = new Module(18, 26, 23, 33);

hw_timer_t *timer;
const float target_freq = 866.0;
const float ppm = 8.5;
float freq = (float) ((target_freq * ppm) / 1e6 + target_freq);
const float rxbw = 12.5;
const float br = rxbw * 2;

// define buffer for raw samples and lowpass filtered samples.
#define RAW_BUF_LEN 4096
volatile uint16_t buffer_raw[RAW_BUF_LEN];
volatile uint16_t raw_write_pos = 0;
volatile uint16_t raw_read_pos = 0;

uint16_t availRaw() {
    if (raw_write_pos > raw_read_pos)
        return (raw_write_pos - raw_read_pos);
    else
        return (raw_write_pos + (RAW_BUF_LEN - 1) - raw_read_pos);
}

// this function is called on timer interrupt
void IRAM_ATTR onTimer() {
    // read FEI value from SPI register 0x1d & 0x1e
    GPIO.out_w1tc = (1 << LORA_CS);
    uint8_t buf[2];
    SPI.transfer(0x1d & 0x7f);
    SPI.transferBytes(nullptr, buf, 2);
    GPIO.out_w1ts = (1 << LORA_CS);
    // store value to buffer
    uint16_t raw = (buf[0] << 8) | buf[1];
    buffer_raw[raw_write_pos] = raw;
    raw_write_pos = (raw_write_pos + 1) % RAW_BUF_LEN;
}

void setup() {
    Serial.begin(4e6);

    SPI.begin(LORA_SCK, LORA_MISO, LORA_MOSI);

    // Serial.print(F("[SX1278] Initializing ... "));
    // fdev is irrelevant while using FEI.
    radio.beginFSK(freq, br, 2.5, rxbw);
    radio.disableBitSync();
    radio.setRSSIConfig(7);
    // start direct mode reception
    radio.receiveDirect();

    /*
     * According to SX1276 datasheet, the bitrate is no larger than rxBW * 2,
     * and FEI is update every 4 bit without other options, which resulted in the max
     * effective sample rate of rxBW / 2.
     */
    timer = timerBegin(0, 20, true);
    timerAttachInterrupt(timer, &onTimer, true);
    /*
     * The sampling is achieved by hardware timer interrupt, therefore the
     * alarm value is timer clock frequency (APB_CLK_FREQ = 80MHz on ESP32),
     * divided by the divider multiply sampling frequency, which is
     * alarm_value = APB_CLK_FREQ / (divider * sample_freq).
     * In this case, 80e6 / (20 * 0.5 * rxbw * 1e3) = 80e2 / rxbw.
     */
    timerAlarmWrite(timer, (int) (80e2 / rxbw), true);
    timerAlarmEnable(timer);
}

void loop() {
    // Send samples to serial.
    if (availRaw() >= 32) {
        uint8_t uart_buf[64];
        for (int i = 0; i < 32; ++i) {
            uint16_t raw = buffer_raw[raw_read_pos];
            uart_buf[2 * i] = raw & 0xFF;
            uart_buf[2 * i + 1] = (raw >> 8) & 0xFF;
            raw_read_pos = (raw_read_pos + 1) % RAW_BUF_LEN;
        }
        Serial.write(uart_buf, 64);
        Serial.flush();
    }
}

On the computer I use a simple python script to receive the samples.

Click to expand

import serial
import numpy as np
import pyaudio

ser = serial.Serial("COM3", 4000000)

sampling_rate = 6250

buffer_size = 128
audio_buffer = np.zeros(buffer_size, dtype=np.int16)

p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paInt16, channels=1, rate=sampling_rate, output=True)
with open("output.bin", "wb") as file:
    while True:
        raw_bytes = ser.read(buffer_size * 2)
        if len(raw_bytes) == buffer_size * 2:
            int_samples = np.frombuffer(raw_bytes,dtype='<i2')
            # int_samples = int_samples  * 8
            # print(int_samples)
            file.write(raw_bytes)
            file.flush()
            # be careful of the volume while streaming to audio device!
            stream.write(int_samples.tobytes())

Using this script I was able to record the samples and stream them to audio devices as well. I tested this with SSTV by transmitting on 433, receiving on 866 and sending the samples to MMSSTV software, here's the result:

The above are transmitted in PD50 and Robot36, I've also tried PD90:

The noise line in the image are possibly cause by problems in my code, it appears about every 80 seconds, preventing the usage of PD90 or longer sstv modes. I was unable to fix this problem due to lack of programming skills, so any help is appreciated. I assume that the problem is in the serial part or the buffer part, but I can't find it.

I currently didn't try demodulate AFSK or other modes using this method yet, I guess it can be better than the DIO method? But the DIO has higher sampling rate, so I can't be sure...However I think the FEI method can open up possibility to modulation schemes require amplitude info, such as 4FSK(maybe DMR is possible, but the sample rate seems not enough), which is impossible for DIO since the DIO-lowpass method is in fact just reconstruct the waveform, it does not and can not recover amplitude info, I've made a mistake on that previously. The AFSK only depends on freq info, so DIO-lowpass can work.

The samples of sstv and some audio tests stored by the python script are attached bellow.
test_samples.zip

[jgromes]

These are very interesting results - thanks for sharing them!

I tested this with SSTV by transmitting on 433, receiving on 866

Not completely sure I follow - why was it necessary to receive at 2x the original frequency?

On a side note, the FEI is also available on the SX126x series, so if we could get this working there it would be a very interesting addition.

[FLN1021]

It is not - I am using TTGO's board and it's sx1276 module's RFI_LF is not connected to the antenna, so it can't receive anything outside band 1. But my transmitter could only tx on 400-470, so I have to use the 2nd harmonic to test the receive.
I indeed notice that sx126x have FEI, but it seems only available in lora mode, and was only able to output last packet's FEI, I didn't find a way to let it work in real time. In fact I don't even know where the registers about FEI came from, It is not mentioned on SX1262,1268 or 1280's datasheet(1280 indeed mentioned 0x954,955,956, but not 0x76b). Do you have any additional information about that?