system latency

YHZ

I'm doing acoustic ranging with Bela Gem Multi. TX via audioWrite(), RX via two mics on analog IN2/IN4. Using dtau = t_mic4 - t_mic2 cancels system latency.
I want to replace one mic with a hardware loopback (analog OUT → dupont wire → analog IN). The principle is the same — both signals share the same ADC subsystem, so subtracting cancels system latency.
Problem: analogOutChannels stays 0 despite IDE setting. analogWrite() segfaults. Field is const.
How to enable analog output on Gem Multi? Or any other way to get an electrical reference without a second mic?

giuliomoro

They are audio outputs, so you need to use audioWrite(). The analog channels setting is for inputs only.
Also note that channels 0 and 1 have different latency behaviour than all other channels. They are different chips and use different decimating filters and group delay.

Channels 0 and 1: ADC/DAC is TLV320AIC3106
Channels 2 through 9: ADC is TLV320ADC3140, DAC is ES9080Q

YHZ

Thank you for the clarification on the ADC chips — that's very helpful.
My core question is actually simpler: How can I cancel system latency with just one microphone on the Bela Gem Multi? I want to use a dupont wire to loop the output signal back to an input as a timing reference, so I can subtract out the ADC/DAC delay. Is there a recommended wiring diagram or example for this single-mic + loopback approach?

YHZ

One more issue: the pins/components for analog input channels 2 and 3 on my Bela Gem Multi have physically broken off / come loose. Is this repairable?

giuliomoro

YHZ One more issue: the pins/components for analog input channels 2 and 3 on my Bela Gem Multi have physically broken off / come loose. Is this repairable?

It should be easy enough to desolder them and put a new header in if you have a bit of experience with the soldering iron.

YHZ want to use a dupont wire to loop the output signal back to an input as a timing reference, so I can subtract out the ADC/DAC delay. Is there a recommended wiring diagram

You just described the wiring, what additional information do you need?

YHZ

giuliomoro
My current wiring setup is as follows:

The 3.5 mm audio jack is connected to a speaker using a 3.5 mm audio cable. Then, Channel 2 of the 3.5 mm interface is connected to Input 5 using a Dupont wire. Input 4 is connected to a microphone.

Is this wiring configuration correct?

Also, why does the output from my current code sound like noise? It is different from what I obtained previously.

YHZ

Why does the exact same code work correctly when connected to the Channel 1 3.5 mm jack, but produce only noise when connected to the Channel 2 jack?

YHZ

#include <Bela.h>
#include <vector>
#include <fstream>
#include <string>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

/*
 * ============================================================================
 *  铁板反射法 — Bela播放+录音+UDP实时发送 (v9: 2麦克风版本)
 *
 *  音频线程 render() 只做单值写入环形缓冲 (O(1))
 *  所有 memcpy / int16转换 / sendto 在 AuxiliaryTask 完成
 *  手写环形缓冲, 不依赖任何外部库
 *
 *  信号: tx_iron_plate_20zhen.bin (ZC 19→42kHz)
 *  帧: 50ms ZC, 无静默, 20帧=1秒
 *  通道: 2(Mic1近) + 4
 *  Bela IDE: 96kHz, Block=64
 * ============================================================================
 */

#define UDP_PORT     9999
#define MAC_IP       "192.168.7.1"
#define BLOCK_SIZE   4800
#define NUM_MICS     2
#define RBUF_SIZE    (BLOCK_SIZE * 4)

std::vector<int> gSelectedChannels = {5, 4};
std::string gInputFile = "tx_iron_plate_20zhen.bin";

std::vector<float> gPlayBuffer;
std::vector<std::vector<float>> gRecordBuffers;
unsigned int gReadPtr = 0;
unsigned int gWritePtr = 0;
unsigned int gTotalFrames = 0;
unsigned int gCycleCount = 0;
bool gIsRunning = false;

// ── 手写环形缓冲 (单生产者单消费者, 无需锁) ──
float gRing1[RBUF_SIZE], gRing2[RBUF_SIZE];
volatile unsigned int gWrIdx = 0;   // 音频线程写指针
volatile unsigned int gRdIdx = 0;   // 辅助线程读指针
unsigned int gUdpIdx = 0;

static inline unsigned int ring_count() {
    return (gWrIdx - gRdIdx) % RBUF_SIZE;
}

// UDP
int gSockFd = -1;
struct sockaddr_in gDestAddr;
AuxiliaryTask gUdpTask;
int gFrameCount = 0;

