OSC (OpenSoundControl) support?!

[xelarep]

It would be great to have a simple OSC support to control Tasmota devices directly from audio/music applications.
E.g.

• switch on/off a recording light, studio light connected to a Tasmota device (main use case)
• get a OSC message if a Tasmota device has been turned on (nice to have)

--> https://ccrma.stanford.edu/groups/osc/index.html
--> https://gigperformer.com

I'm not very familar with the architectuire of Tasmota, nor a real programmer.
However could support with testing and bring this to live :-)

[Staars]

Technically it is very likely possible with Berry.
Can you name an open source (audio) tool, that does what you want? I would give it a try.

[xelarep]

Hi Staars, great to see you!
I'm using commercial tools like Gig Performer or Songmaster Pro, however we can start with these free tools

OSC sender / transmit tool: https://github.com/yoggy/sendosc for the commandline
OSC receiver: https://hexler.net/protokol a free multi-platform monitoring app

From a very high flight level OSC looks some kind of similar to MQTT with variable ports

Transmit sendosc 127.0.0.1 8000 /power i 1

receives as

Sending/receiving OSC in an application typically uses different ports for proper communication on the same device...

So this would be my starting point on a Tasmota device like a SonOff S26

/power 1 - ON
/power 0 - OFF

A change in the power state on the Tasmota device would be transmitted in the other direction, but not echoed, if received by OSC!

[Staars]

Sonoff S26 features a ESP8266, hence no Berry.

But I will try the tools you mentioned. In ancient times I used Osculator, which was pretty unique back then, but the last released version was like from about 2010.

[Staars]

I hope the test code is somewhat accessible for you:

class OSC_Light_Controller : Driver
    var udp_server
    
    def init(port)
        self.udp_server = udp()
        self.udp_server.begin("", port)
        tasmota.add_driver(self)
    end
  
    def every_50ms()
        var packet = self.udp_server.read()
        if packet == nil return end
        
        var data = self.parse_osc(packet)
        print(data)
                
        # Handle /light/brightness
        if data["addr"] == "/light/brightness"
            if data["types"][0] == "i"
                var bri = data["args"][0]
                print("Set brightness:", bri)
                light.set({"bri": bri})
            end
        end
    end
  
    def parse_osc(packet)
    # Extract address as null-terminated string
    var addr = packet.asstring()
    var addr_len = size(addr)
    
    # Calculate padded address length (must be multiple of 4)
    var addr_padded = ((addr_len + 1 + 3) / 4) * 4  # +1 for null terminator
    
    # Type tag string starts after padded address
    var type_start = addr_padded
    
    # Verify type tag starts with comma
    if packet[type_start] != 0x2C
        return nil  # invalid OSC message
    end
    
    # Extract type tags (skip the comma)
    var types = []
    var i = type_start + 1
    while i < packet.size() && packet[i] != 0
        types.push(format("%c", packet[i]))
        i += 1
    end
    
    # Calculate where arguments start (after padded type tag string)
    var type_len = size(types) + 1  # +1 for comma
    var type_padded = ((type_len + 1 + 3) / 4) * 4  # +1 for null terminator
    var arg_start = type_start + type_padded
    
    # Parse arguments based on type tags
    var args = []
    var arg_pos = arg_start
    var j = 0
    
    while j < size(types)
        if types[j] == 'i'  # 32-bit integer
            var val = packet.geti(arg_pos, -4)
            args.push(val)
            arg_pos += 4
        elif types[j] == 'f'  # 32-bit float
            var val = packet.getfloat(arg_pos, true)
            args.push(val)
            arg_pos += 4
        elif types[j] == 'T'  # boolean true (no data bytes)
            args.push(true)
            # arg_pos stays same - no data!
        elif types[j] == 'F'  # boolean false (no data bytes)
            args.push(false)
            # arg_pos stays same - no data!
        elif types[j] == 's'  # OSC-string
            var str_val = ""
            var str_i = arg_pos
            while str_i < packet.size() && packet[str_i] != 0
                str_val += format("%c", packet[str_i])
                str_i += 1
            end
            args.push(str_val)
            var str_len = size(str_val) + 1
            var str_padded = ((str_len + 3) / 4) * 4
            arg_pos += str_padded
        end
        j += 1
    end
    
    return {"addr": addr, "types": types, "args": args}
    end
end

var osc = OSC_Light_Controller(57896)

So yes, it is possible.

[sfromis]

If you need to control a device based on ESP8266, you could have a ESP32 acting as a bridge to issue commands.

[xelarep]

Wow, thanks a lot @Staars 👍I can understand this sketch and I'm curious how to bring it to live 😃

@sfromis an additional bridge is a device I want to avoid.

I also could do a small Arduino sketch on a ESP8266 or ESP32 just providing the OSC functionalitty - I collected some basic information already - just need to do it ;-)
However my intention was to avoid just another specialized device, and so the idea grew: what if I could just "upgrade" one of my Tasmota devices, use ist as before AND have the possibility to control it by OSC additionally.

This devices would become more flexible, and maybe thats also intersting for others as well.

So, back to @Staars sketch: I'm a complete newbie in the Tasmota framework - I would describe my level as "I can reprogram physical devices with a USB/serial adapter and a corresponding binary" (which I sucessfully did in the past), I have intermediate github/programming experience. Did only a few things the last years... Otherwise, I'm just a Tasmota user for my iobroker smarthome installation...

❓ So where to start? Where to put this code snippet in and bring it to live? Is there already a branch/fork we could share, any starting tips?

PS: I'm on macOS and Ubuntu - Windows only if no other way 😁

[Staars]

This is no special branch or fork - only plain Berry, which would run on any ESP32-Tasmota-device, that does not have Berry disabled (basically any standard build of Tasmota-32 since the inclusion of Berry).

My starting point would be to test with the audio software of your choice for basic functionality:

1. Copy-paste the code snippet from above on the Berry console and start the code
2. Configure your audio tool to send to the exact handle: "/light/brightness" to of the ESP32 using the port of the example (57896) and sending an integer value.
3. Watch the console of the ESP32 from point 1, if the data arrives.

If that works, you can start investing time to build your real solution.

As @sfromis wrote you can still build a bridge with any ESP32-Tasmota device sitting in the same network. As long as you have already one, I would not call it an "extra device". Then you would have to translate OSC to MQTT message, which is not horribly complicated, but of course adds a bit of complexity.

[xelarep]

Ahh, got it. I mixed up Berry with Raspberry 😆

Will check it on the weekend! Just had a quick look at the relevant documentation - need to sort out my devices first, I mainly have a bunch of older 82xx based Sonoffs which seem not to be capable of Berry...

Thanks a lot, will get back soon!