Monome Grid & Bela

well my understanding is still the same as it was here:

giuliomoro I know nothing about it, but I would guess that serialoscd is a bridge between OSC and the monome: my guess is that it receives OSC messages from the user application and passes them over to the monome over serial, and also receives serial from the monome and passes it on as OSC to the user application. So, I guess it has to stay open throughout for the program to work!

I guess you now need to send OSC to serialoscd and receive OSC from it, using the OscSender and OscReceiver classes . This can be done using the Communication/OSC example as a starting point. That example relies on bi-directional communication with a node server, but ultimately you only need to send and receive (without the more complex handshake logic implemented in there).

As to WHAT messages to send/receive, I have no idea, that would be in the monome documentation, I imagine? As to WHERE to send the messages (what port), that's hopefully in the serialosc documentation. Note that there will be nothing here that is Bela-specific, so you can probably find better support in specialised Monome forums.
One thing that emerges from the README of serialosc is that you need to plugin the monome for the process to daemonise and do something useful. This may mean that in /lib/systemd/system/serialoscd.service it should be Type=forking as it was originally, instead of Type=simple as I changed it. I cannot test this because I don't have a monome, but you can. Make sure you look at the output of journalctl -f -n 50 -u serialoscd to see if anything useful is printed when the Monome is connected.

ndivuyo @guiliomoror Greetings! I'm getting along fairly well (for my needs at least!) with Bela Salt C++ programming. I'm thinking about buying a Monome Grid to use it to control the Bela Salt. What are the chances of this connectivity working reasonably smoothly?

The above setup should work reliably, but I don't have a Monome so I couldn't try it out. @padenot may also be able to say something about how it worked for him. Because of how the BBG + Bela cape are mounted in Salt, you will need to solder some wires to the back of your BeagleBone to break out the UART signals.

I confirm that plugging a monome device (arc or grid, I tested both) on a Bela just works, nothing special to report, just like any Linux computer. I've been using quite a few packages from different languages to test things out a few years back before writing mine in Rust, also nothing to report, everything just worked, even when stress testing it.

I've only be using the regular Bela, not the mini, I don't know if we should expect anything different? Maybe it has less available power output to drive the monome or something?

Thanks @giuliomoro and @padenot - much appreciated. I'l report back when I have taken some more action! :-)

Hi giuliomoro Greetings! So, I finally got a Monome Grid delivered and installed enough on my Bela Salt so that #include <serialosc_helpers/SerialOsc.h> "works".

However, I'm now trying to get something of https://github.com/daniel-bytes/serialosc_example/blob/master/serialosc_example/serialosc_example.cpp to work in my code - but I'm not sure what files I should put where on the Bela (and anything else I should do) in order to get the sample code working.

Any tips would be gratefully received!

Is serialosc built as a (shared or static) library? If yes, you'll need to set LDFLAGS and CPPFLAGS accordingly for the Bela project so that libserialosc is linked in and the appropriate -L and -I paths are set. You mention you can already include the header file appropriately, is that achieved by placing the source files for libserialosc in the project folder?

Good questions! I will check and report back! :-)

giuliomoro Fantastic, thanks so much. I will try the above and report back. :-)

Hi future travelers. I have also got the grid working although it took me a bit. I'm going to leave some notes here in case it might be useful.

This script is a total success for me: https://github.com/giuliomoro/bela-utils/blob/master/bela-setup-monome.sh (thank you @giuliomoro and @padenot !!)

You also need to generate a monome config file. You can generate this config file by following these instructions. Just make sure that you can use those instructions to generate the file in ~/.config/serialosc/.

Once you have the config file, you need to change one line in the /lib/systemd/system/serialoscd.service to use it:

ExecStart=/usr/local/bin/serialoscd -c ~/.config/serialosc/

That will make sure that it uses the config you generated and serialoscd doesn't switch ports everytime the Bela turns on.

Then

systemctl daemon-reload
systemctl restart serialoscd

will get it going.

Using monome in code is pretty easy. Here's basically what I did in render.cpp(full code: https://github.com/schollz/palms/blob/53a85b62d11be26054f162b30342bb01b6c967e4/render.cpp#L12):

...
#include <monome.h>

// monome
monome_t* monome;
unsigned int grid[16][16] = {[0 ... 15][0 ... 15] = 0};
#define MONOME_DEVICE "osc.udp://127.0.0.1:14656/monome"

void handle_press(const monome_event_t* e, void* data) {
    unsigned int x, y;

    x = e->grid.x;
    y = e->grid.y;

    /* toggle the button */
    grid[x][y] = !grid[x][y];
    monome_led_set(e->monome, x, y, grid[x][y]);
}

