Tenori-On Midi Mapping


With the release of 2.1 firmware for the Yamaha Tenori-On (a 256 button grid), it is now possible to take control of the grid remotely, and send light on light off messages to and from the unit. Unfortunately, the unit sends and recieves only sysex messages.

My understanding is that Renoise cannot recieve sysex messages. So I have been trying to create a router using Bome’s Midi Translator. The idea is, the sysex comes into Bome’s, gets translated into a midi message, and sent through a virtual midi port into Renoise.

My first question is this: what should I be converting the sysex messages into? Should it be simple note on/off? The issue with this is, there are only 127 note on/off messages per channel…and the Tenori-on has 256 buttons. Is it possible to map the same notes on different channels in renoise?

I have managed to map the top half of the Tenori-on to (only) note on messages, and have been able to map the buttons to trigger patterns on/off, but when trying to map the bottom half on channel 2, troubles arose. Also, when trying to map the buttons to gridpie, for some reason only the top row would respond.

How do other (non osc) grid controllers work (launchpad, ohm64, etc.)? Do they use note on/off messages, or midi cc commands?

Is it possible to map each component of renoise to a specific velocity setting? If I was able to do this, I could fit all buttons into just 3 note on/off messages!

My ultimate intention is to use the tenori-on to control things like gridpie, the step sequencer, the mixer–and ideally I would like to create a Duplex map for the unit. As I have limited programming skills, and no current understanding of lua or the Renoise api…this could take some time.

Any hints would be very well received!



Hey, that’s good news!

In Renoise, you can map various MIDI port + channel combinations directly to the instrument. Not sure what you mean by “same notes” though - you want to trigger the same instrument using different channels? 256 buttons can represent more notes than MIDI can support, so there’s a pretty hard limit there.

Yes, for the most part, MIDI based grid controllers rely on note on/off messages.

Fitting 256 buttons is no small task. But have you considered using different MIDI channels - this might be easier to understand and maintain?

Creating a control-map for Duplex takes a little bit of care (it’s borderline programming), but it should be well worth it.
Just post whatever progress you make here, and I’m sure that I, or someone else, will assist you

Edit: one idea that you might want to consider is to split the Tenori into two separate parts/virtual ports → one goes into the standard Renoise MIDI input, for playing notes and triggering samples, and the other one for Duplex, or any other tool that might work with bi-directional communation.

Thanks for the quick reply! You were just the guy I was hoping to have respond…

My next question would be, does anyone know something other than Bome’s that I could use to easily translate sysex messages into midi messages? Especially something free? Bome’s is great, but with the free ‘classic’ version I believe I can only send data in one direction.

So, if I want to be able to tell Renoise what function to turn on and off, while simultaneously having Renoise tell the Tenori-on which lights to turn on or off, I would need to purchase the $100 pro version. I imagine something is possible in puredata, and if there is an easily editable patch this would be a good solution. Already tried midi-ox, and it’s impossible to translate sysex in with that.

Also, sysex to osc could be an option.

What I mean to say is, if I map pattern 1 ‘on’ to 90 0C 7F (channel one, C-0, velocity 127), and map pattern 2 ‘on’ to 91 0C 7F (channel two, C-0, velocity 127), will pattern one also turn on when I hit the button for pattern 2? Are all midi mappings channel specific?

Much appreciated. I’ve got several compositions to wrap up for school this week, so I’ll be delving further into this later on this month! :)


Yes, using PD would def. be a good and flexible solution. With a bit of extra effort, it could even be supported natively in Duplex, as the Renoise API has no problem dealing with sysex codes. This would be the optimal solution, true plug-and-play. But for now, best thing would be to simply get something working :slight_smile:

Ah, OK - I thought you meant binding MIDI notes to an instrument. You are talking about standard MIDI mappings, triggering patterns - actually, I’m not sure if the channel is considered then. Someone else might know this?

If mapping through the midi mapping dialog then channels are respected.

