Thanks for the reply. In short:

1. Modbus TCP - MQTT: I'll probably just start off simple, by polling the Modbus server and exposing any changes as MQTT events. That way, I can get some feel with the setup and I can dig deeper later on. It's nice to know I can come back here for some assistance :)
2. the LED strip: tried it the other day, and it just works; I hadn't taken the time before to properly connect them.
3. DALI: looking forward to hearing more about it; had already seen the thread / python-dali before. Just good to see I'm on the right track here :)

Thx for your quick reply! I have some more remarks / questions in follow-up; (perhaps I can start some separate topics on some of these).

1. Polling speed

I can see the value of this direct switch functionality, but I would rather have the connection of input-to-output managed at a higher level (e.g. home assistant). Besides, the number of outputs on the L303 is not enough for that. Will have a look at the toggle function though!

Events instead of polling

I was also wondering whether there could be a simpler way to capture events from the SPI-interface. A lot of IoT solutions nowadays use protocols specifically for this, like MQTT; home assistant has a lot of support for it and e.g. arduino also has libraries for it. For my home automation setup, I would like to expand the number of IO and platforms, so something like MQTT has the added advantage to add more neurons that can run independently, but communicate directly with MQTT.

What would the best way to do this translation; I am thinking of:

• SPI polling: rather than having the modbus TCP server expose it, push the events out directly when they are found
• modbus TCP server polling: one layer higher, create an interface that connects the modbus TCP server with an MQTT broker
• PTY polling: on the same level, the SPI devices are also available through a PTY, so I could also have a similar interface between the PTY and an MQTT broker
• home assistant: write my own unipi-to-home-assistant integration -- but this would effectively do the same kind of polling as the hass modbus solution is doing right now

The fastest would probably be the SPI polling solution, directly connecting the polled SPI interface with an MQTT broker. I don't have that much experience with this low-level coding though, so it seems pretty hard. What are your thoughts on this? (perhaps I should move this to a separate topic)

On a related note, currently, the RPI seems to polling the SPI devices, but is there also a way to have the SPI devices directly trigger (interrupt?) the RPI? This seems even harder though and I am not sure whether there is that much advantage to it in practice.

2. Momentary switches

The toggle function is something I could indeed do perfectly at this level; no need to emulate this at a higher level such as home assistant.

3. Outputs

I already tried to directly connect a 24VDC LED strip and toggle the DO, but this didn't seem to work. I'll probably need some more time to investigate it.

Lighting: DALI controller

For my lighting solution, I would actually like to build a DALI controller (yet another topic). The shop mentions the axon S605 to be suited for this, but I don't seem to be able to find any further documentation for this. Ideally, I would just have the axon run its own linux distro and have a common DALI library on it to interface with the DALI bus. I would then write my own MQTT client as a bridge between the DALI interface and the other unipi. Not sure how realistic this is though.

FYI, some background:

• I'm a software dev, currently mostly involved with python full-stack web development
• I have a background as an electrical engineer, with some experience in embedded software development and signal (image / audio) processing
• I'm currently in the process of building a house, so anything with respect to home automation is still possible atm. While much of the IoT solutions all focus on wireless solutions, I prefer wired solutions where possible.

I recently tried out a setup with my unipi neuron L303 with home assistant, a python-based open-source framework for integrating various IoT and home automation devices and services. Since it did turn out to be actually quite simple, I figured to share it here.

Outline

The general idea is to use the unipi neuron modbus server for accessing all I/O on the neuron. Home assistant can then communicate with its own hass modbus integration

Unipi neuron modbus server

The picture in this post helped a lot: basically, I had a (headless) raspbian stretch image where I installed evok on, which also installs the unipi neuron modbus server. As I understood it, all I/O on the I/O boards are connected over SPI and are continuously polled. The modbus TCP overlay is just a way to expose this information.

Home assistant setup

Installing home-assistant on the unipi is rather straightforward as it's specifically targeted for platforms such as the raspberry pi. The official hass installation docs now prefer you to use their docker-based installation hass.io. While I do like this idea (and will use this myself on the longer term), for testing purposes I decided to just use the old-style python-pip based installation.

Install pip (python package manager) for python3.

apt-get install python3-pip

Home assistant requires some specific python3-based features (e.g. async handling of events with asyncio) ... and you should use python3 anyway.

