I'm planning to use four Belas in conjunction: each is functioning as a 'voice' of an instrument. One the four will be a master of sorts, sending control data to the other three. I was initially thinking of using the digital pins, but the transmission rate is limited by the audio sample rate, right?
How about I2C?
Other ideas?
Bela's only work as I2C leaders, not followers, that is to say you can only have one per I2C bus and they cannot communicate to each other. If you need to broadcast information from one sender to multiple receivers, you can use a single UART on each board, connecting all receivers in parallel.
Communicating via the digital pins is OK for time-sensitive information. In order for data to be transmitted reliably You'd need the sender to use one line for clock, with each clock cycle taking 4 audio samples, so you get 15 individual channels of 11050bits-per-second data, which is not too bad in my book, but I don't know your requirements ... As
a bonus, this is the lowest latency option. Networking is another option: if you have Belas (not BelaMini) and have a spare network switch (or an old home router with enough ports), then wire them all up and there you have it.
Plenty of options!
giuliomoro thanks for the quick reply!
I'm interested in the UART option. Is this the best source to get started on it: https://learn.bela.io/using-bela/advanced-topics/bela-as-a-uart-adapter/ ?
If so, I'm a little confused about the procedure. Do I need to load or disable a device tree overlay? Log in to one Bela from another?
(I'll be using BelaMini's)
On belamini you only need to use config-pin to set the necessary pins to the desired state. No need to load device tree overlays.
giuliomoro cool - will try this out once i purchase the additional Belamini's. thx again!
hi @giuliomoro
circling back, i'm getting started on this experiment. i'm trying just 2 bela mini's to start. but i'm having issues sending / receiving. here's where i'm at:
I've set the config pins for both minis:
config-pin P2_05 uart
config-pin P2_07 uartjumpers:
p1_16 grounds connected
p2_07 (on bela sender) connected to p2_05 (on receiver)
sender code:
#include <Bela.h>
#include <libraries/Serial/Serial.h>
#include <cstdlib> // For rand() function
#include <ctime> // For seeding random number generator
Serial gSerial;
unsigned int gIntervalMs = 500; // Interval to send data in milliseconds
void serialIo(void* arg) {
while(!Bela_stopRequested())
{
// Generate a random number
int randomNumber = rand() % 1000;
// Convert random number to a string to send via UART
char buffer[16];
snprintf(buffer, sizeof(buffer), "%d\n", randomNumber);
// Send the random number
gSerial.write(buffer);
rt_printf("Sent: %s", buffer);
usleep(gIntervalMs * 1000); // Convert ms to microseconds for usleep
}
}
bool setup(BelaContext *context, void *userData) {
srand(time(0));
gSerial.setup("/dev/ttyS4", 9600);
// Create the auxiliary task for serial communication
AuxiliaryTask serialCommsTask = Bela_createAuxiliaryTask(serialIo, 0, "serial-thread", NULL);
Bela_scheduleAuxiliaryTask(serialCommsTask);
return true;
}
void render(BelaContext *context, void *userData) {
}
void cleanup(BelaContext *context, void *userData) {}receiver code:
#include <Bela.h>
#include <libraries/Serial/Serial.h>
#include <string>
#include <cstring>
Serial gSerial;
// Auxiliary task for UART reading
void serialReceive(void* arg) {
const unsigned int bufferSize = 128;
char buffer[bufferSize];
while(!Bela_stopRequested())
{
// Read from UART with a timeout of 300 ms
int bytesRead = gSerial.read(buffer, bufferSize, 300);
if (bytesRead > 0) {
// Null-terminate the received data to safely print it as a string
buffer[bytesRead] = '\0';
printf("Received: %s", buffer);
}
}
}
bool setup(BelaContext *context, void *userData) {
gSerial.setup("/dev/ttyS4", 9600);
// Create the auxiliary task for receiving data
AuxiliaryTask serialReceiveTask = Bela_createAuxiliaryTask(serialReceive, 0, "serial-receive-task", NULL);
Bela_scheduleAuxiliaryTask(serialReceiveTask);
return true;
}
void render(BelaContext *context, void *userData) {
}
void cleanup(BelaContext *context, void *userData) {
}any suggestions?
What issues are you getting? I recommend you run a project on just one Bela looping back Rx and Tx, using one thread for sending and one for receiving. That program should successfully transmit data between the two threads. Once that's working, run the same program on both boards, wiring them together as you detailed.
If the connection between the boards doesn't seem to work, log in via ssh on both boards at once and run screen /dev/ttyS4 on each. You should be able to type in one terminal and read it on the other one and vice versa.
Minor comments on the code below, which shouldn't be the reason why things haven't worked so far.
This will write outside the buffer memory if bytesRead == bufferSize.
int bytesRead = gSerial.read(buffer, bufferSize, 300);
...
// Null-terminate the received data to safely print it as a string
buffer[bytesRead] = '\0';
printf("Received: %s", buffer);I recommend using this instead:
int bytesRead = gSerial.read(buffer, bufferSize - 1, 300);(i.e.: limit to bufferSize - 1 bytes, so buffer[bytesRead] is guaranteed to be inside the buffer).
If it's just for printing, you could do this instead to avoid having to null-terminate the string:
printf("Received: %.*s\n", bytesRead, buffer);i had the wrong project set to run on boot 
thanks for the code feedback. i updated it to address that and added some error handling.
#include <Bela.h>
#include <libraries/Serial/Serial.h>
#include <string>
#include <cstring>
Serial gSerial;
// Auxiliary task for UART reading
void serialReceive(void* arg) {
const unsigned int bufferSize = 128;
char buffer[bufferSize]; // Extra space for null terminator
while(!Bela_stopRequested())
{
// Read from UART with a timeout of 300 ms
int bytesRead = gSerial.read(buffer, bufferSize, 300);
if (bytesRead > 0) {
// Ensure we are within buffer bounds and safely add a null terminator
if (bytesRead < bufferSize) {
buffer[bytesRead] = '\0';
} else {
// If we read exactly bufferSize characters, null-terminate at the end
buffer[bufferSize - 1] = '\0';
}
printf("Received: %s\n", buffer);
} else if (bytesRead < 0) {
// Print an error if reading from UART failed
printf("Error: UART read failed with code %d\n", bytesRead);
}
}
}
bool setup(BelaContext *context, void *userData) {
gSerial.setup("/dev/ttyS4", 9600);
// Create the auxiliary task for receiving data
AuxiliaryTask serialReceiveTask = Bela_createAuxiliaryTask(serialReceive, 0, "serial-receive-task", NULL);
Bela_scheduleAuxiliaryTask(serialReceiveTask);
return true;
}
void render(BelaContext *context, void *userData) {
}
void cleanup(BelaContext *context, void *userData) {
}one follow-up question @giuliomoro : using this uart approach, is there a way for these followers to send data back to the leader? I tried connecting all the follower's TX's to a bus with to the leader's RX, but the message was only received if only one TX was connected to the bus. When a 2nd TX was added, the leader no longer received the message... thanks!
UART doesn't allow you to do that. You would need to use different UART ports or have the boards connected in a circle and have each board forward messages to the next one.
On Bela Mini you have only these UARTs:
UART4 (fully available)
UART0 (sacrifices Bela digital pins 14 and 15)
UART2 (only if analogs disabled).
On Bela and BBB you would have the following on P8 and P9:
UART2 (only if analogs disabled)
UART3 (Tx only)
UART4 (Rx and Tx)
UART5 (Rx and Tx)
Then there's UART0 in the 1x5 header on the BeagleBone itself.
giuliomoro copy that. thank you!