Eight-channel I/O module for home and industrial automation systems CS-8

Some time ago, one of my readers got in touch and offered to let me test their new product, which had recently gone into production. Well, what can I say? I'm interested in all kinds of hardware, and if it's smart, even more so. As always, I'll take a look, take it apart, run some tests, and share my conclusions.

As usual, a reminder: to keep up with new posts on the blog, I recommend following me on Instagram, where I'll post notifications about every new topic and maybe write about something interesting too — link to my account

Talking to the person who got this whole thing off the ground, I learned that they finished preparing and launching the first batch on February 15, just before the war began, so a lot of work came to a halt right away. Though, what can I say? Everyone in Ukraine saw their work grind to a halt, and their lives change dramatically.

All right, let's get to the review. I received a couple of boxes and a small screwdriver in a separate bag.


A couple of words about the screwdriver first, so it doesn't distract us later. As I understand it, it's included as a gift, but as part of a limited-time promotion.
The body has exactly the same logo as the device packaging.


The body is metal. Unscrew the back and you'll find eight bits: four Phillips and four flathead. That's great, in my opinion, though it would be even better if it also came with hex and Torx bits. Still, credit to the manufacturer: it's a nice and useful tool to have around the house.


The bits are held in place by a magnet inside the screwdriver, and they stay put securely.


The packaging lists the basic specifications and the model name. As I understand it, there are two models, differing in whether the RS485 interface has galvanic isolation. The one I received, without isolation, has an S at the end of its model number.


The package includes the CS-8 module and a manual.


The manual is fairly detailed and easy to follow, but to program the module you'll need to visit the manufacturer's website at the very least, and possibly download the software as well. More on that later.
If you like reading manuals, it's easiest to download it from this link.



The manufacturer estimates the product's service life at around 10 years, and provides a warranty of 36 months, or 3 years.


As before, I'll occasionally include screenshots from the documentation. First, here are the device specifications.
A note on the control interface and model numbers: D3M-8DI1XDI8RO-MB is isolated; D3M-8DI1XDI8RO-MBS is non-isolated.


It's neatly made, with a gray body, little LEDs, and a whole bunch of terminals for connections :)


Let's start with the terminals: there really are a lot of them. The power terminals for the switched loads are grouped at the top, while the control terminals, along with the power supply and RS485 connections, are at the bottom.
There are no labels or diagrams on the sides. It mounts on a DIN rail using a slider without a spring, but I actually find that more convenient in this case.


The terminal blocks themselves are definitely a plus: they're the proper elevator-style type, which I really like.


There are ten LEDs on the front: one for power, one for a control command being received (of any type), and one for each output. There's also a small hole here for accessing the reset button.
There's a switch on the left that connects a terminating resistor to the line. If your device is the last one in the chain, or the only one, you need to turn it on.


The dimensions are standard: three modules wide and slightly shorter than a standard circuit breaker. And here's a photo next to a matchbox to make the size easier to judge :)


The functions of the controls and indicators, along with the overall dimensions.


That's the external inspection done. Now for the more interesting part: what's inside. To do this, we remove the bottom cover, which is held in place only by clips.


The cover came off quite easily, which made me uneasy, so I decided to figure out what was going on.
My investigation showed that one of the four clips wasn't holding. I checked the second module, and everything was fine there: all four clips held securely.
I started looking into it and noticed that the bottom was slightly deformed around the clip that wasn't holding—the right side in the fourth photo.
Trying to bend the plastic back into shape didn't help.

This brings up several “issues” at once.
1. For some reason, I seem to be “lucky”: when I get two identical devices and one of them is defective, the one I end up using while preparing the review is the defective one :)
2. When mounted on a DIN rail, the rear cover has to support the weight of the device as well as the strain from the connected wires. There are a lot of them, and this could cause problems in real-world use.
3. I'm not criticizing or making excuses; I'm simply pointing out the shortcomings I've noticed in my role as a tester. I'll pass this information on to the developers, and they'll decide how to address the weak points. This is normal—it's impossible to catch everything during debugging, and sometimes you stop noticing things.
4. The deformation could have happened for one of two reasons: a manufacturing defect, or the clip wasn't fastened properly during assembly. The device was then put in its box, and the plastic deformed over time. Now that the plastic is deformed, it needs to be bent back the other way to hold properly.
5. Personally, I think they should consider using stronger clips, perhaps even adhesive, or screws, since this joint is under mechanical stress. In fact, even now, you could drive four self-tapping screws into the side of the case near the clips to make the assembly stronger, though less convenient to manufacture.

