hid to osc

a human-interface-device (HID) to open-sound-control (OSC) converter for macOS written in Python3.

the program can send OSC to any IP and port but by default it will send to 127.0.0.1 (localhost) on port 57120 (supercollider).

here is a binary build... HIDtoOSC.zip (macOS, 64bit, 5.3mb)

to run it start Terminal.app and type...

cd ~/Downloads
./HIDtoOSC

that should list available HID devices on your system. after that you will probably see a warning that it failed to open the default device.

so to open and start reading data from any of your own devices you will need to give the correct vendor id and product id as arguments.

usage: HIDtoOSC [-h] [-V] [--vid VID] [--pid PID] [--ip IP] [--port PORT]
                [--rate RATE] [--debug]

optional arguments:
  -h, --help     show this help message and exit
  -V, --version  show program version
  --vid VID      set HID vendor id
  --pid PID      set HID product id
  --ip IP        set OSC destination IP
  --port PORT    set OSC destination port
  --rate RATE    update rate in milliseconds
  --debug        post incoming HID data

 
example - usb keyboard

here is an example that show how to connect to an external generic usb keyboard with the vendor and product id 6700, 2.

NOTE: for security reasons sudo is needed when accessing keyboards but not for accessing most other devices (gamepads, joysticks, mice)

some times you will need to run the program a few times before the HID is claimed. stop the program with ctrl+c

in the example the key A is pressed and released, but all HID will use their own data format. the --debug flag makes the program print out the incoming data.

 
receiving osc

then in SuperCollider we can receive the data as an OSC message. test it by running the line...

OSCFunc.trace;

here is what the example above generates...

OSC Message Received:
        time: 75956.941459501
        address: a NetAddr(127.0.0.1, 56073)
        recvPort: 57120
        msg: [ /hid, 6700, 2, Int8Array[ 0, 0, 4, 0, 0, 0, 0, 0 ] ]

example - usb mouse

and here is another example connecting to an optical mouse. (no sudo needed)

this example sends OSC to port 9999 and the data format is slightly different than in the keyboard example above.

 
building

if you do not trust the binary above (and you should not - specially when running it with sudo) you can run the python code directly.

homebrew and python3 is required.

first install some libraries...

brew install hidapi liblo

next create an virtual environment...

cd ~/python3
mkdir HIDtoOSC && cd HIDtoOSC
python3 -m venv env
source env/bin/activate  #to later leave the virtual environment type: deactivate

then install some python libraries...

pip install pyliblo
pip install hid pyusb
pip install pyinstaller

then finally copy the main python program below, put it in a file called HIDtoOSC.py and test it with for example python HIDtoOSC.py -h (stop with ctrl+c)

#f.olofsson 2019

# required python libraries: pyliblo, hid, pyusb
# example: sudo python HIDtoOSC.py --vid 6700 --pid 2 --port 12002 --debug
# note: macOS must be running this as root if the device is a keyboard

import sys, argparse
import usb.core, hid, liblo

#--settings
version= 0.1

#--arguments
parser= argparse.ArgumentParser()
parser.add_argument('-V', '--version', action= 'store_true', help= 'show program version')
parser.add_argument('--vid', type= int, dest= 'vid', help= 'set HID vendor id')
parser.add_argument('--pid', type= int, dest= 'pid', help= 'set HID product id')
parser.add_argument('--ip', dest= 'ip', help= 'set OSC destination IP')
parser.add_argument('--port', type= int, dest= 'port', help= 'set OSC destination port')
parser.add_argument('--rate', type= int, dest= 'rate', help= 'update rate in milliseconds')
parser.add_argument('--debug', dest= 'debug', action= 'store_true', help= 'post incoming HID data')

parser.set_defaults(vid= 1452)
parser.set_defaults(pid= 517)
parser.set_defaults(ip= '127.0.0.1')
parser.set_defaults(port= 57120)
parser.set_defaults(rate= 100)
parser.set_defaults(debug= False)
args= parser.parse_args()

if args.version:
  sys.exit('HIDtoOSC version %s'%version)

print('Available HID devices:')
for d in hid.enumerate():
  print('  device: %s, %s'%(d['manufacturer_string'], d['product_string']))
  print('  vid: %s, pid: %s'%(d['vendor_id'], d['product_id']))

