Arduino + WiFly sends OSC

 2f (/)  6f (o)  73 (s)  63 (c)
 69 (i)  6c (l)  6c (l)  61 (a)
 74 (t)  6f (o)  72 (r)  2f (/)
 34 (4)  2f (/)  66 (f)  72 (r)
 65 (e)  71 (q)  75 (u)  65 (e)
 6e (n)  63 (c)  79 (y)  0 ()
 2c (,)  66 (f)  0 ()    0 ()
 43 (C)  dc (Ü)  0 ()    0 ()

The byte array equivalent in C for Arduino looks like this:

char data[] = {0x2f, 0x6f, 0x73, 0x63, 0x69, 0x6c, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x2f, 0x34, 0x2f, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x79, 0x00, 0x2c, 0x66, 0x00, 0x00, 0x43, 0xdc, 0x00, 0x00};

Since this is kind of difficult to look at and work with, we can instead use char arrays.  Char arrays can be more readable, but how do you convert a float to a char array?  There’s a neat “trick” to do this in C using the union keyword.  Here’s some working Arduino code for sending OSC messages with a single float argument.  The first message sends 0.1, the next 0.2, and so on until 1.0 is reached and then it’s reset back to 0.1.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include "RNXV.h"

RNXV rnxv = RNXV();
float f;
union u_tag {
  byte b[4];
  float fval;
} u;
void setup() {
  f = 0.1;

  Serial.begin(9600);
  Serial1.begin(9600);

  rnxv.setUart(&Serial1);
  rnxv.join("SSID_HERE","PASSPHRASE_HERE");
  rnxv.enableUdp("192.168.1.5", 3000, 4000);
  rnxv.sendCommand("join", "AOK");
  Serial.println(rnxv.ip());
}
void loop()
{
  delay(1000);
  if (f > 1) f = 0;
  f = f + 0.1;

  char data[32] = "/oscillator/4/frequency\0,f\0\0";
  u.fval = f;
  data[28] = u.b[3];
  data[29] = u.b[2];
  data[30] = u.b[1];
  data[31] = u.b[0];

  Serial.print("print use loop: ");
  for (int i = 0; i <= 31; i++){
    Serial.print(data[i]);
  }
  Serial.println();

  rnxv.sendOsc(data, 32);
}

The code references an RN-XV library I’ve been working on to set up UDP and send the byte array as follows:

1
2
3
4
5
6

void RNXV::sendOsc(char data[], int size)
{
  for(int i = 0; i < size; i++)
    _uart->print(data[i]);
  delay(75);
}

I tried various delays and a delay of 75 seemed just enough that there wouldn’t be any corrupted OSC messages even when running the code for hours. This delay and the minimal code above resulted in about 13 OSC messages transmitting per second.  It is also necessary to loop and send the exact number of chars as a message contains, or else the receiving end doesn’t recognize the end of the message and throws errors.

 OscPkt and AVR-STL

At this point, having proved the concept, I was about to dive into writing my own library to generate the OSC, but thought I’d try one last time to find something off the shelf to do this.

OscPkt, the minimalittlest OSC library for C++ seemed perfect for the job, being super concise and all contained in a single header file. It also was not tightly coupled with any UDP library so I could use my sendOsc function (above). However it depended heavily on C++ Standard Library classes (like vector) which don’t exist for Arduino.

Except they do – a brilliant piece of work by Andy Brown is AVR-STL. It brings STL to Arduino. He has all the instructions on his blog post.  Simply download and put all header files in the include folder into …arduino-1.0.1\hardware\tools\avr\avr\include.  

Once AVR-STL was integrated, I took oscpkt.hh, renamed it to oscpkt.h and added the following two #includes at the top (as per the instructions found on the AVR-STL page):

1
2

#include
#include

Then placed it in a folder “oscpkt” which I threw into my Arduino “libraries” folder. Now you can add the following to any Arduino sketch:

1
2
3
4
5
6
7
8
9

#include "oscpkt.h"
setup() {
  oscpkt::Message msg;
  oscpkt::PacketWriter wr;
  msg.init("/foo");
  wr.init().addMessage(msg);
  Serial.println(wr.packetSize());
  Serial.println(wr.packetData());
}