In fairness, the cover on the second relay is held very securely, and you can't just pull it off the rail. Still, this joint deserves attention.


The electronics module is held inside only by friction, but it fits tightly—I had a hard time prying it out.


It's a “multi-story” design—or, more precisely, a three-story one. Overall, though, it's an interesting assembly, with lots of parts soldered together.


Let's start taking it apart. First, we desolder the top board, which has only LEDs, their resistors, and a button.


To make things a little easier, I desoldered the side board from the bottom board rather than desoldering the middle board from the side board. It was a bit easier that way.


Here's the middle board, with four relays immediately visible.


The side board isn't just an interconnect board; it's quite populated too. It has an Atmega microcontroller, an eight-channel driver, an RS-485 transceiver, and a chip I'm not familiar with, marked C2319Z. I had a few guesses about what the unknown chip did, but I would have needed to trace its pins, and by then I'd already put the boards back together.


The left side of the middle board has additional components related to the communications interface, as well as optocouplers that isolate the control inputs from the microcontroller inputs. This isn't for galvanic isolation, but to improve the noise immunity and reliability of the control inputs. Another point in its favor: an optocoupler is harder to kill and works better.


Eight HF32FV-G relays made by Hongfa handle switching power to the loads. Judging by the visible “24,” I assume the coils are rated for 24 V.


And it's not just “24” that's visible there—the letters “STF” are too, indicating the standard (non-sensitive) type.
What does that mean? The relay isn't latching, so it consumes power continuously while its coil is energized. The power dissipated by the coil depends on the relay type: standard relays dissipate more, sensitive ones less.
According to the datasheet, a standard relay consumes about 0.45 W, while a sensitive one consumes 0.21 W. So eight energized relays will dissipate 3.6 W (I assume a little less in practice) instead of 1.7 W, which is quite significant—and that's without accounting for losses in the contact groups.
We'll check the thermal performance later, though.


There are also some caveats regarding service life. The manual states:
Service life (number of switching cycles for a resistive
load of 10 A, 250 VAC at room temperature) — 100,000 cycles.

I have no complaints here: it's stated honestly and matches the datasheet.


Let's get back to the inspection. There are protective slots around the relay output terminals. The traces are not only wide and present on both sides, but also reinforced with solder. No complaints there. You could say it would be nice to have changeover relays, but I think the real limitation is the number of output terminals—there’s simply nowhere to bring out any more.


The lower board houses the module’s power supply, as well as five optocouplers. The fifth optocoupler handles the input for group load shutdown.


1, 2. The input has a resettable fuse and a thermistor to limit the inrush current into the input capacitor.
3, 4. The input capacitor is 10 µF, 450 V, and that voltage rating is no accident: the module is specified for an input voltage of up to 305 V. On the output there’s a 35 V, 220 µF capacitor and a filter inductor. The capacitors are made by Rybycon, so I have no trouble believing the claimed service life.


There’s also a separate DC-DC converter, most likely to power the device’s “brains.” That’s another plus, since it means less heat inside the module.


The lower board also has protective slots around the relay output terminals, along with ventilation slots like those on the middle board, which help with cooling. You can tell the designers put real care into it. The only thing that spoils the overall impression is the dirt—or, more precisely, a poorly cleaned board. It doesn’t really affect how it works, but it does say something about the board’s manufacturing quality. I’d like to see it not only cleaner, but ideally coated with protective varnish as well.


