Programming Note Limits for Yamaha DX/TX

Print | posted on Saturday, January 24, 2026 5:27 AM

This is mostly a post for my fellow synth heads and to have it published as a point of reference. If you are mostly interested in things Microsoft or modern, you can safely go back to doom scrolling on Linked Out, without reading any further!

I am also increasing my presentation examples of the complete claptrap generative slop tools push out, despite music theory being 50% mathematics and in this case the make up of DX parameters being entirely basic mathematics (8 bit) and (almost) fully documented on copyright free websites. Exactly the sorts of patterns “AI” should have by now learnt and that do not need to be embellished with bullshit content from Reddit. The problem being of course, is that the idiots creating “AI” really aren’t that familiar with actual computer science and definitely can’t count in HEX. It’s their loss, but it sure is a shame they persist in inflicting their sadness on the rest of us. I have a good example of this towards the end of the article.

At any rate, Note Limits (aka Key Limits) are a mechanism within Yamaha DX series synthesizers which allow in essence, splits. Meaning different parts of the keyboard play different voices. These parameters make up part of a DX Function. Functions in DX terminology are how various controllers (Pitch Bend, After Touch, Modulation etc) are sensitive to and respond to adjustments during performance. They also control Poly and Mono modes and Portamento and Glissando.

The DX7 has Function Parameters which change the global settings on the board (for every voice). There is no memory for storing or recalling these parameter sets.

The DX5 and DX1 have memory banks for Functions along with Performance parameters and memories which are combined with the voice(s) to allow recall of Functions on a per Performance basis. Enabling different Functions for different voices.
The TX7 and TF1 have it’s own Function Parameters and memory which are specific to each voice.
The TX7 also has a separate memory bank for a DX7 Function that can be applied to the DX7 when paired with one (making a DX7 a poor man’s DX5).

The good news is all of these share the same basic data format and for the most part, parameters. The TX and TF add Note Limit Low and Note Limit High. The bad news is the terms Function and Performance are frequently used interchangeably.

At any rate, editing / programming these two parameters (Note Limit Low and Note Limit High) is something that only one software tool can do, and it’s entirely (until now) undocumented.

Most modern software editors (DEXED, Ctrlr, PatchBase, etc) for DX basically ignore the Functions. And the ones that do allow them to be changed basically work the same as with the DX7  i.e. global. There is one exception. More on that later. Why is this an issue? Well the whole point of having patches recallable during a performance is to have ALL of the elements of the performance available. This includes, for example, bringing in strings with a foot controller whilst playing a piano, and so on. If a multi-timbral performance has say a drum kit spread across eight splits, it’s not much use when on recall those settings are not present! Now of course, you aren’t playing drums using splits but still an eight part multi-timbral performance is absolutely a thing. Just ask Dr. Fink.

You can, of course, program these parameters on the front panel of the synth. :) Yeah. Not happening. That’s for gear heads, not musicians.

Now, DX Function/Performance parameters are in SYSEX (MIDI) data format – just like DX voice parameters. It’s a relatively simple HEX schema, and very ingenious of the smart (real) programmers at Yamaha to drive not only the tone generators but also the operation of the panel and display etc. Now bulk data is a bit more complicated in terms of schema, but no big deal. All done when MIDI was brand new and they had 4KB to work with.

Thus, if you wish to set the mode to Mono, and the Portamento to Follow with a Portamento time of 50, you can send a simple SYSEX to the board, or do that via some fancy application which slides virtual faders and twiddles knobs into HEX. Lovely. You can also store that into a Function memory bank if that exists.

However the Note Limits are NOT parameters. They don’t exist in the Function/Parameter schema, and are not part of the body of the SYSEX message!

We can set the global Note Limits via SYSEX, but they apply to all voices. Useful, but not quite the Delectados you would like. On the TF1 we can set the Note Limits on the front panel and save the Function on a per voice basis. But the TF1 panel offers you a grand total of three buttons to perform that task and you need to do that for every voice on every module. So for the “factory” patches of the TX816 that’s 34 voices (out of 256 in total). Same deal with the TX7.

The TF1 ‘factory’ patches are on the ‘net, but whoever dumped them only dumped the voices, not the functions. Whoops.