def main():
  dev= usb.core.find(idVendor= args.vid, idProduct= args.pid)

  if dev is None:
    sys.exit('Could not find device %s, %s'%(args.vid, args.pid))

  for config in dev:
    for i in range(config.bNumInterfaces):
      if dev.is_kernel_driver_active(i):
        dev.detach_kernel_driver(i)

  try:
    dev.set_configuration()
  except usb.core.USBError as e:
    sys.exit('Could not set configuration: %s'%str(e))

  endpoint= dev[0][(0, 0)][0]
  try:
    dev= hid.Device(args.vid, args.pid)
    print('Device %s, %s open'%(args.vid, args.pid))
  except:
    sys.exit('Could not open device %s, %s'%(args.vid, args.pid))

  print(endpoint)
  target= (args.ip, args.port)
  noerror= True
  while noerror:
    try:
      data= dev.read(endpoint.wMaxPacketSize, args.rate)
    except:
      noerror= False
      try:
        dev.close()
        print('Closed the hid device')
      except:
        pass

    if data:
      if args.debug:
        print([x for x in data])
      try:
        msg= liblo.Message('/hid', args.vid, args.pid, ('b', data))
        liblo.send(target, msg)
      except:
        print('WARNING: Could not send osc to %s'%(target, ))

if __name__=='__main__':
  main()

later you can build your own binary with the command...

pyinstaller HIDtoOSC.py --onefile --hidden-import=libhidapi --add-binary='/usr/local/lib/libhidapi.dylib:.'

featureCreep

software written for and in collaboration with violinist George Kentros. premiered at after work - this violin must die, fylkingen stockholm 30 mar 2019.

the program is written in supercollider with additional features like ipad control and video mixer made in maxmspjitter.

main interface

the main window with its eight tracks (configurable) looks like this...

here you can set an amplitude threshold for the microphone and arm tracks to automatically detect and capture sounds.

with the waveform selection (dark grey areas) you select what part of the captured sound you want your different players to use.

there are many players - all with different behaviours...
slow, medium, repetitive, scanner, sweep, nervous, fastRhythmic, slowRhythmic, limpRhythmic, fast, drill, jump, plain, half, third, quarter, pingpong, crawl, wave, waveHalf, pattern1, pattern2, pattern3, round, sync

player behaviours include in which direction and how fast to progress in the captured sound buffer, when to play for how long, with which envelope and how loud, how much transposition, play in which audio channel etc etc.
some of these players are using granular synthesis techniques while others are scratching and jumping around in the sound buffer in more or less unpredictable ways. hopefully the names listed here above will give a hint of what players do to the sound.

all players are pieces of code. for example this the code for the scanner player...

SynthDef(\scanner, {|buf, amp= 1, start= 0, end= 1|
        var dur= BufDur.kr(buf);
        var pha= LFNoise2.kr(In.kr(100)+0.1)+1/2;
        var pos= pha*(end-start)+start;
        var add= LFNoise2.kr(1);
        var fre= In.kr(101).linexp(0, 1, 1.1, 18)+add*SinOsc.kr(0.1).max(0.5);
        var snd= TGrains.ar(
                2,
                Impulse.ar(fre),
                buf,
                1+LFNoise2.kr(1, 0.05),
                pos*dur,
                0.75,
                LFNoise2.kr(0.06, 0.5),
                amp.lag(0.5)
        );
        SendReply.kr(Impulse.kr(\updateRate.kr+1), '/pos', pos);
        Out.ar(\syncBus.ir(40)+\index.ir, K2A.ar(pha));
        snd= CompanderD.ar(snd, \compressorThresh.kr, 0.5, 0.5, 0.005, 0.01, EnvGate());
        Out.ar(\out.kr, snd);
}).add;

and most players will look very similar to this. but there are also a few special ones like sync which just matches the playback position of the player in the track above.

in the main window one can also set track volume, bypass any global effects and read/write soundfiles.

the computer keyboard may be used for shortcuts quickly arming, playing and selecting what each track should play.

global control

there is also an additional control gui with global volume, effects, automation and record...

the three sliders delay, sustainer, distortion are just simple wet/dry control for global effects (that can be bypassed for each track using the bp button), while the other sliders freeze, fire, industry, chaos, air are more complex and control a bunch of effects and behaviours. for example freeze will take the sound from all players and smear it out by removing transients and pitch shifting copies of the sound up/down in octaves.

when the automation button is clicked, the program itself can start and stop tracks, change effects and vary a lot of other parameters in the code. the idea here is that the software should be able to run independently and generate interesting variations over long periods of time. also it should never go completely silent nor go wild and overload everything.

remote ipad interface

all the above can be viewed and controlled remotely from a tablet or a phone using a web browser. we programmed a look-alike gui patch with maxmsp and the mira externals. this patch talks to the supercollider interface over opensound control.