For the first test, I powered it up and used a simple jumper to activate all eight outputs.
Two minor, but noticeable, drawbacks showed up right away.
1. The LEDs are very bright. When I first powered it up, I noticed that the green LED was practically shining straight into my eyes. That was nothing compared to what happened when I turned on all the outputs. Frosted LEDs would be better, but at the very least I’d like to see their brightness turned way down. There’s no need for them to be this bright.
2. The module whines while operating. With all the relays off, it’s barely audible, but the more outputs you turn on, the louder the whine gets. By the time the last output is on, it’s… no, not loud, but noticeable and annoying. You might not hear it if the module is installed somewhere far away in an electrical panel, but sometimes the panel is right in a living space, and that whine would get on my nerves. Most likely the compensation capacitor in the feedback circuit is the wrong value. I’ll have to experiment with it, but that means taking the module apart again…


And so I wouldn’t forget later, I checked the thermal performance right away by turning on all the outputs and leaving the device running for about an hour. Two interesting things came to light:
1. It ran noticeably cooler than I expected.
2. Further investigation showed that the relays are driven at their normal voltage when switching on, then at half that voltage while operating.

As it turned out, the whine was caused by a software quirk in this control method, and it has been fixed in all subsequent devices.


The device’s wiring is very simple. As I mentioned, it has terminals for:
1. Power input, used only to power the device.
2. Connection to the data bus.
3. Control commands from the buttons: 8 channel inputs and 1 group control input.
4. Relay contact group outputs: 8 normally open contacts.

Note that the power input is not routed to the outputs, so you can switch loads that are completely independent of the device’s supply. Each channel can also handle up to 10 A.



For testing, I connected ordinary microswitches to the control inputs. The device was connected to the computer through an inexpensive RS485-USB converter, and I monitored relay operation using the corresponding LEDs. That was more than enough.


In its default state, the relay simply passes button commands through to the outputs: press button 1 and relay 1 turns on; press it again and it turns off. For more complex logic, you need to configure it. To do that, you’ll need:
1. An RS485-USB adapter, or any other convenient way to connect an RS485 device to a PC—for example, an RS485-WiFi converter.



2. The configurator, available on the website, which converts the functions you specify into code that you then send to the device.


3. A program to send the generated code to the target device—in this case, the relay module.


For the program to work with the module, you need to configure a few basic settings.
1. Port settings. Usually, you only need to change the port number and stop-bit configuration.
2. Also change the first two parameters in the "Settings" menu; leave the third one alone. It is 0 by default, so leave it as is.
3. And third, change the device address. By default, all devices on the network have the address 7, so that's what we use for the initial setup. But if the address has been changed, set it to the one you need, since there may be more than one device on the network and each must have a different address.
4. To check the connection, click the Tools button.
5. In the window that opens, click Execute Command.
6. If everything went well, the device will respond with its model, hardware version, and firmware version.

Yes, I forgot to show this in the screenshots, but HEX is usually selected for the start address and Data format fields.

My firmware version was 1.50, but it had a bug that was fixed in the next version, so yours will most likely be a newer, fixed version with a different number.

A more detailed description of how to use the software is available at this link



For convenience, the settings are divided into three groups.
1. Connection settings. If you have several devices on the network, assign each one a unique address.
Below are the settings for the debounce filter and long-press duration—that is, how long to hold the switch down for the command to be recognized as a long press. Usually, there's no need to change anything. Also, if you select decimal input, you can enter the parameter "as is".


2. Input signal response settings.
Enable/disable contact debounce filtering for the switches. I haven't figured out why you'd disable it.
Latching switch: enable this for regular switches, rather than momentary "buttons".
Long press lets you control multiple outputs. For example, a short press can switch on the first relay, and a long press the second. To do this, the outputs are combined into virtual groups (up to 4 groups). It can be set to work only when switching on, only when switching off, when changing state, or as a group command.
Response to a command from the group input (a separate, ninth input): specify which inputs to switch to which mode. By default, this command deactivates all outputs.