That’s why 99% of all the doofuses on YouTube with a TX they paid too much for in this century are playing without the fundamental performance characteristics of the synth present and going “wow just hear the stack, like, epic, like, amazing” whilst not using a pedal or setting the pans on their mixer. :)

So, they can be stored, but they aren’t parameters. So where the hell are they? Well in typical sneaky trying to save on memory (ahh those were the days, when programmers cared about memory) fashion. They are in the name! :) Of course they are!

Check out this Function dump of a TF1 used on the Michael Jackson Bad World Tour 1988. The highlighted voice was performed by Don Boyette via a KX1. It SLAMMED. The bass, not the KX1, which was rarer than hens teeth, even in the 1980s. Not that it mattered during the show, but this patch was so slamming it almost covered up the sound of the techs cursing when they had to replace another TX816 PSU.

Couple of interesting things to note here. Firstly the Function memory is contained within the 2nd 4K block. The person who dumped this TF1 knew which buttons to press, even if I say so myself! This is a voice and function dump.

Second is the name of the Function memory, which matches the voice but then has additional text. This is why the patch names were constrained (something a lot of people had problems grokking back in the 80s). There is also a preceding character and the overall expected “string” is totally different to that of the matching voice.

But the really important part is what follows the name, in this case ‘Lo:C –2 Hi: G 8 ‘ – that’s actually the default (and probably the global) note limits for the TF1 module. It means the lowest note is MIDI note 0 (two octaves lower than C0) and the highest note is MIDI note 127 (G8). In practice this means the whole board plays the voice.

Note: Yamaha use C3 as middle C (261.63 Hz) on DX – MIDI note 60 – most use C4.

So by editing the name (correctly) the limits can be set on a per voice basis.

And for those following along, these settings are of course part of the SYSEX message, it’s just that they are not parameters and as such they are not documented.

This is the default ‘string’ for the E.PNO 13.2 voice:

13 E.PNO 13.2  Lo:C -2 Hi:G 8 

Let’s say you want a Synth Drum voice, that is played only by the keys E3 and above, the settings would be Low: E3 High: G8.

Simples, right? Just enter those in the name. Well hold on there a second. The format is important. The string needs to be, exactly:

24 MBLOK 24.8  Lo:E 3  Hi:G 8 

The function number, followed by the voice name, followed by the Lo and High with their respective values.

But (!) there are some spaces. between E and 3, G and 8, one at the very end. Two between the two values and one at the end. But the eagle eyed will note in this example there are two spaces between the two values, whereas in the default there is only one. It’s actually a trailing space of the low value for this example, to enable “X octaves lower/higher than” as in the default. It’s the same for the high value (the end space) that might be G -2. That one at the end, by the way is not displayed in the ‘code’ view – the view source button shows it.

The spaces are needed because they provide for the black keys. For example:

12 FLEXI 12.2  Lo:C#1  Hi:F#1 

No spaces in the note – as that is used by a sharp. The trailing space is important as noted above – the ‘string’ needs to be 30 characters. Basically any valid combination adds up to 30.

11 FMPNO 11.2  Lo:C -2 Hi:G 8 
03 P.ORG  3.2  Lo:C -2 Hi:G 8 
12 FLEXI 12.2  Lo:C#1  Hi:F#1 
24 MBLOK 24.8  Lo:E 3  Hi:G 8 
13 E.PNO 13.2  Lo:C -2 Hi:G 8 

If you don’t follow the format perfectly, the settings won’t work.

Now, of course, you can’t send that as is, it needs to be in HEX, but you know that’s trivial and you’re just gonna use a SYSEX tool or library for that stuff.

Don’t get me started on ranges 0~99 and 0~15. I used to use that as programming test for new starters. I’d LOVE to see how CS graduates would approach that these days! :)

It’s curious that no editors fully support this – at least not intentionally. Some modern editors do allow setting the parameters of the DX7 – but do not include the note limits, or only allow them set globally. A lot of modern DX editors completely ignore the functions entirely. Methinks they don’t really play music, just fiddle with gear, not that there is anything wrong with that per se.

I went back and checked out the Atari ST editor – or rather a port of it – it only handles the global note limits (which are parameters in the formal specification). I didn’t bother with any of the Java stuff, there are limits to how much utter crap I will install on a box!

