214 lines
5.8 KiB
Python
214 lines
5.8 KiB
Python
SLIPDecoder {
|
|
// SLIP DECODING
|
|
// ===================
|
|
//
|
|
// The packets are SLIP encoded using these special characters:
|
|
// end = 8r300 (2r11000000 or 0xc0 or 192)
|
|
// esc = 8r333 (2r11011011 or 0xdb or 219)
|
|
// esc_end = 8r334 (2r011011100 or 0xdc or 220)
|
|
// esc_esc = 8r335 (2r011011101 or 0xdd or 221)
|
|
// original code by Martin Marier & Fredrik Olofsson
|
|
const slipEND = 0xC0;
|
|
const slipESC = 0xDB;
|
|
const slipESC_END = 0xDC;
|
|
const slipESC_ESC = 0xDD;
|
|
|
|
// OSC DECODING
|
|
// ============
|
|
// bundle header "#bundle"
|
|
// type separator ","
|
|
const oscBundleHeader = #[35, 98, 117, 110, 100, 108, 101, 0];
|
|
const oscTypeSeparator = 0x2C;
|
|
|
|
// Buffer for OSC bundles/messages
|
|
const bufferSize = 4096;
|
|
|
|
var <>deviceName, <>rate, <>prepend, <port, <>trace = false, <running = false, <reader;
|
|
|
|
*new { |deviceName="/dev/ttyUSB0", rate=115200, prepend=""|
|
|
^super.newCopyArgs(deviceName, rate, prepend);
|
|
}
|
|
|
|
readInt32 { |byteArr|
|
|
^((byteArr[0] << 24) + (byteArr[1] << 16) + (byteArr[2] << 8) + byteArr[3]);
|
|
}
|
|
|
|
readFloat32 { |byteArr|
|
|
^Float.from32Bits(this.readInt32(byteArr));
|
|
}
|
|
|
|
// Read byte array 4 bytes at a time, return on null termination or if end of buffer reached
|
|
// Return array [string, strlen (bytes)]
|
|
readNextString { |byteArr|
|
|
var str = "", idx = 0;
|
|
while({ (idx + 4) <= byteArr.size }, {
|
|
str = str ++ String.newFrom(
|
|
byteArr[(idx..(idx + 3))]
|
|
.removeEvery([0, nil])
|
|
.collect({|x| x.asAscii})
|
|
);
|
|
|
|
// If last byte is null, return
|
|
if ( isNil(byteArr[idx + 3]) || (byteArr[idx + 3] == 0), {
|
|
^[str, idx + 4]
|
|
});
|
|
idx = idx + 4;
|
|
});
|
|
|
|
// If end of byteArr, return
|
|
^[str, idx];
|
|
}
|
|
|
|
int2chr { |x|
|
|
// ce je stevilo, v razponu crk, stevk in znakov, vrni char, sicer kar cifro
|
|
if (x.isInteger && (x >= 0x20) && (x <= 0x7E),
|
|
{ ^x.asAscii },
|
|
{ ^x }
|
|
);
|
|
}
|
|
|
|
init {
|
|
port = SerialPort(deviceName, rate);
|
|
}
|
|
|
|
traceMsg { |...msg|
|
|
if ((trace), { "> ".post; msg.join(' ').postln; });
|
|
}
|
|
|
|
// Function for decoding the properly-SLIP-decoded message.
|
|
decode { |data|
|
|
var header = data.at((0..7));
|
|
|
|
// Is it a bundle? (read header from first 8 bytes)
|
|
if ((header == oscBundleHeader), {
|
|
// OSC bundle
|
|
var nextMsgLen, nextMsgStart, nextMsgEnd, bundlePart;
|
|
this.traceMsg("BUNDLE");
|
|
|
|
// Next 8 bytes are a time tag (or null)
|
|
/* @TODO handle timetags!
|
|
var timetag = data.at((8..15));
|
|
*/
|
|
|
|
// First message starts after the time tag
|
|
nextMsgStart = 16;
|
|
|
|
// Loop for each message
|
|
while({ nextMsgStart < data.size }, {
|
|
// Further 4 bytes hold the next message length
|
|
nextMsgLen = this.readInt32(data.at((nextMsgStart..(nextMsgStart + 3))));
|
|
nextMsgStart = nextMsgStart + 4;
|
|
nextMsgEnd = min(nextMsgStart + nextMsgLen - 1, data.size - 1);
|
|
bundlePart = data.at((nextMsgStart..nextMsgEnd));
|
|
|
|
// Recursively decode; each bundle part can be another bundle
|
|
this.decode(bundlePart);
|
|
|
|
nextMsgStart = nextMsgEnd + 1;
|
|
});
|
|
}, {
|
|
// OSC message
|
|
var nextString, index, address, type, args = [];
|
|
|
|
// Message Address
|
|
nextString = this.readNextString(data);
|
|
address = nextString[0];
|
|
data = data[(nextString[1]..(data.size - 1))];
|
|
|
|
nextString = this.readNextString(data);
|
|
type = nextString[0];
|
|
data = data[(nextString[1]..(data.size - 1))];
|
|
|
|
type.do({ |t|
|
|
t.switch (
|
|
$i, {
|
|
args = args.add(this.readInt32(data));
|
|
data = data[(4..(data.size - 1))];
|
|
},
|
|
$f, {
|
|
args = args.add(this.readFloat32(data));
|
|
data = data[(4..(data.size - 1))];
|
|
},
|
|
$s, {
|
|
nextString = this.readNextString(data);
|
|
args = args.add(nextString[0]);
|
|
data = data[(nextString[1]..(data.size - 1))];
|
|
}
|
|
/* @TODO implement strings, bytearrays */
|
|
);
|
|
});
|
|
this.traceMsg("OSC", prepend ++ address, args);
|
|
|
|
// Send OSC message to the engine
|
|
NetAddr.localAddr.sendMsg(prepend ++ address, *args);
|
|
});
|
|
}
|
|
|
|
start {
|
|
this.traceMsg("Starting...");
|
|
if ((port == nil), {this.init;});
|
|
if (port.isOpen.not, {this.init;});
|
|
|
|
this.traceMsg("opened");
|
|
running = true;
|
|
|
|
reader = fork {
|
|
var serialByte, buffer, firstRead;
|
|
firstRead = true;
|
|
|
|
// Skip data before the first END character
|
|
while({running && firstRead}, {
|
|
serialByte = port.read;
|
|
|
|
//this.traceMsg("Read byte");
|
|
//this.traceMsg(serialByte.asAscii);
|
|
|
|
if (serialByte == slipEND, {
|
|
buffer = Int8Array(maxSize: bufferSize);
|
|
firstRead = false;
|
|
}, {
|
|
this.traceMsg("Skip...")
|
|
});
|
|
});
|
|
|
|
// Start reading data
|
|
this.traceMsg("First read!");
|
|
while({running}, {
|
|
serialByte = port.read;
|
|
//this.traceMsg("Checking", serialByte.asInteger, serialByte.asAscii);
|
|
serialByte.switch(
|
|
// on END, decode buffer
|
|
slipEND, {
|
|
//this.traceMsg("SLIP END, decoding ");
|
|
//this.traceMsg(buffer);
|
|
//3.wait;
|
|
if (buffer.isEmpty.not, {
|
|
this.traceMsg("decode!", buffer);
|
|
this.decode(buffer);
|
|
buffer = Int8Array(maxSize: bufferSize);
|
|
});
|
|
},
|
|
slipESC, {
|
|
serialByte = port.read;
|
|
serialByte.switch(
|
|
slipESC_END, { buffer.add(slipEND) },
|
|
slipESC_ESC, { buffer.add(slipESC) },
|
|
{"SLIP encoding error.".error }
|
|
);
|
|
}, {
|
|
// Otherwise just add the byte
|
|
//this.traceMsg(buffer);
|
|
buffer.add(serialByte);
|
|
});
|
|
});
|
|
};
|
|
}
|
|
|
|
stop {
|
|
this.traceMsg("Stopping...");
|
|
running = false;
|
|
port.close;
|
|
this.reader.free;
|
|
}
|
|
}
|