alh477/demod-fausdr repository overview

┌─────────────────────────────────────────────────────────────────┐
│  Haskell                                                         │
│                                                                  │
│  DeModFrame  ──encodeFrame──►  ByteString (17 bytes)            │
│                                        │                         │
│                             encodeBpsk (BPSK NRZ-L)             │
│                                        │                         │
│                             Vector Float (symbol stream)         │
│                          ┌───── FFI ───┘                        │
└──────────────────────────┼──────────────────────────────────────┘
                           │
┌──────────────────────────▼──────────────────────────────────────┐
│  Faust  (modulator_hs.dsp → modulator_hs_gen.rs, Rust FFI)       │
│                                                                  │
│  inputs[0]: symbol stream (±1.0 NRZ)                            │
│  → 63-tap Kaiser-windowed RRC FIR (α=0.35, β=8.0)              │
│  → Phase modulation onto NCO carrier                             │
│  outputs[0] = I,  outputs[1] = Q                                │
│                          ┌───── FFI ───┐                        │
└──────────────────────────┼──────────────────────────────────────┘
                           │
┌──────────────────────────▼──────────────────────────────────────┐
│  SoapySDR  (soapy_bridge.cpp)                                    │
│  Interleaved CF32 → writeStream → RF hardware                   │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│  SoapySDR  (soapy_bridge.cpp — RX path)                          │
│  RF hardware → readStream → Interleaved CF32                    │
│                          ┌───── FFI ───┘                        │
└──────────────────────────┼──────────────────────────────────────┘
                           │
┌──────────────────────────▼──────────────────────────────────────┐
│  Faust  (bpsk_demod.dsp → bpsk_demod_gen.rs, Rust FFI)           │
│                                                                  │
│  inputs[0]=I, inputs[1]=Q                                        │
│  → Costas loop (2nd-order, ζ=0.707) — carrier recovery          │
│  → 63-tap RRC matched filter (same coefficients as TX FIR)      │
│  outputs[0]: soft symbols ∈ ℝ                                   │
│                          ┌───── FFI ───┐                        │
└──────────────────────────┼──────────────────────────────────────┘
                           │
┌──────────────────────────▼──────────────────────────────────────┐
│  Haskell  (DCF.Demodulator)                                      │
│                                                                  │
│  sliceSoftSymbols (downsample by sps, threshold at 0)           │
│  bitsToBytes                                                     │
│  findFrame (sliding window sync search)                          │
│  decodeFrame + CRC validate                                      │
│  → Maybe DeModFrame                                              │
└─────────────────────────────────────────────────────────────────┘

 0       1       2-3     4-5     6-7     8-11    12-14   15-16
┌───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┐
│ SYNC  │ FLAGS │  SEQ  │SRC_ID │DST_ID │PAYLOAD│  TS   │ CRC16 │
│ 0xD3  │vvvvtttt│ BE u16│       │       │4 bytes│24-bit │CCITT  │
└───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┘
  1 B     1 B    2 B     2 B     2 B     4 B     3 B     2 B

 0       1       2-5       6-7
┌───────┬───────┬──────────┬───────┐
│ SYNC  │  HDR  │ PAYLOAD  │ CRC16 │
│ 0xA5  │ssssttt│  4 bytes │ CCITT │
└───────┴───────┴──────────┴───────┘
  1 B     1 B      4 B       2 B

Wire: A5 01 DE AD BE EF C2 3F    CRC pin: 0xC23F

Bytes [0..14]:  D3 10 00 01  00 01 FF FF  DE AD BE EF  00 00 00
CRC   [15..16]: 42 DD
Full frame:     D3 10 00 01 00 01 FF FF DE AD BE EF 00 00 00 42 DD

magic(1) version(1) type(1) seq(4 BE) timestamp_us(8 BE)
sender_len(1) sender(N) recipient_len(1) recipient(M)
group_id_len(1) group_id(G) data_len(4 BE) data(D)
msg_id_len(1) msg_id(I)