I hardly-ever use the native MIDI system, but you are obviously abusing it

Okay, so I think I’ve set up my sysex–>midi conversion table in Bomes correctly, but I’m having some issues. I’m including the translator patch here, and if anyone would like to take a look over it for me, it can be loaded with Bome’s classic which can be downloaded for free at:


I’ve divided the 256 button grid horizontally into two channels (8x16 each).

I’ve mapped the button on the top left to midi note 00 channel 1, and the button on row eight far right to note 7F channel 1. Then, the button on row nine far left is mapped to note 00 channel 2, and the button on row 16 far right to note 7F channel 2.

However, when testing out this mapping with renoise, renoise seems to consider note 00 as 0C, which is confusing. My understanding is that 00 should correspond to note C-1 (and Bome’s confirms this), but when this note is passed into renoise it is accepted as 0C or note C-0.

This results in the last eight buttons of each of the two sections being left unmapped.

For reference, I am using midi yoke to virtually run the midi out of Bome’s into renoise.

For further reference, the sysex code for the far left button on row one of the Tenori-on is…

F0 43 73 01 33 01 00 06 00 00 00 00 00 F7

The next button to the right is…

F0 43 73 01 33 01 00 06 01 00 00 00 00 F7

The button on the far left on row two is…

F0 43 73 01 33 01 00 06 00 01 00 00 00 F7

The next button to the right is…

F0 43 73 01 33 01 00 06 01 01 00 00 00 F7

…and it continues down in this fashion.

Any help, comments, ideas would be greatly appreciated!



Ahh, this is something like a Renoise’s local rule from old days.
I don’t remember the reason why clearly though, there is a 1 octave gap between external midi-notes and Renoise’s internal notes always. All the maps are made by taking the gap into consideration.

Is this something that I can account for within my Bome translation, or does it mean that it will be impossible to fully map all 127 note on/off messages of a given channel?


Mmmm, I don’t know about Bomes well though, in the case of Duplex, we use “C–1 (C minus 1)” for example when we make such map.
I’m not so good at sysex, so sorry that I cannot find the correct answer about your case. (really complex case :unsure:)

Isn’t that C minus minus one? Hex code 00 is listed as note C-1 (C minus one) in Bome’s, but accepted as C0 in Renoise. There is no way to make a note lower than 00 in Bome’s.

No matter! I appreciate the help so far.

Anybody have any other ideas on how to approach this? I’m guessing I’ll just have to put the last 16 notes on a third midi channel, which could be solved in the future by using the sysex codes directly in Duplex.

So I’ve now got a working translation map for Bome’s that includes both note on and off commands. Tenori-on midi out goes into Bome’s, first layer sysex note on/off commands are translated into midi on/off commands and sent into Renoise through midi-yoke.

This is awesome to use with the Lauflicht step sequencer!

I am including my Bome’s translation maps here, and there are two versions. The first version is a generic translator map based on two channels (first 128 buttons on channel one, second 128 buttons on channel two). Using this mapping with Renoise, the last 8 buttons of the two channels will be left out. The second version uses three channels, and will allow all Tenori-on buttons to be mapped to Renoise.

Note that these mappings will currently only work in one direction, as Bome’s classic (free edition) allows only for one midi in and one midi out. The full version, at $100, should allow for bidirectional communication.

My question is thus–how can I begin to create a duplex mapping implementing the sysex codes directly, and skipping the Bome’s translation process entirely? What should I look at first?

The Tenori-on could prove to be the ultimate (albeit overly expensive) Renoise controller. There are 16 layers available on the unit, which exist sort of like traditional DAW tracks. There is a different sysex code for every button on every layer of the unit. Thus, layer one could control a 16x16 step sequencer, layer two could offer four 8x8 XY control devices, layer three could allow a 16x16 gridpie, layer four a mixer…etc. All switchable by simply pressing button R1 and selecting a horizontal line on the grid.