void send_udp_block(void*) {
    static int16_t hdr[4];
    static int16_t data[BLOCK_SIZE * NUM_MICS];
    
    // 环形缓冲不够一帧→等待
    if (((gWrIdx - gRdIdx) % RBUF_SIZE) < BLOCK_SIZE) return;
    
    // 从环形缓冲读出一帧 (辅助线程)
    float buf1[BLOCK_SIZE], buf2[BLOCK_SIZE];
    unsigned int rd = gRdIdx;
    for (int i = 0; i < BLOCK_SIZE; i++) {
        buf1[i] = gRing1[rd];
        buf2[i] = gRing2[rd];
        rd = (rd + 1) % RBUF_SIZE;
    }
    gRdIdx = rd;
    
    // 打包 header
    hdr[0] = (int16_t)(gFrameCount & 0xFFFF);
    hdr[1] = (int16_t)((gFrameCount >> 16) & 0xFFFF);
    hdr[2] = (int16_t)(gCycleCount & 0xFFFF);
    hdr[3] = (int16_t)BLOCK_SIZE;
    
    // float→int16 交错 (2通道: ch2, ch4)
    for (int i = 0; i < BLOCK_SIZE; i++) {
        data[i*2]   = (int16_t)(buf1[i] * 32767.0f);
        data[i*2+1] = (int16_t)(buf2[i] * 32767.0f);
    }
    
    sendto(gSockFd, hdr, sizeof(hdr), 0,
           (struct sockaddr*)&gDestAddr, sizeof(gDestAddr));
    sendto(gSockFd, data, sizeof(data), 0,
           (struct sockaddr*)&gDestAddr, sizeof(gDestAddr));
    
    gFrameCount++;
}

void restart_playback() {
    gReadPtr = 0;
    gWritePtr = 0;
    gCycleCount++;
    gIsRunning = true;
}

bool setup(BelaContext *context, void *userData) {
    if (context->audioSampleRate != 96000) {
        rt_printf("ERR: sample rate must be 96000, got %f\n",
                  context->audioSampleRate);
        return false;
    }

    std::ifstream infile(gInputFile, std::ios::binary | std::ios::ate);
    if (!infile) {
        rt_printf("ERR: cannot open %s\n", gInputFile.c_str());
        return false;
    }
    gTotalFrames = (size_t)infile.tellg() / sizeof(float);
    infile.seekg(0, std::ios::beg);
    gPlayBuffer.resize(gTotalFrames);
    infile.read((char*)gPlayBuffer.data(), gTotalFrames * sizeof(float));
    rt_printf("FILE %s (%.1fs, %u samples)\n", gInputFile.c_str(),
              gTotalFrames/(float)context->audioSampleRate, gTotalFrames);

    gRecordBuffers.resize(gSelectedChannels.size());
    for (auto& buf : gRecordBuffers) buf.resize(gTotalFrames);

    gSockFd = socket(AF_INET, SOCK_DGRAM, 0);
    if (gSockFd < 0) {
        rt_printf("ERR: socket failed\n");
        return false;
    }
    int sndbuf = 256 * 1024;
    setsockopt(gSockFd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf));
    gDestAddr.sin_family = AF_INET;
    gDestAddr.sin_port = htons(UDP_PORT);
    inet_pton(AF_INET, MAC_IP, &gDestAddr.sin_addr);
    gUdpTask = Bela_createAuxiliaryTask(send_udp_block, 85, "udp-send");
    rt_printf("UDP 2ch → %s:%d | pkt=%dB | rbuf=%d\n",
              MAC_IP, UDP_PORT,
              (int)(sizeof(int16_t)*(4 + BLOCK_SIZE*NUM_MICS)), RBUF_SIZE);

    gIsRunning = true;
    return true;
}

void render(BelaContext *context, void *userData) {
    for (unsigned int n = 0; n < context->audioFrames; n++) {
        float out = 0;
        if (gReadPtr < gTotalFrames) {
            out = gPlayBuffer[gReadPtr++];
        }

        for (unsigned int ch = 0; ch < context->audioOutChannels; ch++) {
            audioWrite(context, n, ch, out);
        }

        if (gWritePtr < gTotalFrames) {
            float m1 = audioRead(context, n, gSelectedChannels[0]);
            float m4 = audioRead(context, n, gSelectedChannels[1]);
            
            gRecordBuffers[0][gWritePtr] = m1;
            gRecordBuffers[1][gWritePtr] = m4;

            // 单值写入环形缓冲
            unsigned int wr = gWrIdx;
            gRing1[wr] = m1;
            gRing2[wr] = m4;
            gWrIdx = (wr + 1) % RBUF_SIZE;

            gUdpIdx++;
            if (gUdpIdx >= BLOCK_SIZE) {
                gUdpIdx = 0;
                Bela_scheduleAuxiliaryTask(gUdpTask);
            }
            
            gWritePtr++;
        } else if (gIsRunning) {
            rt_printf("LOOP %d\n", gCycleCount + 1);
            restart_playback();
        }
    }
}