the interface here is even more ugly - specially the waveform display because the sound data had to be downsampled and kept at a low resolution to reduce wifi network traffic. also it was hard to fit everything on a single screen as all widgets had to be quite large and not too close to each other to be usable on an ipad.

our software also includes a video mixer for camera and movie playback (not shown here).

sc: fixed number of decimals

here's a quick function for displaying float numbers as strings in supercollider.

(
~fixDec= {|val, numDecimals= 2|  //float to string with fixed number of decimals
        var str= val.round(0.1**numDecimals).asString;
        var num= str.size-str.indexOf($.)-1;
        str.extend(str.size+numDecimals-num, $0);
};
)

//test examples
~fixDec.value(0.1, 3)
-> 0.100
~fixDec.value(0.12345, 3)
-> 0.123

//rounds internally.  compare:
~fixDec.value(0.191, 2)
-> 0.19
~fixDec.value(0.197, 2)
-> 0.20

//can deal with negative values
~fixDec.value(-2pi, 4)
-> -6.2832

//and integers
~fixDec.value(10000, 4)
-> 10000.0000

~fixDec.value(10000, 0)
-> 10000.

anneVideotracking4

a much improved version of my old max application anneVideotracking

with this version you can use 12 zones on a webcamera video input to trigger midi, soundfiles, audio input (mics) and osc messages (send to supercollider for example).
the zones include filters and different types of thresholds and calibration. the data can be on/off triggers and or continuous values.

(sorry for the terrible gui design.)

download the mac standalone from here.

and here's the updated supercollider example that demonstrates how to use the osc data to control some sine oscillators.

//to start: select all & cmd+enter
//to stop: cmd + .
(
n= 12;
s.latency= 0.05;
s.waitForBoot{
        var dlast= 0.dup(n);
        d= {Bus.control(s, 1)}.dup(n);
        e= {Bus.control(s, 1)}.dup(n);
        OSCFunc({|m|
                var index= m[1], val= m[2], diff= (val-dlast[index]).abs;
                //m.postln;
                d[index].set(val);
                e[index].set(diff);
                dlast.put(index, val);
        }, \anneVideoTracking);
        CmdPeriod.doOnce({d.do{|x| x.free}; e.do{|x| x.free}});
        SynthDef(\annetest, {
                var src= Mix({|i| SinOsc.ar(i*100+400, 0, LagUD.kr(In.kr(e[i].index), 0.01, 0.1))}.dup(n));
                Out.ar(0, Pan2.ar(src));
        }).add;
        s.sync;
        Synth(\annetest);
};
)

midi pedals

here's how i built a usb foot pedal that sends out midi cc messages as well as note on/off messages when crossing some threshold.

to get a rugged pedal i bought a sewing machine foot pedal / speed control. for converting to midi and connecting to a computer i used a digispark module. the two other parts needed was a 3,5mm socket and a 4K7 resistor.

pedal01

pedal00

the code for the digispark is really simple and i programmed it from the arduino ide. THRESH_HI and THRESH_LO together with the state variable implements hysteresis, and lastVal is used to filter out any repeating values.

//with Digispark (Default - 16.5mhz)
//connect 4.7K resistor between tip and 5v, tip to P2 and sleeve to gnd

//usb yellow or red     5v
//usb white             data-
//usb green             data+
//usb grey or black     gnd

#define USB_CFG_DEVICE_NAME     'm','i','d','i','P','e','d','a','l'
#define USB_CFG_DEVICE_NAME_LEN 9
#include <DigiMIDI.h>

#define PINLED 1      //onboard led
#define PINSENSOR A1  //foot controller sensor (P2)
#define PINGND 0      //ground
#define CTRL 7        //midi controller (cc)
#define NOTE 99       //midi note
#define VELO 64       //midi velocity
#define CHAN 9        //midi channel
#define THRESH_HI 100 //0-127
#define THRESH_LO 50  //0-127

DigiMIDIDevice midi;
int lastVal = 0;
int state = 0;

void setup() {
  pinMode(PINLED, OUTPUT);
  pinMode(PINGND, OUTPUT);
  digitalWrite(PINGND, LOW);
  midi.sendNoteOff(NOTE, VELO, CHAN);
}

void loop() {
  midi.update();
  int val = analogRead(PINSENSOR);
  val = constrain(val, 9, 900);
  val = map(val, 9, 900, 127, 0);
  if (val != lastVal) {
    midi.sendControlChange(CTRL, val, CHAN);
    if (state == 0 && val > THRESH_HI) {
      midi.sendNoteOn(NOTE, VELO, CHAN);
      digitalWrite(PINLED, HIGH);
      state = 1;
    } else {
      if (state == 1 && val < THRESH_LO) {
        midi.sendNoteOff(NOTE, VELO, CHAN);
        digitalWrite(PINLED, LOW);
        state = 0;
      }
    }
    lastVal = val;
  }
  midi.delay(100);
}

