Analog input send by Osc

you can use something like this:

#include <Bela.h>
#include <libraries/OscSender/OscSender.h>
#include <libraries/Biquad/Biquad.h>
#include <vector>

std::vector<float> gFilteredAnalogIns;
std::vector<Biquad> filters;
OscSender oscSender;
int remotePort = 7563;
const char* remoteIp = "192.168.7.1";
const float kSendPeriod = 0.05; // 50 ms

void sendThread(void*)
{
	while(!Bela_stopRequested())
	{
		for(int c = 0; c < int(gFilteredAnalogIns.size()); ++c)
		{
			// access the filtered values from the global variable and send them
			oscSender.newMessage("/analog-in").add(c).add(gFilteredAnalogIns[c]).send();
		}
		usleep(kSendPeriod * 1000000);
	}
}

bool setup(BelaContext *context, void *userData)
{
	gFilteredAnalogIns.resize(context->analogInChannels);
	
	// The analog inputs are sent over OSC every kSendPeriod seconds.
	// This amounts to a downsampling of the input signals and so
	// we filter them with a lowpass filter before downsampling
	// in order to reduce noise and aliasing
	float cutoff = 0.7f * 1.f / kSendPeriod;
	BiquadCoeff::Settings settings = {
		.fs = context->analogSampleRate,
		.type = BiquadCoeff::lowpass,
		.cutoff = cutoff,
		.q = 0.707,
		.peakGainDb = 0,
	};
	filters.resize(gFilteredAnalogIns.size(), settings);

	oscSender.setup(remotePort, remoteIp);
	Bela_runAuxiliaryTask(sendThread);
	return true;
}

void render(BelaContext *context, void *userData)
{
	for(unsigned int n = 0; n < context->analogFrames; ++n)
	{
		for(unsigned int c = 0; c < context->analogInChannels; ++c)
			// filter the input signals here and store them in the
			// global variable
			gFilteredAnalogIns[c] = filters[c].process(analogRead(context, n, c));
	}
}

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

on the host, open UDP port 7563 and listen for incoming messages. E.g.:

Cristiano May be i' m doing something wrong.

if you are on Windows you may need to change the remoteIp on the board to 192.168.6.1.

Cristiano Anyway i don' t want to use it with pure data but inside a software i'm writing which use Osc implementation via Liblo library.

Once you have that working, you should be able to receive it from your custom program. This code sends OSC via UDP. Non-trivial changes will be needed to send via TCP.

Cristiano I have tried to receive in pure data through the "print OSC-packet" object and it prints out but
caotically:

what's your patch like (hint: post it, next time)?

[netreceive -b -u 7563]
|
[print OSC-packet]

? That is not using any OSC-packet object, but rather it's printing the output of [netreceive] prepending it with the string OSC-packet. Data is received by [netereceive] as "binary" so it outputs numbers between 0 and 255, each representing one byte that was received. If you simply print the output of [netreceive], it will print the decimal representation of each byte that was received. You should use something like [oscparse] as above. The output would be like this:

So that shows that each message looks like this:

/analog-in CHANNEL VALUE , where CHANNEL is an int and VALUE is a float. Hopefully these details are enough for you to properly parse the messages in your program.

Cristiano ne more question about the filtering, isn't it enough to output the acquired analog signal directly?

Kindof. It does work but you are downsampling something from 22050Hz to about 200Hz (sending every 50ms), so any noise and high-frequency changes would be aliased. We therefore filter it before downsampling in order to reduce the noise and aliasing of your data.

because you are sending the data over OSC about every 50ms, which means downsampling to about 200Hz.

It's supported only internally. That is a lot of data to send over network. It can be achieved, but then the overheads of OSC are too big to send individual messages like this. You'd have to look at using OSC blobs or just plain raw samples as I do here.

but why do you want to send full-rate signals to the host?

Then your best bet is to do it on Bela. Trying to send a lot of data over network is doable, as I mentioned, and probably you can send 8 to 10 channels, but you'll need large buffers on each side, which means latency will be pretty high (e.g.: 1 second).