Wiznet makers

What the Project Does

This project is firmware for controlling multiple roller shutters or blinds from a single Arduino Mega 2560. Each shutter has configurable settings such as UP/DOWN relays, manual button inputs, travel time, tilt support, and the display name used in Home Assistant.

Home Assistant sends OPEN, CLOSE, STOP, position values, and tilt values to the Arduino through MQTT. The Arduino receives these commands, controls the relay assigned to the target shutter, and publishes the current state and position back to MQTT.

From an Industrial IoT perspective, the key value of this project is wired reliability rather than wireless convenience. Roller shutters are systems where motors, relays, long wiring runs, and power fluctuations coexist. If the network is unstable, the actual shutter movement and the state shown in Home Assistant can become inconsistent. W5500-based Ethernet provides a predictable connection in this type of environment.

Image source: AI-generated

Image source: https://github.com/damsma/RollerShutter_Arduino_MQTT_Home_Assistant

Image source: https://github.com/damsma/RollerShutter_Arduino_MQTT_Home_Assistant

Where WIZnet Fits

The WIZnet product used in this project is the W5500 Ethernet Controller. The W5500 connects to the Arduino via SPI and provides MQTT communication through EthernetClient in the Arduino Ethernet library.

The W5500 is an Ethernet controller with a hardware TCP/IP stack, 32 KB internal buffer, and 8 sockets. On an MCU with limited RAM, such as the Arduino Mega 2560, network processing can be offloaded to the external Ethernet controller. This allows the MCU to focus on shutter position calculation, button handling, relay control, and MQTT message processing.

Compared with Wi-Fi-based control, the W5500 requires cabling, but it depends less on wireless interference or access point conditions. In environments such as distribution panels, relay boxes, and building automation panels where metal structures and power noise are present, wired Ethernet can be the more practical choice.

Implementation Notes

NetworkConfig.h — W5500, Static IP, and MQTT Configuration

#define MQTT_BASE_TOPIC "homeassistant/cover"
#define MQTT_DEVICE_NAME "RollerShutter"
#define Standard_w5500 1
#define MAINTAIN_ETHERNET_INTERVAL 120000

#define MYIPADDR 192,168,1,199
#define MYIPMASK 255,255,255,0
#define MYDNS 192,168,1,1
#define MYGW 192,168,1,1

byte mac[] = {0x00, 0x10, 0xF1, 0x6E, 0x01, 0x99};
#define MQTT_SERVER "192.168.1.188"
#define MQTT_PORT 1883

This file centralizes the network and MQTT configuration. Standard_w5500 selects the W5500 configuration, while MYIPADDR, MYGW, and MQTT_SERVER define the fixed network values that allow the Arduino to communicate with Home Assistant or the MQTT broker.

In Industrial IoT environments, a static IP is often easier to maintain than DHCP. However, when multiple devices are connected to the same network, IP conflicts must be avoided.

RollerShutter_Arduino_MQTT_Home_Assistant.ino — Using EthernetClient as the MQTT Transport Layer

#include "NetworkConfig.h"
#include <SPI.h>
#include <Ethernet.h>
#include <PubSubClient.h>

IPAddress ip(MYIPADDR);
EthernetClient ethClient;
PubSubClient client(ethClient);

In this section, the W5500 is used as the Ethernet interface for MQTT communication. EthernetClient creates the W5500-based TCP connection, and PubSubClient performs MQTT publish/subscribe operations on top of it.

In other words, the W5500 does not directly process Home Assistant functions. Its role is to provide a stable wired network path between the Arduino and the MQTT broker.

RollerShutter.h — Home Assistant MQTT Discovery Configuration

root["device_class"] = "shutter";
root["command_topic"] = commandTopic();
root["state_topic"] = stateTopic();
root["availability_topic"] = availabilityTopic();
root["payload_open"] = "OPEN";
root["payload_close"] = "CLOSE";
root["payload_stop"] = "STOP";
root["set_position_topic"] = positionSetTopic();
root["position_topic"] = positionTopic();
root["optimistic"] = false;

This code builds the discovery payload that allows Home Assistant to automatically recognize each shutter as an MQTT cover entity.

Because optimistic is set to false, Home Assistant does not assume the state only because a command was sent. Instead, the UI is updated based on the state_topic and position_topic values actually published by the Arduino. This is a safer approach for devices such as shutters or blinds, where the commanded state and the actual physical position may differ.

client.publish(discoveryTopic().c_str(), buffer, true);
client.publish(availabilityTopic().c_str(), "online", true);
client.publish(stateTopic().c_str(), stateStr, true);
client.publish(positionTopic().c_str(), posBuffer, true);

This structure publishes discovery, availability, state, and position messages through MQTT. By using retained messages, Home Assistant or the MQTT broker can quickly restore the last known configuration and state after a restart.

Practical Tips / Pitfalls

• The W5500 CS pin setting must be checked carefully. The project distinguishes between Standard_w5500, Easyswitch_with_w5500, and Pico_with_w5500 configurations.
• The MQTT broker IP, Arduino static IP, gateway, and subnet must be in the same network range.
• Because the Home Assistant discovery payload can be large, the PubSubClient buffer size should be verified.
• As the number of shutters increases, the number of MQTT topics and retained messages also increases. It is useful to check the retained message state on the broker.
• Relay direction changes require a protection delay. If the opposite relay turns on before the motor has fully stopped, hardware damage may occur.
• Before connecting the actual motor, test MQTT commands, state publishing, and Home Assistant display with the relay output isolated.
• Recovery behavior should be tested by disconnecting the LAN cable, restarting the MQTT broker, and restarting Home Assistant.

FAQ

Q: Why is the W5500 suitable for this project?
A: The W5500 handles TCP/IP processing in hardware, reducing the workload on the Arduino Mega 2560. This allows the MCU to focus on shutter position calculation, button input, relay control, and MQTT message processing instead of the network stack.

Q: How does the W5500 connect to the Arduino Mega 2560?
A: It connects through SPI. MISO, MOSI, SCK, and CS pins are required, and the CS pin must be set correctly depending on the board configuration. This project allows different CS pin configurations depending on the W5500 board type.

Q: What role does the W5500 play in this project?
A: The W5500 provides the wired Ethernet connection between the Arduino and the MQTT broker. Home Assistant commands are delivered to the Arduino through MQTT, and the Arduino reports shutter status back to Home Assistant through the same path.

Q: Can beginners follow this project?
A: This project is more advanced than a basic Arduino example. It requires an understanding of the Arduino Mega pinout, W5500 SPI connection, MQTT broker setup, Home Assistant MQTT integration, and relay driving circuits. Before connecting an actual shutter motor, low-voltage testing and relay operation verification are strongly recommended.

Q: How is this different from using a Wi-Fi-based ESP board?
A: Wi-Fi simplifies wiring, but it can be affected by wireless interference, access point conditions, and signal attenuation. W5500-based Ethernet requires a cable, but the connection is more predictable, making it better suited for building automation or industrial shutter control where reliability is important.