Also, these mappings (and future Duplex layouts) should work with the Ipad TNR-I software as well. At $20 + Ipad cost, this could provide affordable control for many users.



Currently, I think this is difficult unless you have the lua programming skill enough, because it needs to improve the core code of Duplex itself. If you don’t have such skill (I also don’t have it at all), you should wait until it will be done by danoise or somebody others. If you can program lua well, of course you can try it, though I cannot help about such part.

But according to your post, it seems that Tenori-on can be used as a common “one direction” controller already. Then it’s not difficult just to make some Duplex mappings.

( :excl: Oh, now I have to correct a bit about my former post. Though I had said that there is a 1 octave gap in Renoise, it’s only about the native midi mapping of Renoise. About Duplex, it seems that you don’t need to consider it.)

Then temporary, I tried to make a very simple Duplex map for Tenori-on, just for checking whether it works or not.
About how to treat this file(s), please see this article. I guess it should work, maybe I’m wrong something though… :huh:

Holy! Nicely done, and many thanks for this! Single direction control works perfectly with this map you created.

Hopefully Danoise will have a moment to chime in on this. If it is currently impossible, then I will try to find a better (ie free) way to allow the Tenori-on bi-directional feedback, other than Bome’s. My programming skills are totally lacking, so I won’t be able to make these kinds of modifications…just yet.

Once I figure out the bi-directional feedback, I will check into creating Duplex mappings for things like Gridpie.

Also, one thing I had forgotten to mention in my last post regarding the usefulness of a Tenori-on for Renoise control: while there is a different sysex message for every button on every track or ‘layer’ (16 total), there are also unique sysex messages for every button on every layer of every pattern or ‘block’ (again, 16 total). Layer changes are made by pressing R1 and a given horizontal row, block changes are made by pressing R5 and a given vertical column.

To see how useful this is, imagine switching patterns in renoise by simply pressing R5 and a given vertical column. I’m going to re-map the block changes to midi notes to allow just this, but someday I would like to create a Tenori-on specific Renoise tool, as the possibilities of control here are seemingly endless.

Thanks for the help!


I’m definitely going to look into this sysex thing. If it’s possible to solve without the use of third-party tools, that would be great.

And as satobox says it might need a few changes here and there. The only thing that has me a bit worried, is the sheer amount of possible mappings/sysex messages, with 256 buttons capable of various states. Seems like we are talking many thousands?

For, I’d say that your something akin to your basic bome setup would be sufficient. Then, everything that has to do with ‘virtual pages’ and such could be added later on

Btw, I made a bit more realistic layouts include GridPie.
You can use SwitchConfiguration buttons too (2 buttons on the lower right coner).

Well after this, I want you to edit & create layouts by yourself by all means. :)
It is by no means difficult. It’s only somewhat troublesome due to too many buttons. :wacko:

Cool! I look forward to hearing what you’ve found, when you’ve got the time.

Indeed, 16(256*16)=65,536…this is a huge amount of information to map!

Issues could be alleviated by using variables on just 256 mappings. For example, the generic SYSEX code to turn of a given light is as follows:

F0 43 73 01 33 01 00 06 xx yy lyr 00 00 F7

…where xx= X-axis
yy= Y-axis
lyr= Layer number

…as it has turned out, dealing with the block data would be somewhat difficult, but simply having a variable in place of ‘lyr’ which could be changed between 00 and 0F to indicate a given layer might make considerable more sense than a huge table of data (256*16=4,096).

Seeing as there is a special SYSEX code that is sent when a layer is changed, I imagine it being fairly easy to write code switching around the ‘lyr’ variable as different layers are selected on the unit.

Absolutley! Just getting a single layer of 256 buttons to send and recieve data properly would be an achievement.

So amazing, satobox! I will for sure be working to build new playable layouts once I have bi-directional feedback working in some fashion.

I’ll report back in this thread once I have made some new developments…