void cleanup(BelaContext *context, void *userData) {
    if (gWritePtr > 0) {
        rt_printf("SAVE WAV...\n");
        for (unsigned int i = 0; i < gSelectedChannels.size(); i++) {
            std::string fname = std::to_string(gSelectedChannels[i]) + "_000.wav";
            std::ofstream out(fname, std::ios::binary);
            if (!out) { rt_printf("ERR: %s\n", fname.c_str()); continue; }
            
            short nc = 1;
            int ds = gWritePtr * nc * 2;
            int fsz = 36 + ds;
            out.write("RIFF", 4); out.write((char*)&fsz, 4);
            out.write("WAVEfmt ", 8);
            int s1 = 16; out.write((char*)&s1, 4);
            short af = 1; out.write((char*)&af, 2);
            out.write((char*)&nc, 2);
            int sr = context->audioSampleRate;
            out.write((char*)&sr, 4);
            int br = sr * nc * 2; out.write((char*)&br, 4);
            short ba = nc * 2; out.write((char*)&ba, 2);
            short bps = 16; out.write((char*)&bps, 2);
            out.write("data", 4); out.write((char*)&ds, 4);
            
            for (unsigned int t = 0; t < gWritePtr; t++) {
                float s = gRecordBuffers[i][t];
                if (s > 1.0f) s = 1.0f; if (s < -1.0f) s = -1.0f;
                short pcm = (short)(s * 32767.0f);
                out.write((char*)&pcm, 2);
            }
            out.close();
            rt_printf("OK %s\n", fname.c_str());
        }
    }
    close(gSockFd);
    rt_printf("UDP closed, %d blocks\n", gFrameCount);
}

giuliomoro

That code looks like it should output the same signal on all output channels. Can you try a simpler example (e.g.: Fundamentals/sinetone) at different sampling rate and make sure all outputs work correctly?

YHZ Is this wiring configuration correct?

I see no problem with that

YHZ

giuliomoro Thanks for the suggestion. I tested Fundamentals/sinetone and all output channels work fine — the hardware is confirmed OK.

YHZ

When I set the gain of all the speakers to the same level, I found that Channels 2–9 are noticeably louder.

YHZ

I’m transmitting a signal from 19 kHz to 42 kHz. When I use Channel 1, there’s no audible sound at all. However, when I switch to Channels 2–9, the output becomes very loud.

giuliomoro

When I set the gain of all the speakers to the same level, I found that Channels 2–9 are noticeably louder.

That's right, at full scale, 2 to 9 are ±5V outputs, while channels 0 and 1 are approx ±1V.

YHZ

So what should I do to make Channels 2–9 behave like Channel 1, so that the output is inaudible instead of producing audible sound?

giuliomoro

Turn down the gain?

YHZ

Do you mean the speaker gain? I have to reduce it to −100 dB before the sound becomes inaudible, but then the signal received by the microphone is much too weak.

giuliomoro

In the tab you showed earlier there are gain controls for each channel, input or output. Adjust the output levels as needed.

I am confused because you say you want the sound to be inaudible, but then complain that it is too weak for the microphone to pick up?

YHZ

What I’m trying to achieve is the same behavior as Channel 1. In the CIR plot, under conditions where the transmitted signal is inaudible in both cases, the peak amplitude is about 400 for Channel 1, whereas it is only about 1.8 for Channel 2.

giuliomoro

The condition "signal is inaudible in both cases" is not very scientific or reproducible. Below a certain level, it won't matter the gain adjustment, you'll get the same "inaudible" signal.

The nominal difference between the output levels is 20*log10(5/1) = 13.98dB. So, if you are using the outputs 0 and 2, to obtain the same signal level on both you'll have to make the level of output 2 14dB smaller than that of output 0.

Note that the gain controls may be have nonlinear behaviour across their range that is not immediately communicated to the user via the IDE. For this reason, I recommend setting only the base level difference through the IDE and then the rest of the attenuation should be done in the code. For instance, in the IDE set 0dB for channels 0 and 1 and then set -14dB for all other output channels. In the code, apply a gain to your signal to make it of the desired amplitude an then send the same output to all channels.

Also note that voltage levels are nominal, but variations may occur on a channel-by-channel level, so if you care about obtaining the exact same amplitude on multiple channels, the only foolproof solution is to use a calibration routine.

On top of all of this I have to ask whether you need more than 8 output channels. If you don't, then just use them all from channels 2-9 to avoid most of the complications mentioned above.