Bela C++ Code For 8x ADC to Serial

giuliomoro Just was able to try this - thank you!

The uint16_t does reduce the length of the message which is very helpful. That said, it seems that samples # 8-15 for each of the analog input's blocks are zeros. I've included 1 message from the Pd console below as well as the code. Any ideas?

Thanks again!

186 107 191 107 163 107 171 107 167 107 151 107 165 107 176 107 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 106 108 92 108 84 108 94 108 74 108 94 108 102 108 93 108 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 172 107 149 107 173 107 178 107 197 107 195 107 190 107 193 107 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 40 108 20 108 240 107 245 107 0 108 233 107 224 107 246 107 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 120 0 113 0 128 0 125 0 130 0 117 0 121 0 120 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 152 0 172 0 162 0 170 0 150 0 181 0 161 0 162 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 162 0 145 0 143 0 150 0 158 0 147 0 149 0 142 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 143 0 166 0 148 0 166 0 140 0 146 0 157 0 158 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

#include <Bela.h>
#include <libraries/Pipe/Pipe.h>
#include <libraries/Serial/Serial.h>
#include <cmath>
#include <iostream>
#include <string>
#include <libraries/UdpClient/UdpClient.h>


float input; //from Bela->context
uint16_t array[8][16]; //eight ADC x 16 samples
UdpClient udpClient(4567, "192.168.7.1");
Serial gSerial;
Pipe gPipe;
AuxiliaryTask serialCommsTask;



void ioLoop(void* arg) {
	while(!Bela_stopRequested())
	{
		udpClient.send(array, sizeof(array));
	//	usleep(100);
	}
}

bool setup(BelaContext *context, void *userData) {
	gSerial.setup ("/dev/ttyGS0", 230400);
	AuxiliaryTask serialCommsTask = Bela_createAuxiliaryTask(ioLoop, 0, "serial-thread", NULL);
	Bela_scheduleAuxiliaryTask(serialCommsTask);
	gPipe.setup("serialpipe", 1024);
	return true;
}

void render(BelaContext *context, void *userData)
{
//READ FRAME BY FRAME OF THE BUFFER
	for(unsigned int n = 0; n < context->audioFrames; n++) {
	for(unsigned int ar = 0; ar < 8; ar++) {
	input = analogRead(context, n, ar); //read from ADC/context
	array[ar][n] = trunc(input*65535); //convert from float to int
    }
    }
}

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

giuliomoro ahh yes that definitely makes sense. this is working well now - thank you!

There's one last thing I'm seeking to do/fix: create a consistent transmission rate from the Bela to PD on the computer. I'm measuring a range of 15000-18000 blocks/second in Pd -- I imagine the theoretical rate should be 2756.25 blocks/second since we have 8 samples/block and 22050 samples/second. I'm guessing here, but it seems that even though render() is called at period intervals perhaps the void ioLoop is making additional cycles? Even when I add usleepthe transmission rate will slow down, but is still not consistent.

Any ideas? thank you again!

#include <Bela.h>
#include <libraries/Pipe/Pipe.h>
#include <libraries/Serial/Serial.h>
#include <cmath>
#include <iostream>
#include <string>
#include <libraries/UdpClient/UdpClient.h>


float input; //from Bela->context
uint16_t array[8][8]; //eight ADC x 8 samples
UdpClient udpClient(4567, "192.168.7.1");
Serial gSerial;
Pipe gPipe;
AuxiliaryTask serialCommsTask;



void ioLoop(void* arg) {
	while(!Bela_stopRequested())
	{
		udpClient.send(array, sizeof(array));
		usleep (100);
	}
}

bool setup(BelaContext *context, void *userData) {
	gSerial.setup ("/dev/ttyGS0", 230400);
	AuxiliaryTask serialCommsTask = Bela_createAuxiliaryTask(ioLoop, 0, "serial-thread", NULL);
	Bela_scheduleAuxiliaryTask(serialCommsTask);
	gPipe.setup("serialpipe", 1024);
	return true;
}

void render(BelaContext *context, void *userData)
{
//READ FRAME BY FRAME OF THE BUFFER
	for(unsigned int n = 0; n < context->analogFrames; n++) {
	for(unsigned int ar = 0; ar < 8; ar++) {
	input = analogRead(context, n, ar); //read from ADC/context
	array[ar][n] = trunc(input*65535); //convert from float to int
    }
    }
}

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

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?