Install home assistant

pip3 install --user homeassistant

The --user option installs it in a folder of your own user.

Start running it:

hass

You can now access it under $NEURON_IP:8123 (default hass port)

When adding an integration (such as modbus), home assistant will automatically install the required dependencies for it (such as pymodbus).

Home assistant configuration

Now, how to glue these two together. Home assistant uses simple .yaml files for configuration. The main config file is configuration.yaml; see hass configuration.yaml for more details. My config file was under $HOME/.homeassistant/configuration.yaml

I did add the following lines to this file specifically for modbus (comments added)

# register the modbus-tcp platform
modbus:
  type: tcp
  host: 127.0.0.1  # localhost; just check on this machine
  port: 502  # default port number from modbus tcp neuron overlay

switch:
  platform: modbus
  slave: 1  # field is required -- but not checked for modbus TCP
  scan_interval: 0.1 # polling speed
  coils:
    - name: User programmable LED X1
      coil: 8  # modbus register mapping
      slave: 1
    - name: User programmable LED X2
      coil: 9
      slave: 1
    - name: User programmable LED X3
      coil: 10
      slave: 1
    - name: User programmable LED X4
      coil: 11
      slave: 1

# reading a digital input
binary_sensor:
  - platform: modbus
    scan_interval: 0.001
    coils:
      - name: Digital Input 21
        coil: 100

This is only just a test setup where I can control the 4 test leds on the neuron and read out one of the digital inputs.

I was actually amazed myself how simple the setup was to integrate both platforms -- so great work on the hardware and the modbus TCP server overlay.

Next

This was just a test setup for me, some more things I'd like to check:

• polling speed: the inputs respond rather slow atm, so I'd like to check how to increase the speed there. I'm curious where the bottleneck is; on the SPI polling or on home assistant polling the modbus server itself. On SPI level, I am curious whether it is possible to have more of a interrupt-based system.
• inputs as actual push buttons: the inputs should really toggle, rather than follow the input value. I know it's possible to manage this simply in home assistant, couldn't find it directly
• outputs: haven't checked driving the outputs yet. Is it actually possible to directly drive e.g. a 24V LED strip from the digital outputs (not relays -- the L303 only has limited outputs)

Home assistant is only an example and actually not even that relevant to my question here -- ideally I'd write my own integration into home assistant.

I am more interested really in how to program against the low-level IO with a general purpose programming language. I already read a bit about EVOK and the modbus server, so I'll probably just need to read a bit more about that.

My main question really was to have a simple "hello world"-like example in a general purpose programming language on a neuron. I was thinking about something like a python-script that reads inputs (e.g. a push button) and than drives an output (e.g. light switch) based on that input, pretty much that same way that you can do an a regular raspberry pi with the rpi.gpio library.

wrt Mervis: I had the idea the focus there was that it uses a custom graphical programming interface. My main motivation for a setup with a unipi / neuron would be to not have to deal with graphical programming tools, to be honest :slight_smile:

Specifically about the DirectSwitch: is this documented somewhere? What is it really? I have the impression that you sort of link an output state directly to a state change of an input. I would rather have the option to specify my own logic (callback, trigger, whatever you'd like to call it) based on an input change.

As a general question: what would be the best starting point (documentation) for developing a custom application? I do like the idea of EVOK as a web-like API to develop against. I am a bit skeptical however about the reaction time with all these different levels of abstraction ...

I am currently trying to figure out the specs / setup for a DIY home automation project for a new building. Needless to say I'd figure the unipi / neuron HW would fit in nicely.

For the software part, I'm thinking of using something like home assistant . I've already been tinkering a bit with a regular raspberry pi, but for a home project I'd like to use the neuron as it already seems to be able to do all the IO transformation I would need.

From reading the docs / this forum, I can see however that it's probably not the input to address the IO itself directly; if I understand correctly, the idea is to use EVOK as a web-like API instead.

Do you have some example code for a small setup with EVOK? I am thinking of something like:

• reading a digital input switch (e.g. reading a 24V push button)
• writing a digital output switch (e.g. writing a 24V output to trigger a bistable relay to drives a lamp)

For the reading part: would you typically do some kind of polling? Or is there some sort of interrupt / callback-like system available?

Thanks in advance!