Bela C++ Code For 8x ADC to Serial

giuliomoro ahh that's awesome to hear -- the instrument is coming along !!

a few years back (when I first got the Bela) I ported the Pd code for the instrument from the Mac to the Bela. The problem was that Heavy doesn't support some objects; FFT was especially an issue (you had helped me to understand the scenario here: https://forum.bela.io/d/1698-optimizing-pd-patch-heavy-compatibility-other-ideas). Because I was caught up in hardware design stuff at that time, I decided best route was to keep the software running on the Mac, stick with the Arduino I was using for ADC, and later, down the road, work to re-code everything in C++ for the Bela. I'm at the point where a lot of the HW stuff is fixed and am now switching back to the Bela for the ADC (better conversion in comparison to Arduino). I'm still kicking the can down the road for the C++ port lol. Anyway, that's the backstory

violapwr wanted to share an update on this in case useful to anyone; I finally got all the bugs out in this Bela analog data -> PD function I was building.
-data is being transmitted with minimal errors and audio signals (over analog) actually sound good (as opposed to crunchy lol) when received on the PD end
-uses OSC to send & sync sample rate, block size, and number of channels to PD

below is the Bela code and here's link to the PD files:
https://github.com/brianlindgren/Bela-to-PD-over-OSC

#include <Bela.h>
#include <cmath>
#include <iostream>
#include <libraries/UdpClient/UdpClient.h>
#include <libraries/OscSender/OscSender.h>
#include <libraries/OscReceiver/OscReceiver.h>
#include <libraries/Pipe/Pipe.h>

Pipe oscPipe;

OscReceiver oscReceiver;
OscSender oscSender;
int localPort = 7562;
int remotePort = 5000;
const char* remoteIp = "192.168.7.1";

constexpr int kBufferSize = 1024; // Total size of the circular buffer
int kAnalogInChannels;
int gAnalogFrames;
int gAnalogSampleRate;

float input; //from Bela->context
uint16_t circularBuffer[kBufferSize]; // Circular buffer
UdpClient udpClient(4567, "192.168.7.1");
AuxiliaryTask serialCommsTask;

int readIndex = 0;  // Current read index
int writeIndex = 0; // Current write index


void ioLoop(void* arg) {
    while (!Bela_stopRequested()) {
        while (readIndex != writeIndex) { //send 1 block at time until caught up
        
            uint16_t buffer[kAnalogInChannels * gAnalogFrames]; // init transfer buffer
            
            //copy analog frames to transfer buffer
            for (int frame = 0; frame < gAnalogFrames; ++frame) {
            	//cycle through channels and copy content from circular buffer
                for (int channel = 0; channel < kAnalogInChannels; ++channel) {
                    buffer[(frame * kAnalogInChannels) + channel] = circularBuffer[readIndex + ((frame * kAnalogInChannels) + channel)];
                }
            }
    
            readIndex = (readIndex + (gAnalogFrames * kAnalogInChannels)); // Move the read index to the next block
            
            if (readIndex >= (kBufferSize - 1))  //wrap read pointer
    			readIndex = 0;
            
			udpClient.send(buffer, sizeof(buffer)); //send to PD
        }
        usleep(250);
    }
}

void on_receive(oscpkt::Message* msg, void*)
{
	// we make a copy of the incoming message and we send it down the pipe to the real-time thread
	oscpkt::Message* incomingMsg = new oscpkt::Message(msg);
	oscPipe.writeNonRt(incomingMsg);

	// the real-time thread sends back to us the pointer once it is done with it
	oscpkt::Message* returnedMsg;
	while(oscPipe.readNonRt(returnedMsg) > 0)
	{
		delete returnedMsg;
	}
}

