Hi,
just for those who are interested and also want to use a Monome (mine is on the way 
):
I build a library with a set of functions which
- set the leds (
osc_) according to methods serialosc supports (set, map, row, col) and
- store the grid state (if needed on several
pages)
I am aware of the fact that I probably have some complicated, clumsy or just false ideas which shine through the code due to my lack of experience. But on the other hand: I am constantly learning and am quite glad what I have so far compared to what I knew a few months ago.
I also think that meanwhile I reached a point where it possibly would be better to not write code running in one of SP’s buffer but write an extension to the Sonic Pi core code in proper Ruby. (I probably will soon run into problems of when and how to load the code in the write order, name space issues and possibly also performance bottlenecks). I feel like a baby with a mind of a 18 year old that has not yet the means to express that.
So I will go on with my tiny and somewhat clumsy baby steps bearing in mind, that in the end I want to use this to make music and consider the coding progress as an gratifying and useful byproduct
Here is a preview of the code (just the code, no documentation, which is - I know - somehow impertinent) with the intention to show those who are interested the progress and maybe get some feedback and advice:
# grid-08.rb
set :host, "localhost"
set :port, 47120
use_osc get(:host), get(:port)
define :delay do | d = 0.0625|
sleep d
end
#
# Initialize PAGES array -
# a representation of the the grid in separate pages
#
set :num_pages, 5
set :grid_size, 8
pages = []
get(:num_pages).times do
y = []
8.times do
x = []
get(:grid_size).times do
x.push(0)
end
y.push(x)
end
pages.push(y)
end
set :pages, pages
#
# Page helper functions
#
define :pages_print do
pages.length.times do | p |
row = ""
puts "Page #{p}: ----------------"
pages[0].length.times do | y |
row += pages[p][y].to_s
puts pages[p][y].to_s
end
puts "------------------------"
end
end
# set single item of page p
# @param s {number} single state value
define :page_set do | p, s, x, y |
page = pages[p]
page[y][x] = s
pages[p] = page
set :pages, pages
end
#page_set(1, 1, 7, 7)
define :page_all do | p, s |
page = pages[p]
page = s
pages[p] = page
set :pages, pages
end
##| k = [[0, 0, 0, 0, 0, 0, 0, 1],
##| [0, 0, 0, 0, 0, 0, 1, 1],
##| [0, 0, 0, 0, 0, 1, 1, 1],
##| [0, 0, 0, 0, 1, 1, 1, 1],
##| [0, 0, 0, 1, 1, 1, 1, 1],
##| [0, 0, 1, 1, 1, 1, 1, 1],
##| [0, 1, 1, 1, 1, 1, 1, 1],
##| [1, 1, 1, 1, 1, 1, 1, 1]
##| ]
##| page_all(0, k)
define :page_row do | p, s, x |
page = pages[p]
page[x] = s
pages[p] = page
set :pages, pages
end
#page_row(0, [1, 1, 1, 1, 1, 1, 1, 1], 0)
define :page_col do | p, s, y |
page = pages[p]
get(:grid_size).times do | i |
page[i][y] = s[i]
end
pages[p] = page
set :pages, pages
end
#page_col(1, [1, 1, 1, 1, 1, 1, 1, 1], 7)
define :page_update do | p, s, x=nil, y=nil |
if x != nil and y == nil
page_row(p, x, s)
elsif x == nil and y != nil
page_col(p, s, y)
elsif x != nil and y != nil
page_all(p, s)
else
page_set(p, s, x, y)
end
end
define :osc_set do | x, y, s, page=0 |
osc "/grid/led/set", x, y, s
end
# Set all of device's leds to off or on
define :osc_all do | s |
osc "/grid/led/all", s
end
osc_all(0)
define :osc_map do | x_offset, y_offset, arr, page=0 |
state = []
arr.each_with_index do | y, i |
# arr 1-dimensional with decimal bitmask
if y.is_a? Integer
state[i] = y
else
# arr is 2-dimensional with 0 and 1
bin = ""
arr[i].each do | x |
bin += x.to_s
end
dec = bin.reverse.to_i(2)
state.push(dec)
end
end
osc "/grid/led/map", x_offset, y_offset, *state
end
##| m = [[1, 1, 1, 1, 1, 1, 1, 1],
##| [1, 0, 0, 0, 0, 0, 0, 0],
##| [1, 0, 0, 0, 0, 0, 0, 0],
##| [1, 0, 0, 0, 0, 0, 0, 0],
##| [1, 0, 0, 0, 0, 0, 0, 0],
##| [1, 0, 0, 0, 0, 0, 0, 0],
##| [1, 0, 0, 0, 0, 0, 0, 0],
##| [1, 1, 1, 1, 1, 1, 1, 1]]
##| osc_map(0, 0, m)
# osc_map(0, 0, [128, 192, 224, 240, 248, 252, 254, 255])
define :osc_row do | x_offset, y, s, page=0 |
state = []
if s.is_a? Integer
state = s
else
state = s.join.reverse.to_i(2)
end
osc "/grid/led/row", x_offset, y, state
page_update(0, state, nil, y)
end
#osc_row(0, 0, [0,1,1,1,0,0,1,1])
#osc_row(0, 0, 192)
define :osc_col do | x, y_offset, s, page=0|
state = []
if s.is_a? Integer
state = s
else
state = s.join.reverse.to_i(2)
end
osc "/grid/led/col", x, y_offset, state
end
#osc_col(5, 0, [0,1,1,1,1,1,1,1])
#osc_col(5, 0, 254)
define :toggle do | x, y, page = nil |
state = get(:pages)[0][y][x]
if state == 1
osc_set(x, y, 0, p)
state = 0
elsif state == 0
osc_set(x, y, 1, p)
state = 1
end
if page == nil
# if no page given update all pages
get(:num_pages).times do | p |
page_set(p, state, x, y)
end
else
# update only given page
page_set(page, state, x, y)
end
return state
end
# /// Testing //////////////////////////////////////////
live_loop :listen do
use_real_time
data = sync "/osc/monome/grid/key"
#data = sync k
x = data[0]
y = data[1]
s = data[2]
if data[2] == 1
if y == 7
case x
when 0
t = toggle(x, y)
if t
current_page = 1
end
when 1
t = toggle(x, y)
if t
current_page = 2
end
when 2
t = toggle(x, y)
if t
current_page = 3
end
when 3
t = toggle(x, y)
if t
current_page = 4
end
end
end
pages_print()
puts current_page
end
end
#page_set(1, 1, 7, 0)
PS.: The immediate objective is to port this application from Open Sound Control to the Monome.