static void monome_loop(void*) { // monome_event_loop(monome);
    while (!Bela_stopRequested()) {
        monome_event_handle_next(monome);
    }
    monome_close(monome);
}



bool setup(BelaContext* context, void* userData) {
    /* open the monome device */
    if (!(monome = monome_open(MONOME_DEVICE, "8000")))
        return -1;
    monome_led_all(monome, 0);
    /* register our button press callback */
    monome_register_handler(monome, MONOME_BUTTON_DOWN, handle_press, NULL);
    Bela_runAuxiliaryTask(monome_loop);
    ...

One important note is that the port you use for #define MONOME_DEVICE "osc.udp://127.0.0.1:14656/monome" needs to have the port (mine is 14656) match what is in your config file. You can find your port by running cat ~/.config/serialosc/*, for example it gives me:

server {                  
  port = 14656            
}                         
application {             
  osc_prefix = "/monome"  
  host = "127.0.0.1"      
  port = 8000             
}                         
device {                  
  rotation = 0            
}                         

So you can see that I use port 14656 for everything and define that in my render.cpp

Thanks for the feedback.

infinitedigits This script is a total success for me

Great. It actually seems that there are minor changes needed to it, e.g.:

infinitedigits Once you have the config file, you need to change one line in the /lib/systemd/system/serialoscd.service to use it:

ExecStart=/usr/local/bin/serialoscd -c ~/.config/serialosc/

could you make a pull request to my repo to include this change?

Please let me know if I need to move this question to a new post, though this post has helped me nearly get up and running.I have a Bela with latest 0.3.8 image and looking to get serialosc installed.

After some time getting apt-get update to work (couldn't find Release info or something) I finally installed the lib tools. Found somewhere that need to run echo "deb http://archive.debian.org/debian stretch main contrib non-free" > /etc/apt/sources.list.

I clone/build/install the libmonome.git however for serialosc. when configuring it seems to be successful (though fmemopen and reallocarray are checked as 'no' and windows.h is not found). When I run ./waf I get the following error
[ 1/23] Compiling src/common/util.c
gcc: error: unrecognized command line option '-std=c17'; did you mean '-std=c11'?

Waf: Leaving directory `/root/serialosc/build'
Build failed
-> task in 'serialosc-common' failed with exit status 1 (run with -v to display more information)

Any ideas?

It seems that this commit increased the C standard level from C99 to C17 for the purpose of supporting anonymous unions in accordance to the updated standard instead of using the compiler-specific __extension__ keyword. However, it looks like this improvement to the language took place in the transition from C99 to C11 (https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2244.htm), so they could have as well specified C11 instead of C17. This was a pretty recent change and it doesn't look like any new code has been added since then that would rely on C17. For all of these reasons, I think it is safe to lower the requirement to C11 which is the latest C revision supported by gcc on the latest Bela version.

Apply this patch and you should be able to build:

diff --git a/wscript b/wscript
index 659328c..cdd25ab 100644
--- a/wscript
+++ b/wscript
@@ -281,9 +281,9 @@ def configure(conf):


        if conf.options.enable_debug:
-               conf.env.append_unique("CFLAGS", ["-std=c17",  "-Wall", "-g", "-Og"])
+               conf.env.append_unique("CFLAGS", ["-std=c11",  "-Wall", "-g", "-Og"])
        else:
-               conf.env.append_unique("CFLAGS", ["-std=c17", "-Wall", "-Werror", "-O2"])
+               conf.env.append_unique("CFLAGS", ["-std=c11", "-Wall", "-Werror", "-O2"])


        if conf.env.CC_NAME in ["gcc", "clang"]:

(i.e.: replace c17 with c11 in wscript). You'll have to rm -rf build and ./waf configure again after this for the changes to be picked up.

I have looked into this and I am unsure I can test this any further without having a monome myself. Try adding this printf statement so we know what path it's trying to open:

diff --git a/src/serialosc-device/config.c b/src/serialosc-device/config.c
index b6fda47..d3a05fd 100644
--- a/src/serialosc-device/config.c
+++ b/src/serialosc-device/config.c
@@ -135,6 +135,7 @@ sosc_config_write(const char *config_dir, const char *serial, sosc_state_t *stat
                path = path_for_serial(sosc_get_default_config_dir(), serial);
        }

+       printf("FOPEN PATH %s\n", path);
        if (!(f = fopen(path, "w"))) {
                s_free(path);
                return 1;

Rebuild, restart, replug