3. Output settings: switch-off delay, automatic shutoff, and so on.
State memory: after a power cycle, the selected outputs return to the same state they were in before power was lost.
Response to state change: essentially, this enables or disables the selected input. In OFF mode, the command is ignored.
State inversion: essentially, this simulates normally closed contacts using normally open ones. In other words, an open output is considered on, and a closed output is considered off.
Closed-state limit: an active output automatically switches off after the specified time. This is handy for automatically disconnecting loads, or as a safety feature for forgetful users, for example.
Switch-off delay: very similar to the previous function, but the timer starts when the switch-off command is issued, rather than when the switch-on command is issued.


At first, all this may look like a jumble, but in reality it's not that complicated. That said, I think it would be much more convenient to have dedicated software for working with the module—ideally, not just for configuring it, but also for real-time monitoring and remote control.
The developer said that software is planned, but the situation in the country has had a major impact on those plans, so we'll have to wait.

There are only a few key parameters you'll need to change, and the configurator generates them. In other words, as you click the checkboxes below, the parameter changes in real time. Those are the parameters you need to update.
1. ID — the device's address on the network. In our case, it's 7; this usually doesn't change.
2. Func — the function code, which determines the control function.
3. Addr — essentially, the command address. Each command group has its own address; some may even have two, meaning the command is split into two subcommands.
4. Count — the number of registers being controlled. Some commands support group control, meaning a single data word contains settings for all outputs. Other commands have a separate value for each output.
5. Data — the actual data to write to the device after selecting the checkboxes you need.


As an example, let's try changing the settings for the latching buttons. The buttons connected to the device can be either momentary buttons or switches. In the latter case, there are two fixed states: on and off, i.e. As with a regular wall switch, the closest equivalent to a “toggle” is a doorbell button: the contacts stay closed as long as you keep your finger on it.


After selecting the inputs we need, the code in the Data field changes from 0000 (for example) to a new value, in this case 00A5.
Enter the same code in the corresponding field in the software, then click an empty area or press Enter to move focus away from the field.


Then click the Read/Write button to save the new setting to the device. That's it: inputs 1, 2, 6, and 8 are now configured to work with a latching button.


Here's another example: changing the automatic output shutoff time. You can set the time in seconds, minutes, or hours, after which the outputs will turn off automatically.


First, we change the control format. The corresponding code is available both in the configurator and in the software.


Since this setting is configured individually for each output, we select the 8-output mode.


Copy the data generated by the configurator into the corresponding fields. From here, it's the same as in the previous example.
That's it. The first four outputs will now turn off automatically after the specified time.


A quick demonstration.

1. The first and second inputs are in toggle mode (the default); the third and fourth are configured for latching switches.


With the first pair, pressing the button turns the output on, and pressing it again turns it off. With the second pair, the output stays on as long as you hold the button down.


2. Long-press function: the first output works as usual, while the second turns on when you press and hold the button. The second output can also be controlled normally using its own button.




3. Group control with a long-press function. For each input, you can configure it to turn outputs off, turn them on, or toggle their state.


Unfortunately, I forgot the exact configuration I had set for this example, but if I remember correctly, it was just as shown in the screenshot above.
There are actually quite a few possible configurations; you can create up to 4 groups in total.


4. Using the group control button. By default, it can turn off not only outputs configured for toggle control, but also outputs controlled by latching switches. The output controlled by the latching switch is turned off as well; to turn it back on, you need to switch it off and then on again.


5. The group control input can also be configured to selectively turn off loads.
I also noticed a bit of confusion here: “turning on the group output” actually turns the outputs off.


The configuration is set to turn off all outputs except the first one.


6. Limiting how long an output stays on: the first output has no limit, the second turns off after 5 seconds, and the third after 8 seconds. Obviously, the time can be longer, but that's hard to demonstrate here.


Note that the time is set in seconds, in 1-second increments; minutes, in 1-minute increments; or hours, in 1-hour increments. For example, you can't set 1.5 hours, which is a bit inconvenient—or perhaps I haven't figured out how. The maximum time is 60 hours.


7. Output shutoff delay: the second output has a 5-second shutoff delay.


With this configuration, you can't turn off the second output immediately; it will turn off after a delay when the shutoff command is received on this input. The input itself can also be configured for either a momentary or latching switch.