some supercollider test code...

MIDIClient.init;
MIDIIn.connectAll;
MIDIdef.cc(\pedalCont, {|...args| [\pedalCont, args].postln}, 7, 8);
MIDIdef.noteOn(\pedalOn, {|...args| [\pedalOn, args].postln}, 99);
MIDIdef.noteOff(\pedalOff, {|...args| [\pedalOff, args].postln}, 99);

MIDIdef.trace;

for another project i also made a 3d printed variant. this one is not so rugged and only acts as an on/off switch. it's based on Adafruit's USB_Foot_Switch_Controller but modified to fit a digispark.

pedal02

arduino code for this discrete pedal (only note on/off)...

//with Digispark (Default - 16.5mhz)
//modified Adafruit's USB_Foot_Switch_Controller

#define USB_CFG_DEVICE_NAME     'm','i','d','i','P','e','d','a','l'
#define USB_CFG_DEVICE_NAME_LEN 9
#include <DigiMIDI.h>

#define PINLED 1  //onboard led
#define PINSENSOR 2 //switch
#define NOTE 89  //midi note
#define VELO 64  //midi velocity
#define CHAN 9  //midi channel

DigiMIDIDevice midi;

int state = 0;

void setup() {
  pinMode(PINSENSOR, INPUT_PULLUP);
  pinMode(PINLED, OUTPUT);
  midi.sendNoteOff(NOTE, VELO, CHAN);
}

void loop() {
  midi.update();

  if (digitalRead(PINSENSOR) == 0) {
    if (state == 0) {
      digitalWrite(PINLED, HIGH);
      midi.sendNoteOn(NOTE, VELO, CHAN);
      state = 1;
    }
  } else {
    if (state == 1) {
      digitalWrite(PINLED, LOW);
      midi.sendNoteOff(NOTE, VELO, CHAN);
      state = 0;
    }
  }
  midi.delay(100);
}

openbci wifi shield diy

here is how i built my own wifi shield for the openbci cyton and ganglion boards. the total cost was less than €10.

see the schematics.

* 1 esp8266-12 module
* 1 esp8266-12 adapter
* 2 push buttons
* 3 blue leds
* 1 ncp1117 voltage regulator
* 1 jst connector
* some resistors and capacitors
* pin headers and a piece of veroboard

on the white adapter board i first removed the 0K resistor link in the middle (R2). then i cut the two tracks that run from VCC to the left hand side 10K resistor (R3). next i soldered on a ncp1117 on the back side (not visible in the photo) and finally added two 100nF caps.

then i mounted the esp+adapter on a vero board, added male pin headers and the other components and wires.

IMG_20180626_160641

IMG_20180626_160755

it looks very rough but works great. here are instructions on how to upload firmware and how to use it.

bluetooth module repair

this documents a repair of a cyton board. the board would turn on and kind of work but one couldn't upload new firmware to it.

i localised the issue to the RFD22301 (aka RFDuino) module. i desoldered it from the board using some rose's metal - a material with low melting temperature (94°c) - and then put on new temporary pins to a few pads and put it on a breadboard.

IMG_20180607_153919

the module sort of worked but it still wouldn't be programmed. after lifting the metal can and checking the all the connections, i found a broken trace from the chip out to the rf_rxd pad (gpio0/aref) on the module. tracing the fault a bit further it turned out to be a broken via. i tried to refill the via with solder but it was just too small to repair. so i ended up adding a thin copper wire directly from the pin to the pad and wrapped it in some kapton tape for isolation.

IMG_20180608_070749

i had to cut out a slot in the metal can so that my wire could get out without getting squeezed and shorting to ground. it doesn't look pretty, but the module now worked and i could finally upload new firmware. and after soldering the can back and putting back the module, the cyton board worked again.

IMG_20180608_081319

i also repaired a broken trace on one of the serial lines. it's visible on the right hand side in the photo.

lidarsensor

last summer i wrote code to talk to the ydlidar x4 lidar – 360-degree laser range scanner. it was quite difficult to parse the data and get correct readout of the point cloud. the X4_Lidar_Development_Manual.pdf had all the information but it was quite obscure.

lidar_test

i also added tracking (red cross in the screenshot) to figure out coordinates of a person moving around in a room. nothing fancy but worked ok.

see attached code. it is for unity3d and written in c#.

AttachmentSize
Binary Data Lidar.cs15.5 KB

Pages

Subscribe to f0blog RSS