FYI: got my DALI bus driver in the mail today and did the full setup; managed to get everything up and running!

Will keep you posted on any further development wrt to the upstream python-dali library / any MQTT front-end I'd like to add.

@martin-kudláček yeah, I guess it does indeed make sense to have a separate power supply from a network point of view. I'll try again as soon as I will be able to get one.

Apart from the hardware setup, do you have any further documentation on how to address the DALI busses? From what I understand from your python implementation, you just have a modbus server running which you use to update specific registers. I guess this should be good enough for now, but given I'd like to translate between MQTT events and the DALI bus, I would also be interested in learning how to directly interface with it.

@martin-kudláček Thanks for your reply!

I indeed do not have a separate DALI power supply, as I was under the impression that this would already have been provided by the Axon module. Do you have some suggestions of a proper DALI-bus specific power supply? Is a single power supply for all 4 busses OK, or does each bus need it own power supply?

Anyways, glad to learn something's just off with the setup I have.

I took up the sysfs-based approach in my own (golang-based) project: https://github.com/mhemeryck/unipitt

Basically, it does active polling on a series of files, representing the different inputs and pushes out an MQTT-event in case there's a change.

@sennevds

My notes:

1. reading of inputs: works reasonably well right now. I did create my own implementation (based on golang) that basically just polls the states of the switches continuously and pushes out any change as an MQTT event -- processed directly by home assistant. The polling implementation works on the background and eats about 5-10% CPU (still tolerable, might still be improved), switch behavior feels instantaneous for me.
2. writing outputs: my implementation is also able to again translate incoming MQTT events into toggle outputs. Here, you don't need to poll directly (the MQTT handler itself is able to deal with that). Alternatively, you could look into home assistant modbus, to send a modbus command directly from home assistant. My implementation completely sidesteps the whole modbus translation phase, so if you'd be using it for reading, writing would make sense as well.
3. pushing out DALI commands: I did receive my axons S605 not that long ago, been fiddling with it, see https://forum.unipi.technology/topic/966/dali-interface-integration-in-python-dali . I have the feeling support for this product is still in its infancy, as well as the python-dali library it depends on. If I would have some more low-level documentation on it, I would very much like to take the development on this to a higher level!

If you'd like more input on how to use the unipitt binaries, and you feel a bit tech-savvy yourself, I'd be happy to help you set it up. That way, I can improve the project to make it more robust a portable for other interested users.

Did some reading and some (real rough) coding already; https://github.com/sde1000/python-dali/compare/master...mhemeryck:unipi and did try to set up all the hardware.

For now, I can't detect anything on the bus, so I'd like to check a few things:

• hw setup: does it matter what kind of wiring I use to connect the DALI bus? I currently used a 8-wire SVV cable (0.8mm2 diameter)
• wiring: I notice there are 4 "busses" on the axon S605, each having 2 connectors. I guess each of the 4 are for one set of 64 devices and that you have 2 connectors such that you can loop the signal through the bus. For my setup, with only one test LED driver, I guess it's OK to just use one of the connectors (no need to create a loop? Not even sure that's safe ...)

Implementation; I'm currently just testing the "commissioning". As I understood it, this means a first phase in which the axon scans the bus, find devices and assigns short addresses.

The particular code I'm using is (taken from your repo):

    bus_driver = SyncUnipiDALIDriver(bus=0)
    logger = logging.getLogger("UnipiDALIDriver")
    bus_driver.logger = logger
    bus_driver.debug = True
    light_bus = Bus(name="1_01", interface=bus_driver)
    light_bus.assign_short_addresses()
    print(light_bus._devices)

i.e. I just check whether any devices were found. Does this make sense? Is the number of the buses 0-based?

Another implementation note: my understanding is that this driver just does a translation between a modbus (TCP) server that's running on the device. Is it also possible to query the bus device directly, i.e. via a linux block device handle? (is that safe?). Also, how does the mapping modbus (TCP) / DALI driver work?

Thanks in advance,

Hi,

Update: tl;dr: I am really struggling to just getting started with the axon S605. I tried running a sort of "commissioning" with the unipidali implementation you propose, but I can't even read any voltage level responses from any of the outputs (simple voltage reader though, I don't have a scope). Is there any low-level documentation out there for me in order to be able to start programming against it?

Just recently received by axon S605 for DALI interfacing and I'm currently looking into the scripts you did write for controlling it; https://git.unipi.technology/UniPi/unipi-python-lighting/tree/master/UnipiDali

Being a python dev myself, I was thinking of tweaking it a bit; I did notice there was an open issue on the upstream python-dali repo related to integrating a unipi-based DALI interface in there: https://github.com/sde1000/python-dali/issues/48

I was wondering how you feel about this. I haven't done any actual coding on it, but I suppose my solution would be based heavily on yours. Specifically note that they have an LGPLv3 license, so that could be an issue.

@martin-kudláček just looking into the DALI support. The way I understand the python-dali library to work, I need some kind of implementation of your unipi DALI connector to actually use it. The link in your post is not public though. Is this software somewhere publicly available? If not, DALI is not really an option for me to consider, actually.

EDIT: some background. After I previously had a project to interface with the neuron I/O via some polling procedure via MQTT, my next idea would actually be to likewise have an MQTT client running on the DALI controller you have (I believe the axon S605), interfacing via python-dali and your python DALI controller implementation.

'nother update: giving it some thought, I quickly wanted to see if I could do the same stuff again in go, so here goes another POC: https://github.com/mhemeryck/unipitt/blob/37b9a07bc570301c2a11836526df1a2be8b21647/main.go

(Don't mind the project name though, I've sort of ran out of original names, I guess)

Anyways, performance seems much better in this case. I figure I'll put my efforts into polishing this project as it seems to be the simplest, fastest, most robust.

I did notice however when toggling one of the DI's, that another DI also got toggled somehow, still need to investigate that further.

Thanks for continuous feedback, this actually adds a lot to me for the overall unipi experience!

FYI: figured to create a small proof-of-concept with python3 + asyncio; see https://github.com/mhemeryck/unipoll/blob/b40c73f682956b08ede27abb85a904d95d9cf1ab/unipoll.py

Note: CPU usage is quite high though, probably because of the wait I handled the scheduling with asyncio.