While I was experimenting with the different modes, I started thinking: lots of people use illuminated switches at night.
Unfortunately, regular illuminated switches won't work here—or rather, they won't light up.
But I got curious: could the backlight be implemented at all? As it turned out, it can.

The voltage across the button contacts is 24 V, and the short-circuit current is 4.7 mA. But since the device detects not a short circuit itself, but a current increase above a certain threshold, the current-limiting resistor value also depends on that threshold.
I first tried a resistor of around 5.1 kΩ, but the device thought I was connecting a button, so I increased the value to 12 kΩ.
In the end, the LED lights up and the button still works. Obviously, though, it would be better to use an ultra-bright LED; the one shown here is simply a high-brightness type.


During testing, I found a few shortcomings. I wrote about some of them, and discussed others directly with the developer and manufacturer.
After our discussion and some additional tests, the developer revised the device, fixed the issues, and sent replacement units with new firmware.
The first difference is that the firmware version is now 1.6 instead of 1.5.


The second difference is that the configurator now lets you set the initial state of the outputs. For example, a light could be powered on all the time, but switched off with an additional command when needed.
Whether this feature is really necessary is debatable, but in any case, it's better to have it than not.


The input inversion function now works correctly, and is effectively a way to set the initial state: the output is active when the switch is off.
However, it only works with latching switches. If the input is in trigger mode, inversion—and therefore the initial state—doesn't differ from normal mode. Personally, though, I think it would make more sense to support inversion in trigger mode too. In other words, with the output in inverted mode, it would emulate an NC relay contact: closed when power is applied, and opening when the button is pressed. For now, though, you can work around this using the “initial state” function.


At least two other bugs were fixed as well:
1. I noticed that with the timer that automatically switches off an output after a set interval, it took three button presses to switch it back on. Not a disaster, just inconvenient. This has been fixed: the triple press now happens only once after changing the output's operating mode, and subsequent switching works correctly.
2. I wrote about a squeak. It turned out to be a software bug in the relay control, and it's been fixed. The relay now operates completely silently—apart from the sound of the relay itself switching, of course.

A few more things I'd like to see:
1. Reduce the LED brightness and replace them with diffused ones. That would not only make the device more comfortable to use, but also give it a more polished look.
2. Software. I'd really like to have both a standalone program for easier configuration and the option to control the device remotely and monitor its status. For example, you're sitting on the couch in the evening, watching TV with a beer, and wondering whether you turned off the light upstairs. You check your phone, see that you forgot, tap once, and switch it off. I agree, this is already a whole different ball game: the device was originally intended simply to make ordinary switches easier and better to use. But perhaps this could be offered in some kind of PRO version.
3. Add the ability to save the configuration, because it would be hard to remember all the settings when replacing the module.
4. Pay closer attention to the enclosure's design details during final inspection.
5. It might make sense to add a varistor to the device's power supply circuit.
6. For industrial use, it would be good to have a protective coating on the circuit board.
7. While writing this, I forgot what else I wanted to recommend. I'll add it when I remember :)

And now for the verdict.
Personally, I find this device interesting, and it really can help automate simple routine tasks, such as controlling lights, an extractor fan, and so on. It's well made, solid, and clearly thoughtfully designed. My only significant criticism was the enclosure, but the developer is already looking into that. I was also pleased by how promptly and reasonably they responded to my comments and suggestions.

The main thing holding this device back is old-style wiring, since it requires separate lines for each switch and load, which is quite uncommon.
There's also the question of dimming lights—for example, in a bedroom. This device can only switch them on and off. When I renovated my daughter's room, though, I installed LED bulbs that can be controlled with an ordinary switch and have two or three brightness levels. So this problem can be solved too, in principle, although not as conveniently as I'd like.

In short, this is a useful, well-made device, but it requires modern wiring. I recommend it.

I hope the manufacturer doesn't stop here and continues to expand its capabilities. Their first attempt has clearly been a success.

That's all for now. Everything will be fine, Ukraine will prevail!