cd haskell && nix develop
faust-all-mod     # compile all modulator DSP files → *_gen.rs (once per DSP change)
cabal-build && cabal-test
cabal run demod-sdr-hs -- --driver rtlsdr --freq 433.92e6 --rate 2e6 --gain 20

cd haskell && nix develop
cabal run demod-rx-hs -- --driver rtlsdr --freq 433.92e6 --rate 2e6 --gain 40

nix develop
cmake -B build -G Ninja
faust-all-mod && faust-all-demod && faust-all-audio   # compile all DSP → *_gen.rs
cmake --build build
ctest --test-dir build -V                    # conformance + frame tests
./build/demod-sdr

cd dcf/rust && cargo test

cd dcf/go && go test -v

sbcl --load hydramesh.lisp --eval '(run-tests)'

cd gr-demod
cmake -B build && cmake --build build && sudo cmake --install build
python3 -m pytest python/demod/qa_dcf_frame.py -v   # no hardware required

cd dcf/c_sdk/plugins
gcc -shared -fPIC -o libdcf_sdr_transport.so sdr_transport.c -lcjson -lpthread
# config.json: "transport": "libdcf_sdr_transport.so"
# demod-sdr-hs must be running to open the named pipes

cd haskell && nix develop

# 1. Compile the acoustic DSP (once per change):
faust-all-audio   # compiles acoustic_fsk_mod.dsp + acoustic_fsk_demod.dsp → *_gen.rs

# 2. Build:
cabal build acoustic-hello-tx acoustic-hello-rx

# 3. Machine B — start listener first:
cabal run acoustic-hello-rx

# 4. Machine A — interactive TX prompt:
cabal run acoustic-hello-tx
# send> HELLO
# send> DeMoD LLC
# send>        ← empty line to quit

pactl load-module module-null-sink sink_name=loopback
pactl load-module module-loopback source=loopback.monitor
# run TX and RX in separate terminals — they talk through PipeWire

ITransport* dcf_transport_create(void) {
    ITransport* tp    = calloc(1, sizeof(ITransport));
    tp->name          = "my-transport";
    tp->version_major = 1;    // must be >= 1.1
    tp->version_minor = 1;
    tp->setup         = my_setup;
    tp->send          = my_send;
    tp->receive       = my_receive;
    tp->health_check  = my_health_check;
    tp->destroy       = my_destroy;
    return tp;
}

{
  "node_id":    "node-alpha",
  "mode":       "p2p",
  "listen_addr": "0.0.0.0:9000",
  "peers":      ["10.0.0.2:9000"],
  "plugins": {
    "transport": "libdcf_sdr_transport.so",
    "hardware":  { "i2c_sensor": "libi2c_sensor.so" }
  },
  "transport_params": {
    "tx_pipe":          "/tmp/dcf_sdr_tx",
    "rx_pipe":          "/tmp/dcf_sdr_rx",
    "frame_timeout_ms": 500
  },
  "timeout_ms": 5000,
  "retries":    3,
  "redundancy": { "enabled": true, "reroute_timeout_s": 10 }
}

nix build .#docker
docker load < result
# Acoustic TX — mount host PipeWire/JACK socket:
docker run --rm -it \
  -v /run/user/1000/pipewire-0:/run/user/1000/pipewire-0 \
  -v /run/user/1000/jack:/run/user/1000/jack \
  demod-faust-sdr:latest acoustic-hello-tx
# SDR TX — pass through USB device:
docker run --rm -it --device /dev/bus/usb \
  demod-faust-sdr:latest demod-sdr-hs

nix build .#appimage-hello-tx && chmod +x result && ./result
nix build .#appimage-hello-rx && chmod +x result && ./result
nix build .#appimage-sdr-tx   && chmod +x result && ./result
nix build .#appimage-sdr-rx   && chmod +x result && ./result

nix build .#tarball
tar xf result/demod-faust-sdr.tar.gz
./demod-faust-sdr/run acoustic-hello-tx
./demod-faust-sdr/run demod-sdr-hs

nix build .#bundle-hello-tx   # → single self-extracting shell script
nix build .#bundle-hello-rx
# or, using the nix-appimage bundler:
nix bundle --bundler github:ralismark/nix-appimage .#hello-tx