bool setup(BelaContext *context, void *userData) {
	/// from Bela example
	oscPipe.setup("incomingOsc");
	oscReceiver.setup(localPort, on_receive);
	oscSender.setup(remotePort, remoteIp);

	// the following code sends an OSC message to address /osc-setup
	oscSender.newMessage("/osc-setup").send();

	printf("Waiting for handshake ....\n");
	// we want to stop our program and wait for a new message to come in.
	// therefore, we set the pipe to blocking mode.
	oscPipe.setBlockingNonRt(false);
	oscPipe.setBlockingRt(true);
	oscPipe.setTimeoutMsRt(1000);
	oscpkt::Message* msg = nullptr;
	int ret = oscPipe.readRt(msg);
	bool ok = false;
	if(ret > 0) {
		if(msg && msg->match("/osc-setup-reply"))
		{
			printf("handshake received!\n");
			ok = true;
		}
		delete msg;
	}
	if(!ok) {
		fprintf(stderr, "No handshake received: %d\n", ret);
		return false;
	}
	// in the remainder of the program, we will be calling readRt() from render(), and we want it
	// to return immediately if there are no new messages available. We therefore set the
	// pipe to non-blocking mode
	oscPipe.setBlockingRt(false);
	
	AuxiliaryTask serialCommsTask = Bela_createAuxiliaryTask(ioLoop, 90, "serial-thread", NULL);
	Bela_scheduleAuxiliaryTask(serialCommsTask);
	printf("AnalogFrames: %d\n", context->analogFrames);
	printf("AnalogInChannels: %d\n", context->analogInChannels);
	printf("AnalogSampleRate: %d\n", (int)context->analogSampleRate);
	gAnalogFrames = context->analogFrames; //# of analog frames
	kAnalogInChannels = context->analogInChannels;
	gAnalogSampleRate = (int)context->analogSampleRate;
	oscSender.newMessage("/osc-settings").add(gAnalogSampleRate).add(gAnalogFrames).add(kAnalogInChannels).send();
	oscPipe.writeRt(msg);
	return true;
}

void render(BelaContext *context, void *userData)
{
	//write a message if read head couldn't catch up to write head last cycle
	if (readIndex != writeIndex) {
        rt_printf("udp catchup! >> readIndex: %d, writeIndex: %d\n", readIndex, writeIndex);
	}

	
	//cycle through frames
	for(unsigned int n = 0; n < gAnalogFrames; n++) {
	
		//cycle through channels and copy content to circular buffer
		for(unsigned int ar = 0; ar < kAnalogInChannels; ar++) {
			
			input = analogRead(context, n, ar); //read from ADC/context
			circularBuffer[writeIndex + ar] = input * 65535; //convert from float to int
	    }
	    // Increment write index every time a new frame is written and reset to 0 if too high
	    writeIndex = (writeIndex + kAnalogInChannels); 
	    
	    if (writeIndex >= (kBufferSize - 1))
	    	writeIndex = 0;
    }
}

void cleanup(BelaContext *context, void *userData) {}

very strange problem I'm having...

for some reason the Bela all of a sudden had trouble communicating with PD over OSC. I wiped and reflashed the ssd but still not working (with the code above). I'm getting this error: no viable conversion from 'void (oscpkt::Message *, void *)' to 'std::function<void (oscpkt::Message *, const char *, void *)>' column: 31, line: 73

if i run \example Communication/OSC-pipe/render.cpp the code runs & i'm able to receive 'osc-setup' in PD, but the 'osc-setup-reply' is not received on the Bela, with PD reporting this error send: No route to host (65)

come to think of it, a few days ago, git (on Bela) was giving me a seg fault, so i tried to update/reinstall it using apt (which did not work)... hopefully I did not screw up anything ....

any ideas?

giuliomoro No... I also tried to turn off my macOS firewall, and received the same error in PD

I just tried the same experiment with my Bela Mini (and the simplified PD patch), and had the same result, which leads me to agree that the issue is perhaps not with the the Bela but on the computer end... I recently updated my macOS to 15.4... could it be a macOS issue?

Update:
I re-tried our PD test patch on my school computer & it worked without error (screenshot below). Also, more complex program (from a year back, above) is working as well. The school machine is macOS 14.7.5. So perhaps it's a macOS thing?