Yamaha SPX Checksum calculation

[damiensellier]

Hi,
I am working on a Yamaha SPX900 SPX1000 and SPX990 panel right now and the before-last byte is a checksum byte.
According to my readings it seems that Yamaha uses two's complement check sum calculation method.

I checked the checksum value for several messages with an online calculator but the value given is not what I am supposed to get.

exemple
_F0 43 00 7E 00 1E 4C 4D 20 20 38 41 32 31 53 20_ 01 00 00 00 00 00 04 00 00 12 13 00 00 00 00 01 00 00 0B 04 **1E** F7
message is 01 00 00 00 00 00 04 00 00 12 13 00 00 00 00 01 00 00 0B 04

Checksum is 1E but the calculator gives C6

_F0 43 00 7E 00 1E 4C 4D 20 20 38 41 32 31 53 20_ 01 00 00 00 00 00 04 00 00 14 15 00 00 00 00 01 00 00 0B 04 **1A** F7

message is 01 00 00 00 00 00 04 00 00 14 15 00 00 00 00 01 00 00 0B 04
Checksum is 1A but the calculator gives C2

Do you know if the checksum are calculated for the whole message (header + message) or only the message?
What could gives such a difference in the check sum value?

Thanks a lot

Damien

[damiensellier]

Ok I think I got it!
It's an 8bit bytes two's complement calculator but midi is 0-127 7bit byte. This is why I get values above 7F...
I am going to use the method from this topic about roland checksum calculations on ctrlr.org

[dnaldoog]

Hi Damien,

Below are a couple of functions that should work! Looks like the offset from start is 6 bytes.

function checkSumMemoryBlock(sum)
    -- Yamaha checksum formula = checksum = ( NOT sum + 1 ) AND 0x7F
    -- thanks to IntEyes for this
    -- https://yamahamusicians.com/forum/viewtopic.php?t=6864
    local cs = bit.band(bit.bnot(sum) + 0x01, 0x7F)
    return cs
end --end function
---------------------------------------------------------

Here is how I did it with an incoming MemoryBlock:
YAMAHA CHECKSUM_1_0_2021-04-07_23-00.zip

myMethod = function(--[[ CtrlrModulator --]] mod --[[ number --]], value --[[ number --]], source)
    local offset, csEox = 6, 2
    mf =
        MemoryBlock(
       L(panel:getLabel("input"):getText())
    )
    sizeofM = mf:getSize() - offset - 3
    m = MemoryBlock(mf:getRange(offset, mf:getSize() - offset - csEox):toHexString(1))

    local sum = 0
    for i = 0, m:getSize() - 1 do
        sum = sum + m:getByte(i)
    end

    local cs = checkSumMemoryBlock(sum)
    panel:getLabel("d"):setText(string.format("checkSum = %.2x (%d)", cs, cs))
end

function checkSumMemoryBlock(sum)
    -- Yamaha checksum formula = checksum = ( NOT sum + 1 ) AND 0x7F
    -- thanks to IntEyes for this
    -- https://yamahamusicians.com/forum/viewtopic.php?t=6864
    local cs = bit.band(bit.bnot(sum) + 0x01, 0x7F)
    return cs
end --end function

--[[
ee=(Invert('L'+ c+de)+1)&0x7F from Manual
--]]

[dnaldoog]

@dnaldoog it's either 5x8 LCD HD44780U A02 or 5x7 DOT Matrix they are the exact same font as on HD44780U displays.

Ask me if ever you need some of my scripts.
I'll try your panel on my PC later this weekend. I don't have windows10 near me.

Hey Damien,
What is the name of the ttf you are using in that screenshot. Looks nice.

Yes that is much better than the one I was using - thank you.

[dnaldoog]

Hi @damiensellier and tedjuh. Hope you are doing well!

I needed lua to be able to insert a negative number into a sysex message for the Korg m3r - I think it might relate to the subject of this post, but I am having trouble even understanding the code I wrote above! 🤔

Anyway, I think the goal in the post was to send a 4 bit nibble negative sysex message.

With the m3r, a negative is split into two bytes (14 bit). To do that in a Ctrlr Expression you can do:

lt (modulatorValue, 0, 16384 - (abs(modulatorValue)), modulatorValue) 

so -1 is sent as 7F 7F, -2 7E 7F and +1 is 01 00 of course. (order = lsb,msb in the case of Korg)

but I found a simple way to do it in lua. This method only allows a maximum absolute value of 127, but the m3r only ever goes to -99 as far as I can see. Just thought I would share it anyway. It seems to work well! The problem was mentioned in the old forums and I always stumble on the problem. Maybe there's a much better way to do it?

korg14BitValue = function(val) -- returns a negative 14 bit value limit -127 ~ +127
	local msb,lsb=0,0
    if val < 0 then
        msb = 127
        lsb = math.abs(bit.bnot(val) - 127)
    else
        lsb = val
    end
    return msb, lsb
end

function returns two values and is called with :

calculateNegatives = function(--[[ CtrlrModulator --]] mod --[[ number --]], value --[[ number --]], source)
    if panel:getBootstrapState() then
        return
    end
local msb,lsb=korg14BitValue(value)
panel:getLabelComponent("d"):setText(sf("\nF0 42 00 00 %.2X %.2X F7",lsb,msb))

end

An explanation

• Take a 16 bit signed number -1 = 1111 1111 1111 1111
• Flip each bit 0000 0000 0000 0000
• Subtract 127 = -127
• Make the MSB 127 if negative otherwise 0
• Make LSB positive 127 0x7F

---

• Take a 16 bit signed number -99 = 1111 1111 1001 1101
• Flip each bit 98 0000 0000 0110 0010
• Subtract 98 - 127 = -29
• Make the MSB 127 if negative otherwise 0
• Make LSB positive 29 0x1D

Korg lua negative sysex_1_0.zip

[damiensellier]

Hi John, everything is fine on my side, actually very busy, I don't have a lot of time those last few months to code panels.
Your method is cleaner than the previous one, I used the other on many projects, if I require negative value split to several nibbles like this I'll use your new one.
Hope everything is alright on your side John. Cheers from Montreal

[dnaldoog]

Actually, there is an even easier way to calculate a negative value! 😆

korg14BitValue2 = function(val) -- returns a negative 14 bit value limit -127 ~ +127
	local msb,lsb=0,0
    if val < 0 then
        msb = 127
        lsb = 128-math.abs(val)
    else
        msb = 0
        lsb = val
    end
    return msb, lsb
end

[dnaldoog]

Finally, this is probably the most efficient! 😁

korg14BitValue = function(val)
    local msb = bit.rshift(val, 31)
    local lsb = (128 * msb) + val
    return msb*127, lsb
end

or this:

korg14BitValue = function(val)
    local tmp = bit.band(0x7f7f, val)
    local msb = bit.rshift(bit.band(tmp, 0x7f00), 8)
    local lsb = bit.band(tmp, 0x7f)
    return msb, lsb
end