Monome Device ID guide?

Is there a guide to deciphering monome device id strings?

For example, based on the id/serial number, is it possible to determine which model is in use (and thus which features are available)?

Use case: create a reference table for norns that lists all monome device IDs and returns what features are available - monobright vs. varibright, tilt, etc.

EDIT: Here’s what I can glean from the monome website editions page:

year, model, brightness, brightness steps, tilt
2006, 40h, mono, 1, 0
2007, 40h-se, mono, 1, 1
2007, 40h-kit, mono, 1, 1 
2007, series, mono, 1, 1
2010, mk, mono, 1, 1
2011, grid, vari, 4, 1
2012, grid, vari, 16, 1
2013, grid, vari, 16, 0
2014, grid, vari, 16, 0
2015, grid, vari, 16, 0

in short, sortof.

libmonome supports the 3 different serial protocols: 40h, series, and mext. you can make a lot of assumptions by which protocol is used, with only minor errors. ie, 2011 4vari “work” fine with 16-step programming.

OK yeah - I forgot about that.

However, the protocol in use is not exposed to Lua anywhere on norns is it?

check_monome_device_desc() in libavr32 deduces protocol/features from id/serial.


I’d love to know about this aswell. I’d like to deduce model from the info communicated in the serialosc protocol for my SerialOSCClient SuperCollider lib.

From libavr32 above I made this lua snippet:

for i,v in pairs(grid.list) do
    print(grid.list[i]) -- device name
    if string.find (grid.list[i], "a40h") then 
        print ("arduinome")
    elseif string.find (grid.list[i], "40h") then 
        print ("40h")
    elseif string.find (grid.list[i], "m64-") then 
        print ("series 64")
    elseif string.find (grid.list[i], "m128-") then 
        print ("series 128")
    elseif string.find (grid.list[i], "m256-") then 
        print ("series 256")
        print ("other mext device")

Otherwise in serialosc you can get some info from sys

// sys


pattern:	/sys/query
desc:		request device information
serial:		[0x00]

pattern:	/sys/id
desc:		request device ID string
serial:		[0x01]

pattern:	/sys/size	
desc:		request grid size
serial:		[0x05]

Output from those is:

//// output (from serialosc/device)

// sys

pattern:	/sys/query s n
desc:		device information
serial:		[0x00, s, n]
args:		s = subsection, enumerated as strings [null, "led-grid", "key-grid", "digital-out", "digital-in", "encoder", "analog-in", "analog-out", "tilt", "led-ring"]
			n = number

pattern:	/sys/id s[64]
desc:		device ID string
serial:		[0x01, s[64]]
args:		s = id string, 64 chars

pattern:	/sys/size x y	
desc:		grid size
serial:		[0x05, x, y]
args:		x = x size
			y = y size
1 Like

Thanks. Yeah, what I’m really after, though is information on the granularity you posted above. Metadata on: brightness, brightness step, tilt. I haven’t found a way to infer this from the id.


From the info I posted at the top you can make some of those inferences, But with the 40h it’s unclear which is which (since the 2006 does not have tilt) and then the 2011 grid has 4 steps of brighness, etc.

@tehn is there any format to the number digits in serial numbers that would help narrow this down?

Yeah some but unfortunately not all. AFAIK ”series 64” can mean mono or vari w/ different levels of brightness…

2011 grid 4 step is fully compatible with 16 step, don’t bother differentiating. there are no vari series devices. no, i don’t have serial number info unfortunately, but i don’t think it’s necessary.

also a better place to build/expose this functionality/information would probably be in libmonome itself?

Doing some more hacking in this area today and saw this discrepancy

in the monome serial spec, serialosc and monome protocol seem to handle the device ID string differently - serialosc is 64 bytes, but monome protocol is 32 bytes

Is this anything I need to worry about or account for when trying to read or write a monome deviceID ?

/// output (from serialosc/device)
// sys
pattern:	/sys/id s[64]
desc:		device ID string
serial:		[0x01, s[64]]
args:		s = id string, 64 chars
monome protocol

from device:

0x01 system / ID
bytes: 33
structure: [0x01, d0..31]
description: respond with ID (text string)

@okyeron you may want to look at the monome_get_proto function from libmonome. this will return the protocol string for the given device: ["40h", "series", "mext"]

we don’t expose this function in lua b/c in theory it shouldn’t matter which protocol is used. we certainly could do so, or it could likely be inferred from the device name which we get from monome_get_friendly_name().

we do of course report row/col count.

off the top of my head, i don’t think there’s a simple way to query libmonome about varibright support. libmonome is open source of course :slight_smile: so i’d say feel free to propose/implement such an addition. (that’s rather presumptive of me, being neither the author nor the maintainer of the lib.)

(norns uses libmonome by the way, not libavr32; the latter is much more basic and not really designed to provide a high-level API.)

Yup yup - got that about norns/libmonome. :+1:

However, in this case I’m working on teensy code for my little monome-midi device as well as my diy grid/arc devices.

The curiosity was when reading or writing the system id - do I need to account for 64 bytes in any situation?

seems like its 32 bytes in the serial protocol, 64B in serialosc.

just a guess, but maybe its just a utf8 ascii string and a utf16 unicode string, respectively? (serial protocol, network protocol)

sorry to be redundant before, i was just responding to this

and agreeing with this

1 Like