The TX7 editor in SoundDiver (excellent software shit canned by Apple when they acquired Logic – boo Apple, you SUCK!) – same deal in the supplied TX ‘adaptation’. There is a community adaptation specifically for the TF1 and that also cannot set the note limits without editing the name. This seemingly stalled around a decade ago development actually tells the user in the interface NOT to edit, because it “doesn’t work”. I can’t actually get this ‘adaptation’ to function reliably with my TF1s anyway. The paid for MidiQuest (which is turdtastic in general) only supports the globals.

As part of the development of my Teensy based DX programmer, I had already built a library to translate from ‘human’ to ‘DX sysex’, which in effect is just a giant dimensional array. So I extended that to include the “name” as an experiment and knocked up a quick and dirty UI in PowerShell – works great.

It would be trivial to build a proper UI to wrap this, allow for entry of note values range constrained, then concat the correct string and send back to the synth, thus avoiding any PBKAC error. But there is a wrinkle, the name must be saved and then the Function set retrieved before the parameters can be edited. You cannot do it a single operation. The only time a single operation is allowed, is when you send the entire bank (32) – i.e. a SYSEX dump of all function memories TO the synth.

Alas as of today, the only software that does this, on a per Function Memory basis, is DX Manager, by editing precisely the string in the Performance combo box and saving it (by reselecting it) – you have to save the name before altering the parameters. This doesn’t appear to be intended functionality. But it does work. The combo box by the way does not allow you to see your cursor!

Now for the “AI” part.

I “prompt engineered” Claude (“trained to be safe, accurate, and secure”) with information on where the correct SYSEX MIDI Data Format tables exist (copyright free) and which MCP to use for handling them. I specified the totality of potential options for the name and the format masks. I also provided it my look up dictionary, and a UI definition. Remember the output as it were, is all HEX.

And yes, it made a total mess of it. It horlicks it up the gazoo, and back. The only thing it could do without barfing slop was the UI. It created a program that will attempt to save corrupt SYSEX to the synth and light up the panel error LEDs.

What did it stuff up? Well it couldn’t handle the parameter SYSEX properly – it created results that included dozens of errors, including some that were invalid HEX!  0G is not HEX. LOL. All that computing power and yet…. well I guess we don’t need clean water after all.

Why did it make this most epic fail? Because it decided the digital data provided and the instructions to generate HEX weren’t as useful as the stuff on the MCP. It didn’t use convert where it should have done. It also appears that the MCP messed up the OCR (the scans of the MIDI Data Format tables). Further it provided no validation (maybe my mistake for not specifying such a basic concept). It made code just like what 1990s web sites used to do – hey man, that input data is all good, we’ll just pass it straight into the SQL query, what could possibly go wrong?! :)

So I went back and asked it do a smaller task, by providing a portion of the MIDI Data Format tables in digital form. I did two, one with a deliberate mistake, and one without. I gave explicit instructions to validate and ensure all output was valid HEX. That worked. So to make it even in any way feasible that “AI” could assist here I need to type the entire data format again, by which time I could have coded it myself. Oh wait, I done got busy doing that already – it’s the damn dictionary. The one I gave my ‘intelligent’ assistant in the first place.

And the name thing, yeah it couldn’t grok it, despite the note lookup table provided. Another thing it barfed slop on was not understanding repetition symbols in the documentation. That one is excusable, but disappointing nonetheless.

Naturally, I could (in theory) solve all of these problems by providing it with a dump of the ROM. That is also known as copyright theft and I am not up for that. There’s a reason the Yamaha Montage costs what it does. That’s people’s intellectual property, and it’s also their healthcare, mortgages and pensions.

I asked it to do something so trivial if I want to I can write out the conversion with pencil on paper. Without the internet. And yet. Slop. Pure slop.

Obviously, I already knew it would produce slop. But I was quite surprised by how bad it was. All this “let it do the heavy lifting and have an expert review the output“ bullshit we are being sold by the Technology Industrial Complex can’t do what Yamaha did in 4KB in 1982. And is a irresponsible waste of resources for zero tangible benefit. I guess it’s not made for people who can code, but more for those who want to throw ‘ideas’ at a wall.

We should go back to teaching people how computers actually work. But we won’t… there’s too many memes to make.