This tutorial explains how to implement an automatic water reserve control system using a CONTROLLINO PLC and OpenPLC. The system monitors the water levels of a cistern (minimum level) and an elevated tank (minimum and maximum levels) to control a pump that transfers water from the cistern to the elevated tank. Additionally, manual pump control is possible using start and stop buttons.

Prerequisites

Before starting, ensure you have the following:

• OpenPLC software installed.
• A CONTROLLINO PLC (any model) or a compatible PLC.
• Sensors for water level detection:
• Minimum level sensor for the cistern.
• Minimum and maximum level sensors for the elevated tank.
• Two buttons for manual control (Start and Stop).
• Basic knowledge of ladder logic programming.

Step-by-Step Guide

Step 1: Install and Set Up OpenPLC

1. Download OpenPLC:

• Visit the OpenPLC official website and download the software.
• Follow the installation instructions for your operating system.

1. Set Up the OpenPLC Environment:

• Open the OpenPLC editor.
• Configure the device by selecting your CONTROLLINO model in Settings > Device.
• Assign the correct COM port for communication with the PLC.

Step 2: Configure System Inputs and Outputs

Define the following inputs and outputs in your ladder logic program:

Step 3: Program the Ladder Logic

1. Automatic Mode:

• The pump (Water_Pump) is activated automatically when:
  • The cistern is above its minimum level (Pool_Low_Level_Sensor is active).
  • The tank is below its minimum level (Tank_Low_Level_Sensor is active).
• The pump is deactivated when:
  • The tank reaches its maximum level (Tank_High_Level_Sensor is active).
  • The cistern falls below its minimum level (Pool_Low_Level_Sensor is inactive).

1. Manual Mode:

• The pump can be directly controlled using the buttons:
  • The Start Button (Start_Button) activates the pump.
  • The Stop Button (Stop_Button) deactivates the pump.
• The switch (Automatic_Manual_Switch) must be in manual mode to enable this functionality.

1. Switching Between Modes:

• The Automatic_Manual_Switch toggles between automatic and manual modes.
• In manual mode, sensor readings do not affect the pump operation.

Step 4: Connect the Hardware

1. Wiring:

• Connect the level sensors to the respective input pins.
• Connect the Start and Stop buttons to other input pins.
• Connect the water pump to the assigned output pin.

1. Pin Mapping:

• Ensure that the variable names in OpenPLC match the physical connections.

Step 5: Test the System

1. Load the Program:

• Save your project in the OpenPLC editor.
• Connect your CONTROLLINO PLC to the computer and upload the program.

1. Test Automatic Mode:

• Ensure the cistern is above its minimum level.
• Lower the water level in the tank below its minimum.
• Observe how the pump automatically activates and fills the tank until it reaches the maximum level.

1. Test Manual Mode:

• Switch to manual mode using the Automatic_Manual_Switch.
• Press the Start Button to activate the pump and the Stop Button to deactivate it.

Ladder Logic Explanation

Automatic Mode

1. Automatic Activation:

• When both Pool_Low_Level_Sensor and Tank_Low_Level_Sensor are active, the pump (Water_Pump) turns on.

1. Automatic Deactivation:

• The pump turns off when either:
  • Tank_High_Level_Sensor is active (tank full).
  • Pool_Low_Level_Sensor is inactive (cistern empty).

Manual Mode

1. Manual Control:

• Pressing Start_Button turns on the pump manually.
• Pressing Stop_Button turns off the pump manually.

Troubleshooting

1. Check Wiring:

• Ensure sensors and buttons are connected to the correct input pins.
• Verify the pump is connected to the correct output pin.

1. Verify Variables:

• Check that the variable names in OpenPLC match the physical connections.

1. Debugging:

• Use the OpenPLC debugging tools to monitor the state of inputs, outputs, and signals.

Conclusion

Congratulations! You have successfully implemented a water reserve control system with both automatic and manual modes. This system is ideal for efficiently managing water levels in elevated tanks and cisterns. You can further customize the system by adding additional sensors or modifying the logic to suit specific requirements.

This tutorial demonstrates how to create an automatic staircase lighting system using OpenPLC and a CONTROLLINO PLC. The system uses two push buttons for manual control and a PIR sensor for automatic activation. The light toggles manually with button presses or turns on automatically when motion is detected, staying on for 20 seconds before turning off if no further motion occurs.

Prerequisites

Before you begin, ensure you have the following:

• OpenPLC software installed.
• A CONTROLLINO PLC (any model) or compatible PLC.
• A Passive Infrared (PIR) motion sensor.
• Two push buttons (for manual control).
• Basic knowledge of ladder logic programming.

Step-by-Step Guide

Step 1: Install and Configure OpenPLC

1. Download OpenPLC:

• Visit the OpenPLC website and download the software.
• Follow the installation instructions for your operating system.

1. Set Up the OpenPLC Environment:

• Open the OpenPLC Editor.
• Configure the environment for your CONTROLLINO PLC by selecting the correct model in Settings > Device.
• Assign the appropriate COM port for communication.

Step 2: Define System Inputs and Outputs

Configure the following inputs and outputs in your ladder logic program:

Timers:

• TOF0 (Off Delay Timer): Controls the light timeout after motion detection.
• Duration: T#20s.

Step 3: Create the Ladder Logic Program

1. Manual Light Control:

• When either control_button_down or control_button_up is pressed, the lights_buttons_state toggles the stairs_light.
• This allows manual on/off control of the staircase light.

1. Automatic Light Control:

• When the stairs_pir_sensor detects motion, it activates the timer TOF0.
• The light (stairs_light) remains on while the timer is active or as long as motion is detected.

1. Light Timeout:

• When no motion is detected for 20 seconds, the TOF0 timer deactivates.
• The light turns off automatically unless toggled manually.

Step 4: Connect the Hardware

1. Wiring:

• Connect the PIR sensor output to a digital input pin (e.g., DI0).
• Connect the downstairs push button to another input pin (e.g., DI1).
• Connect the upstairs push button to a separate input pin (e.g., DI2).
• Connect the staircase light to a digital output pin (e.g., DO0).

1. Pin Mapping:

• Assign the corresponding input and output variables in OpenPLC:
  • stairs_pir_sensor → %IX0.0
  • control_button_down → %IX0.1
  • control_button_up → %IX0.2
  • stairs_light → %QX0.0

Step 5: Load and Test the Program

1. Upload the Program:

• Save your ladder logic project in the OpenPLC Editor.
• Connect your CONTROLLINO PLC to your computer and upload the program.

1. Test Manual Light Control:

• Press the upstairs (control_button_up) or downstairs (control_button_down) push button.
• Confirm that the light toggles on and off with each press.

1. Test Automatic Light Control:

• Walk near the PIR sensor to simulate motion detection.
• Observe the light turning on and staying active for 20 seconds after the motion stops.
• Ensure the light turns off automatically after the timer expires.

Ladder Logic Explanation (Detailed)

Manual Light Control

1. Toggling the Light:

• Each button press (control_button_up or control_button_down) changes the state of lights_buttons_state.
• The state of lights_buttons_state determines whether stairs_light is turned on or off.

Automatic Light Control

1. PIR Sensor Activation:

• When the stairs_pir_sensor detects motion, the timer TOF0 starts.
• The stairs_light remains on while motion is detected or while the timer is active.

1. Light Timeout:

• The TOF0 timer turns off the light 20 seconds after the PIR sensor stops detecting motion.

Combining Manual and Automatic Control

• The light can be manually toggled on or off at any time using the push buttons.
• Automatic activation by the PIR sensor operates independently, ensuring flexibility.

Troubleshooting

1. Verify Wiring:

• Ensure all sensors and buttons are correctly connected to the appropriate input pins.
• Confirm the light is connected to the correct output pin.

1. Check Variable Assignments:

• Double-check that the input and output variables in OpenPLC match your physical connections.

1. Debugging:

• Use the OpenPLC debugging tools to monitor the state of variables and timers.

Conclusion

Congratulations! You have successfully implemented an automatic staircase lighting system using OpenPLC and a CONTROLLINO PLC. This system combines manual and automatic control for optimal flexibility and convenience. Experiment with different timer durations or additional sensors to customize the system further.

This tutorial explains how to create a PWM-based light intensity control system using OpenPLC software and a CONTROLLINO Micro PLC. The system adjusts the brightness of a light through a single push button, using a digital output. Each button press decreases the brightness until it cycles back to full intensity. This project showcases ladder logic programming to control light intensity using PWM.

Prerequisites

Before you begin, ensure you have the following:

• OpenPLC software installed.
• A CONTROLLINO Micro PLC.
• Basic knowledge of ladder logic and PWM.
• Hardware setup ready, including a connected push button and light output.

Step-by-Step Guide

Step 1: Install and Configure OpenPLC

1. Download OpenPLC from the official OpenPLC website.
2. Install the software on your computer.
3. Open the OpenPLC Editor and configure the environment for your CONTROLLINO Micro PLC:

• Navigate to Settings > Device and select “CONTROLLINO Micro” from the list.
• Ensure the correct COM port is selected.

Step 2: Create the Ladder Logic Program

1. Define Variables:
   Open the OpenPLC editor and define the variables listed below: Name Type Description Control_button BOOL Push button input to control brightness cycling. Light_output BOOL PWM output controlling the light intensity. Light_bright INT Tracks the current brightness level. Pulse_regulator TIME Timing variable for PWM modulation. Light_on_state BOOL Indicates whether the light is currently on. Reset_state BOOL Resets the brightness level to maximum. Flag_cicle BOOL Controls PWM signal cycling. Full_bright BOOL Indicates the full brightness state.

1. Draw the Ladder Diagram:

• Implement the logic as described in the Ladder Logic Explanation section below.
• Use counters (CTU), timers (TP and TOF), and comparators (EQ, GT) to create the control logic.

Step 3: Understanding the Ladder Logic

Button Press and Brightness Cycling

1. Counter (CTU0):

• Each button press increments the counter.
• The counter cycles through brightness levels (0, 1, 2, 3) and resets to 0 after reaching the maximum level.

1. Brightness Level Comparison:

• Use comparators to determine the brightness level (Light_bright) and adjust the PWM pulse width accordingly.

1. PWM Signal Generation:

• Use timers to control the on/off duration of the PWM signal based on the current brightness level.

1. Light Output Control:

• The variable Pulse_regulator adjusts the Light_output signal to modulate light intensity.

Step 4: Connect the Hardware

1. Wiring:

• Connect the push button to a digital input pin (e.g., CONTROLLINO_D0).
• Connect the light output to a PWM-capable pin (e.g., CONTROLLINO_Q0).

1. Pin Mapping:

• Assign the Control_button variable to the input pin connected to the push button.
• Assign the Light_output variable to the output pin connected to the light.

Step 5: Load and Run the Program

1. Upload the Program:

• Save your ladder logic project.
• Use the OpenPLC Editor to upload the program to your CONTROLLINO Micro.

1. Test the System:

• Power on the CONTROLLINO Micro.
• Press the push button and observe the light cycling through brightness levels.

Ladder Logic Explanation (Detailed)

Counter (CTU0):

• Tracks the number of button presses and increments the Light_bright variable.
• Resets to 0 after reaching the maximum brightness level.

Reset and Cycling:

• When the brightness reaches the lowest level, the Reset_state variable resets the system to the maximum brightness level.

Brightness Control:

• Use comparators (EQ, GT) to map the brightness level to a PWM duty cycle.
• Timers (TP0, TOF0) generate the PWM signal by controlling the on/off duration of Light_output.

Troubleshooting

1. Verify the wiring between the push button, light, and CONTROLLINO.
2. Ensure that the correct input and output pins are assigned to the variables.
3. Check for errors in the ladder logic program using the OpenPLC debugger.

Conclusion

You have successfully implemented a PWM-based light intensity control system using a CONTROLLINO Micro and OpenPLC. By integrating ladder logic and PWM, this project demonstrates an efficient way to control light brightness with a single push button. Experiment with the timing variables and additional functionality to customize the system further.

This is an example guide to setting up Modbus TCP communication between a client and server using CONTROLLINO and an Ethernet shield. This tutorial will help you configure the client to read and write inputs and outputs and the server to synchronize its state with the client.

Prerequisites

• Installed Arduino IDE.
• CONTROLLINO PLC board (e.g., MAXI(also Automation), or MEGA).
• Basic understanding of Modbus TCP and Ethernet setup.

Modbus TCP connection example

Point to point connection

Connection using switch

Example Code

You can download the example Modbus TCP Client and Server code from the following GitHub repository:

• Modbus TCP Client code

• Modbus TCP Server code

• Detailed example explanation

Step-by-Step Guide

Modbus TCP Client

The Modbus TCP client communicates with the server to toggle coils and read and write registers.

Step 1: Setup the Arduino Environment

• Connect your CONTROLLINO board to your computer.
• Open the Arduino IDE.
• Ensure that the CONTROLLINO is selected in the Tools menu.
• Include the necessary libraries for communication:
  • ArduinoRS485
  • ArduinoModbus
  • Controllino
  • SPI
  • Ethernet

Step 2: Initialize the Ethernet and Modbus TCP Client

In the setup() function:

1. Start the Ethernet connection by calling Ethernet.begin(mac, ip) using the MAC address of your Ethernet shield.
2. Check the Ethernet hardware and cable connection.
3. If the connection is successful, initialize the Modbus TCP client by using modbusTCPClient.begin(server, 502).

Step 3: Configure Digital and Analog Pins

In the loop() function:

1. Digital Inputs and Coils:
   • Declare an array slaveInputs[] to store the state of the slave’s digital inputs.
   • Read these inputs using modbusTCPClient.discreteInputRead().
   • Synchronize the state of the slave inputs to the master outputs using digitalWrite().
   • Write the current state of the master digital input to the slave using modbusTCPClient.coilWrite().
2. Analog Inputs and Holding Registers:
   • Declare an array slaveInRegisters[] to store the state of the slave’s holding registers.
   • Read the analog inputs using modbusTCPClient.inputRegisterRead().
   • Synchronize the master’s analog outputs using analogWrite() and update the slave’s holding registers using modbusTCPClient.holdingRegisterWrite().

Modbus TCP Server

The Modbus TCP server simulates a coil and synchronizes the state of its inputs and outputs with the client.

Step 1: Setup the Arduino Environment

• Connect your CONTROLLINO board to your computer.
• Open the Arduino IDE.
• Ensure that the CONTROLLINO is selected in the Tools menu.
• Include the same libraries as in the client setup:
  • ArduinoRS485
  • ArduinoModbus
  • Controllino
  • SPI
  • Ethernet

Step 2: Initialize the Ethernet and Modbus TCP Server

In the setup() function:

1. Start the Ethernet connection using Ethernet.begin(mac, ip).
2. Start the Modbus TCP server by calling modbusTCPServer.begin().
3. Configure the Modbus coils, discrete inputs, holding registers, and input registers using:
   • modbusTCPServer.configureCoils()
   • modbusTCPServer.configureDiscreteInputs()
   • modbusTCPServer.configureHoldingRegisters()
   • modbusTCPServer.configureInputRegisters()

Step 3: Configure Digital and Analog Pins

1. Set up digital input and output pins.
   • Use pinMode() to define the pins as either INPUT or OUTPUT.
   • Initialize output pins to a LOW state.
2. Set up analog output pins for holding registers using analogWrite().

Step 4: Synchronizing Coils and Registers

In the loop() function:

1. Client Connection:
   • Wait for incoming client connections using ethernetServer.available().
   • Accept the client connection with modbusTCPServer.accept(client).
2. Synchronize Coils and Registers:
   • In the executeSynchronization() function:
     • Read the state of the server’s coils using modbusTCPServer.coilRead(), and update the corresponding output pins using digitalWrite().
     • Read the state of the input pins using digitalRead() and update the corresponding coil register with modbusTCPServer.coilWrite().
     • For analog outputs, write the value from the holding register to the PWM outputs using analogWrite().
     • Read the analog input pins and update the corresponding input registers using modbusTCPServer.inputRegisterWrite().

Conclusion

You have now successfully configured Modbus TCP communication between a CONTROLLINO client and server using an Ethernet shield. The client reads and writes digital and analog inputs/outputs, while the server synchronizes its state accordingly. Experiment with different pin configurations and data handling to expand your project!

This tutorial will guide you through setting up Modbus RTU communication between a master and a slave device using two CONTROLLINO devices. The master device reads digital and analog inputs from the slave and sends data to control its outputs, while the slave responds with data controlling its own outputs based on commands received from the master.

Note

The Controllino BSP, for MAXI and MEGA, inside pins_arduino.h contains the following definitions:

// ArduinoRS485 library support
#define RS485_SERIAL_PORT           Serial3
#define RS485_DEFAULT_TX_PIN        14
#define CUSTOM_RS485_DEFAULT_DE_PIN 75
#define CUSTOM_RS485_DEFAULT_RE_PIN 76

These allows the use of the default instance of RS485 library:

RS485Class RS485(RS485_SERIAL_PORT, RS485_DEFAULT_TX_PIN, RS485_DEFAULT_DE_PIN, RS485_DEFAULT_RE_PIN);

Which is also the default RS485 interface for ModbusRTUServer and ModbusRTUClient the default instances for RTU in ArduinoModbus library.

This allows an easy integration of the libraries and the Controllino BSP so there is not need to create an instance of RS485 and later an instance of ModbusRTUServer or ModbusRTUClient, but just use the default instances like in the library examples.

Prerequisites

• Installed Arduino IDE.
• CONTROLLINO Mega or Maxi PLC board for both master and slave devices.
• Basic understanding of Modbus RTU communication and pin setup.
• Connect two Controllino boards using de RS485 pins as show the pictures above.

RS485 connection for Controllino Maxi

RS485 connection for Controllino Mega

Example Code

You can download the example Modbus RTU master and slave code from the following GitHub repository:

• Modbus RTU Master code

• Modbus RTU Slave code

• Detailed example explanation

Step-by-Step Guide

Step 1: Setup the Arduino Environment

1. Connect your CONTROLLINO boards (both master and slave) to your computer.
2. Open the Arduino IDE.
3. Ensure the appropriate CONTROLLINO Mega board and port are selected in the Tools menu.
4. Include the necessary libraries:
   • ArduinoRS485 library for Modbus RTU communication.
   • ArduinoModbus library for handling Modbus RTU protocol.
   • Controllino library to handle CONTROLLINO-specific pins.

Step 2: Initialize Modbus RTU Communication and Serial Debugging

1. In the setup() function of both master and slave:
   • Initialize Modbus RTU communication by calling ModbusRTUClient.begin(9600) for the master and ModbusRTUServer.begin(1, 9600) for the slave. This sets up the master to communicate at a 9600 baud rate, and the slave is assigned ID 1.
   • Initialize serial communication for debugging purposes using Serial.begin(9600).
2. On the master side, you will configure the Modbus client, while the slave initializes the Modbus server.

Step 3: Configure Digital and Analog Pins

1. Master Configuration:
   • Digital Inputs and Outputs:
     • Configure digital pins CONTROLLINO_A0 to CONTROLLINO_A10 as inputs.
     • Configure relay pins CONTROLLINO_R0 to CONTROLLINO_R10 as outputs.
   • Analog Inputs and Outputs:
     • Configure analog input pins CONTROLLINO_A11 to CONTROLLINO_A15 as inputs.
     • Configure PWM output pins CONTROLLINO_D0 to CONTROLLINO_D4 as outputs.
2. Slave Configuration:
   • Digital Inputs and Outputs:
     • The same digital input-output configuration will be applied to the slave.
   • Analog Inputs and Outputs:
     • Similarly, configure analog input pins and PWM output pins as on the master.

Step 4: Sending and Receiving Data Between Master and Slave

Master Code

In the loop() function:

1. Start by reading the digital inputs (CONTROLLINO_A0 to CONTROLLINO_A10) on the master.
2. Write the input states to the slave’s coils using ModbusRTUClient.coilWrite(). This will send the master’s inputs to the corresponding digital outputs (CONTROLLINO_R0 to CONTROLLINO_R10) on the slave.
3. Read the analog input values on the master, and split the 10-bit values into Modbus registers. Write these to the slave’s holding registers.
4. After sending data to the slave, read the slave’s discrete inputs and input registers to update the master’s digital and analog outputs.

Slave Code

In the loop() function of the slave:

1. Use ModbusRTUServer.poll() to check for incoming Modbus requests from the master.
2. For digital outputs, read the coil values sent by the master and update the digital output pins accordingly.
3. For analog outputs, read the values from the holding registers and use them to set the PWM outputs.

Step 5: Synchronizing Digital and Analog Outputs

1. The master’s digital outputs (CONTROLLINO_R0 to CONTROLLINO_R10) are updated based on the data received from the slave’s discrete inputs.
2. The master’s analog outputs (CONTROLLINO_D0 to CONTROLLINO_D4) are updated based on the slave’s input registers.
3. On the slave, the digital outputs and PWM outputs are controlled by the master’s Modbus write commands, allowing for synchronized control across the devices.

Step 6: Debugging and Monitoring Communication

1. Add serial print statements to monitor Modbus communication between the master and slave.
2. Ensure the Modbus client is correctly reading and writing data from and to the slave device.
3. Use LEDs or external devices connected to the outputs to visualize changes in state as you control the system through Modbus communication.

Troubleshooting

• Modbus Communication Issues: Verify the slave ID and Modbus address in both the master and slave codes.
• Serial Debugging: Ensure the Serial Monitor is open at the correct baud rate (9600 baud).
• Wiring: Double-check the RS485 connections between the master and slave devices. Ensure that the A+ and B-terminals are properly connected.
• Pin Setup: Verify that the correct pins are configured as inputs and outputs on both the master and slave.

Conclusion

You have now successfully established Modbus RTU communication between a CONTROLLINO master and slave. The master reads digital and analog inputs, sends this data to the slave, and controls the slave’s outputs accordingly. Experiment with this setup to synchronize multiple devices or expand your project with additional sensors and actuators!

Also this tutorial can be a base example on how to extend the I/Os of a CONTROLLINO with another CONTROLLINO, using Modbus RTU and RS485.

This tutorial will guide you through setting up I2C communication between a master and a slave device using a CONTROLLINO PLC. The master device reads analog and digital inputs and sends this data to the slave, while the slave responds with data that controls the outputs on the master.

Prerequisites

• Installed Arduino IDE.
• CONTROLLINO PLC board (e.g., MINI, MAXI, or MEGA).
• Basic understanding of I2C communication and pin setup.

I2C Connection example

This example of connection is based on the Controllino Mega but I2C connections for Maxi and Mini uses the same pins of the same X1 connector.

Example Code

Please grab the following example .ino file from Github:

Step-by-Step Guide

Step 1: Setup the Arduino Environment

1. Connect your CONTROLLINO board to your computer.
2. Open the Arduino IDE.
3. Ensure that the appropriate CONTROLLINO board and port are selected in the Tools menu.
4. Include the Wire and Controllino libraries in your project.

Step 2: Initialize I2C Communication and Serial Debugging

1. In the setup() function, initialize the I2C communication by calling Wire.begin(). This sets up the CONTROLLINO device as a master.
2. Initialize serial communication for debugging purposes using Serial.begin(9600).

Step 3: Configure Digital and Analog Pins

1. Set up the digital pins:
   • The first 5 digital pins (CONTROLLINO_D0 to CONTROLLINO_D4) are configured as inputs.
   • The corresponding relay pins (CONTROLLINO_R0 to CONTROLLINO_R4) are set as outputs.
2. Set up the analog pins:
   • The next 2 analog input pins (CONTROLLINO_A0 and CONTROLLINO_A1) are configured as inputs.
   • The same pins will also serve as PWM outputs, configured as outputs.

Step 4: Sending Analog and Digital Inputs to the Slave

1. In the loop() function, start communication with the slave by calling Wire.beginTransmission(slaveAddress).
2. Read the values from the analog input pins and split each 10-bit value into two bytes. Send these bytes to the slave using Wire.write().
3. Read the states of the digital input pins, and store them in a single byte using bitwise operations. Send this byte to the slave.

Step 5: Receiving Data from the Slave

1. After ending the transmission with Wire.endTransmission(), request data from the slave by calling Wire.requestFrom(slaveAddress, 5).
2. Once data is available, read the byte that contains the digital output states and update the output pins accordingly.
3. For analog data, combine the two bytes received into a single integer, and use this value to set the PWM outputs on the master.

Step 6: Control Digital Outputs Based on Slave Data

1. Use the byte received from the slave to set the states of the digital output pins (CONTROLLINO_R0 to CONTROLLINO_R4).
2. Each bit in the byte represents the state of one output pin, and the digitalWrite() function is used to control these pins.

Certainly! Here’s an expanded explanation with more details on how the slave code works and its interaction with the master:

Step 7: Set Up the Slave Address and Digital/Analog Pins

In the slave code, the device is initialized with a specific I2C address using Wire.begin(8). This address must match the address used in the master code for communication to work.

The digital and analog pins on the slave are then configured:

• The first 5 digital pins are set as inputs and outputs, similar to the master.
• The next 2 pins are designated as PWM outputs (for receiving analog data from the master) and as analog inputs (for sending data back to the master).

This ensures that both the master and slave are working with the same configuration, which is essential for seamless data exchange.

Step 8: Handling Data Received from the Master

The receiveEvent() function in the slave code is triggered whenever the master sends data to the slave. This function:

1. Reads the analog values sent by the master, reconstructing each value from two bytes.
2. Writes the reconstructed analog values to the designated PWM output pins on the slave, enabling the master to control the analog output on the slave remotely.
3. Reads the byte representing the digital output states, where each bit corresponds to the state of one digital output pin.

The slave then uses digitalWrite() to set its digital output pins based on the master’s instructions, allowing the master to control these outputs directly.

Step 9: Responding to the Master’s Data Request

When the master requests data from the slave, the requestEvent() function on the slave is executed:

1. The analog inputs are read, its value is splited into two bytes for transmission.
2. The combined digital input states are read and stored in a single byte, with each bit representing one digital input.

The slave then sends these values back to the master via Wire.write(), allowing the master to read the current state of the slave’s inputs and use this data in its control logic.

Step 10: Synchronizing Data Between Master and Slave

The master and slave continuously communicate over I2C to maintain synchronization:

1. The master sends analog values to control the PWM outputs on the slave.
2. The master also sends digital states to control specific digital outputs on the slave.
3. The slave responds with its own digital and analog input states, enabling the master to monitor and react to the slave’s environment.

This bidirectional data flow ensures the master can dynamically control and respond to the conditions on the slave, creating a cohesive system where both devices operate in harmony.

Troubleshooting

• Ensure the I2C address of the slave matches the value set in slaveAddress.
• Check the wiring between the master and slave, ensuring the I2C SDA and SCL lines are connected properly.
• Verify the CONTROLLINO board and port are correctly selected in the Arduino IDE.

Conclusion

You have now successfully established I2C communication between a CONTROLLINO master and slave. By reading analog and digital inputs on the master and controlling its outputs based on data received from the slave, this setup enables synchronized control between two devices. Experiment with different pin configurations and data handling to expand your project!

Platform.io together with VS Code is the current de-facto standard for advanced programmers to develop on Arduino boards. CONTROLLINO is natively compatible with Platform.io

How to use CONTROLLINO with Platform.io

Please refer to the official tutorials from Platform.io on how to connect your board:

• Controllino MINI
• Controllino MAXI
• Controllino MAXI Automation
• Controllino MEGA

Information: In this tutorial we are using the HMI from Beijer.

Controllino HMIs are industrial HMI panels with high-resolution touch-screens and modern design. The panels combine IP65 corrosion resistant plastic housing with the full version of the iX software, providing an advanced HMI solution for every kind of applications.
Combine HMI with Controllino and you can create simple as well as the sophisticated applications in very short time.

IMPORTANT: Please, select proper target board in Tools->Board->Controllino MINI/MAXI/MEGA before Upload to your CONTROLLINO.
(Please, refer to https://github.com/CONTROLLINO-PLC/CONTROLLINO_Library if you do not see the CONTROLLINOs in the Arduino IDE menu Tools->Board.)

MODBUS TCP/IP

Hardware Required

• Controllino MAXI/MEGA
• 24V DC Power supply
• Controllino HMI
• 2x Ethernet cable
• Router

Circuit

Note*
Pin header is working on 5V TTL levels. Voltage levels over 5.5V can damage the Controllino permanently.

HMI setup

To set up the Controllino HMI for communication and application we use the iX Software. iX Software is a revolutionary software that features drivers to communicate with your automation equipment, enhanced HMI functionality, state-of-the-art graphics, an intuitive design environment and a truly open platform for today’s automation market. iX Developer is a licensed application that runs on a Windows PC and is used to program iX operator panels.
Here we are going to show some steps on how to set it up properly. If you want to check more information and  the iX user manual click here.

Download the Controllino HMI – TCP/IP example and run it in the iX software.
From the left side of the main screen in the iX example there is the Tags button. Open the Tags to set your application addresses. You can see example of this on the next picture:

For more information about Tags and addressing of them navigate to Controllers/Settings and click on the help button of the Modbus Master controller.

After that go to the Controllers tab to choose the right controller for communication. When we are using the Controllino device we want to choose MODICON -> Modbus Master controller. In this example it is already done and they are named Modbus_TCP and Modbus_RTU.

Press on the Modbus_TCP controller, activate it and click on the Settings button to do the folowing:

Set communication mode to the Ethernet TCP/IP and the IP address of the station to your Controllino IP address. To get your Controllino IP address and to ensure that the connections work, run the ArduinoIDE->File->Examples->Ethernet->DhcpAddressPrinter example, upload it and open Serial Monitor. If everything works, you should get your IP address on the screen.

Code

Before uploading the program to the Controllino you have to install the Modbus TCP library. You can download it here. To install it copy the Modbus folder to your Arduino->libraries folder.
After getting the IP address of the Controllino the new program has to be uploaded to the device.

#include <Controllino.h>
#include <SPI.h>
#include <Ethernet.h>

#include "Mudbus.h"

Mudbus Mb;

int D0 = CONTROLLINO_D0;
int D1 = CONTROLLINO_D1;
int R0 = CONTROLLINO_R0;
int A0_ = CONTROLLINO_A0;


//Function codes 1(read coils), 3(read registers), 5(write coil), 6(write register)
//signed int Mb.R[0 to 125] and bool Mb.C[0 to 128] MB_N_R MB_N_C
//Port 502 (defined in Mudbus.h) MB_PORT

void setup()
{
 uint8_t mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02 };
 uint8_t ip[] = { 192, 168, 0, 103 }; // CHANGE this to the IP address of your CONTROLLINO
 uint8_t gateway[] = { 192, 168, 0, 254 };
 uint8_t subnet[] = { 255, 255, 255, 0 };
 Ethernet.begin(mac, ip, gateway, subnet);

 delay(5000);
 Serial.begin(9600);
 Serial.println("Started");
 
 pinMode(D0, OUTPUT); 
 pinMode(D1, INPUT); 
 pinMode(R0, OUTPUT); 
 pinMode(A0_, INPUT); 
}

void loop()
{ 
 
 Mb.Run();

 analogWrite(D0, Mb.R[0]);
 digitalWrite(R0, Mb.R[2]);
 Mb.R[1] = digitalRead(D1); 
 Mb.R[3] = analogRead(A0_); 
 
}

MODBUS RTU VIA RS485

Hardware Required

• Controllino MAXI/MEGA
• 24V DC Power supply
• Controllino HMI
• 3 wires or serial port adapter (male)

Circuit

Note*
Pin header is working on 5V TTL levels. Voltage levels over 5.5V can damage the Controllino permanently.

HMI setup

To set up the Controllino HMI for communication and application we use the iX Software. iX Software is a revolutionary software that features drivers to communicate with your automation equipment, enhanced HMI functionality, state-of-the-art graphics, an intuitive design environment and a truly open platform for today’s automation market. iX Developer is a licensed application that runs on a Windows PC and is used to program iX operator panels.
Here we are going to show some steps on how to set it up properly. If you want to check more information and  the iX user manual click here.

Download the Controllino HMI – RTU example and run it in the iX software.
From the left side of the main screen in the iX example there is the Tags button. Open the Tags to set your application addresses. You can see example of this on the next picture:

For more information about Tags and addressing of them navigate to Controllers/Settings and click on the help button of the Modbus Master controller.

Notice here that the Modbus_RTU tags are starting with “5:”. For communication with other stations than the default station, the station number is given as a prefix to the device. This is stated either as a fixed number or as an index register between I1 and I8. The station number is referring to a specific unit id. (5:40001 addresses holding register 40001 in station 5.)  In our case the Controllino is slave device on station 5. We can always define his station in the code that we upload.

After that go to the Controllers tab to choose the right controller for communication. When we are using the Controllino device we want to choose MODICON -> Modbus Master controller. In this example it is already done and they are named Modbus_TCP and Modbus_RTU.

Press on the Modbus_RTU controller, activate it and click on the Settings button to do the folowing steps:

Set communication mode to the Serial and the COM2 port of your Controllino HMI. Don’t forget to match the baud rate of Controllino and HMI. Choose the COM2 port to be RS-485.

Code

The Controllino HMI is communicating to the Controllino slave device on the station 5 so we have to set it in the line: define SlaveModbusAdd 5

#include <Controllino.h> /* Usage of CONTROLLINO library allows you to use CONTROLLINO_xx aliases in your sketch. */
#include "ModbusRtu.h" /* Usage of ModBusRtu library allows you to implement the Modbus RTU protocol in your sketch. */
/*
 CONTROLLINO - Modbus RTU protocol Slave example for MAXI and MEGA, Version 01.00
 
 The sketch is relevant only for CONTROLLINO variants MAXI and MEGA (because of necessity of RS485 interface)!

 This sketch is intended as an example of the communication between devices via RS485 with utilization the 
 ModbusRTU protocol.
 In this example the CONTROLLINO is used as the Modbus slave!
 For more information about the Modbus protocol visit the website: https://modbus.org/
 
 Modbus master device can read Modbus 16bit registers (provided by the slave):
 0 - analog CONTROLLINO_A0 value (0 - 1024)
 1 - digital CONTROLLINO_D0 value (0/1)
 2 - Modbus messages received
 3 - Modbus messages transmitted

 Modbus master device can write Modbus 16bit registers:
 4 - relay CONTROLLINO_R0 (0/1)
 5 - relay CONTROLLINO_R1 (0/1)
 6 - relay CONTROLLINO_R2 (0/1)
 7 - relay CONTROLLINO_R3 (0/1)

 To easily evaluate this example you need a second CONTROLLINO as Modbus master running DemoModbusRTUMaster 
 example sketch.
 Please note that both CONTROLLINOs need 12/24V external supply and you need to interconnect GND, -, + signals 
 of RS485 screw terminal.

 Modbus Master-Slave library for Arduino (ModbusRtu.h) was taken from the website: 
 https://github.com/smarmengol/Modbus-Master-Slave-for-Arduino
 It was necessary to modify setting of the PORTJ for pins DE and RE control. These pins are located at the 
 PORJ and on the pins PIN6(DE) and PIN5(RE).

 IMPORTANT INFORMATION!
 Please, select proper target board in Tools->Board->Controllino MAXI/MEGA before Upload to your CONTROLLINO.
 (Please, refer to https://github.com/CONTROLLINO-PLC/CONTROLLINO_Library if you do not see the CONTROLLINOs in 
 the Arduino IDE menu Tools->Board.)

 Created 30 March 2017
 by David


 (Check https://github.com/CONTROLLINO-PLC/CONTROLLINO_Library for the latest CONTROLLINO related software stuff.)
*/
int D0 = CONTROLLINO_D0;
int D1 = CONTROLLINO_D1;
int R0 = CONTROLLINO_R0;
int A0_ = CONTROLLINO_A0;

// This MACRO defines Modbus slave address.
// For any Modbus slave devices are reserved addresses in the range from 1 to 247.
// Important note only address 0 is reserved for a Modbus master device!

#define SlaveModbusAdd 5

// This MACRO defines number of the comport that is used for RS 485 interface.
// For MAXI and MEGA RS485 is reserved UART Serial3.

#define RS485Serial 3

// The object ControllinoModbuSlave of the class Modbus is initialized with three parameters.
// The first parametr specifies the address of the Modbus slave device.
// The second parameter specifies type of the interface used for communication between devices - in this sketch 
// is used RS485.
// The third parameter can be any number. During the initialization of the object this parameter has no effect.

Modbus ControllinoModbusSlave(SlaveModbusAdd, RS485Serial, 0);

// This uint16 array specified internal registers in the Modbus slave device.
// Each Modbus device has particular internal registers that are available for the Modbus master.
// In this example sketch internal registers are defined as follows:
// (ModbusSlaveRegisters 0 - 3 read only and ModbusSlaveRegisters 4 - 7 write only from the Master perspective):
// ModbusSlaveRegisters[0] - Read an analog value from the CONTROLLINO_A0 - returns value in the range from 0 to 1023.
// ModbusSlaveRegisters[1] - Read an digital value from the CONTROLLINO_D0 - returns only the value 0 or 1.
// ModbusSlaveRegisters[2] - Read the number of incoming messages - Communication diagnostic.
// ModbusSlaveRegisters[3] - Read the number of number of outcoming messages - Communication diagnostic.
// ModbusSlaveRegisters[4] - Sets the Relay output CONTROLLINO_R0 - only the value 0 or 1 is accepted.
// ModbusSlaveRegisters[5] - Sets the Relay output CONTROLLINO_R1 - only the value 0 or 1 is accepted.
// ModbusSlaveRegisters[6] - Sets the Relay output CONTROLLINO_R2 - only the value 0 or 1 is accepted.
// ModbusSlaveRegisters[7] - Sets the Relay output CONTROLLINO_R3 - only the value 0 or 1 is accepted.

uint16_t ModbusSlaveRegisters[8];

// The setup function runs once when you press reset (CONTROLLINO RST button) or connect the CONTROLLINO to the PC
// In the setup function is carried out port setting and initialization of communication of the Modbus slave protocol.

void setup()
{
 delay(5000);
 Serial.begin(9600);
 Serial.println("Started");
 
 pinMode(D0, OUTPUT); 
 pinMode(D1, INPUT); 
 pinMode(R0, OUTPUT); 
 pinMode(A0_, INPUT); 

 ControllinoModbusSlave.begin( 19200 ); // Start the communication over the ModbusRTU protocol. Baund rate is set at 19200.
 Serial.begin(9600);
 
}

// The loop function runs over and over again forever
void loop()
{
 // This instance of the class Modbus checks if there are any incoming data.
 // If any frame was received. This instance checks if a received frame is Ok.
 // If the received frame is Ok the instance poll writes or reads corresponding values to the internal registers 
 // (ModbusSlaveRegisters).
 // Main parameters of the instance poll are address of the internal registers and number of internal registers.
 
 ControllinoModbusSlave.poll(ModbusSlaveRegisters, 8);

 // While are not received or sent any data, the Modbus slave device periodically reads the values of analog and 
 // digital outputs.
 // Also it updates the other values of registers.

 analogWrite(D0, ModbusSlaveRegisters[0]);
 digitalWrite(R0, ModbusSlaveRegisters[2]);
 ModbusSlaveRegisters[1] = digitalRead(D1); 
 ModbusSlaveRegisters[3] = analogRead(A0_); 
 
}

More information about port manipulation on this site: https://www.arduino.cc/en/Reference/PortManipulation

Port registers allow for lower-level and faster manipulation of the i/o pins of the microcontroller on an Controllino PLC. Each port is controlled by three registers, which are also defined variables in the arduino language:

• DDR register – determines whether the pin is an INPUT or OUTPUT
• PORT register – controls whether the pin is HIGH or LOW
• PIN register – reads the state of INPUT pins set to input with pinMode()

DDR and PORT registers may be both written to, and read. PIN registers correspond to the state of inputs and may only be read.

Output Parallelization

There is the possibility to parallelize some digital outputs to drive loads with the need of more current under the following conditions:

• Outputs are controlled from the same processor port (possibility to set it via one instruction)
• There is no delay between control signls for parallelized outputs ( shall be managed by the SW)

Possible outputs for parallelization

MINI
1st group: D0, D1, D2, D3
2nd group: D4, D5
3rd group: D6, D7

MAXI:
1st group: D0, D1, D3
2nd group: D2
3rd group: D4, D5, D6, D7
4th group: D8, D9, D10, D11

MEGA:
1st group: D0, D1, D3
2nd group: D2
3rd group: D4, D5, D6, D7
4th group: D8, D9, D10, D11
5th group: D12, D13, D14, D15, D16, D17, D18, D19
6th group: D20, D21, D22
7th group: D23

Controllino PORTS

In order to see which Controllino pin corresponds to which PORT on microprocessor open the Controllino PINOUT tables.
Link to PINOUT table is here.

IMPORTANT INFORMATION!
Please, select proper target board in Tools->Board->Controllino MINI/MAXI/MEGA before Upload to your CONTROLLINO.
(Please, refer to https://github.com/CONTROLLINO-PLC/CONTROLLINO_Library if you do not see the CONTROLLINOs in the Arduino IDE menu Tools->Board.)

Hardware Required

• Controllino MINI/MAXI/MEGA
• 12/24V DC Power supply

Circuit

Note*
Pin header is working on 5V TTL levels. Voltage levels over 5.5V can damage the Controllino permanently.

Code

To  check where is the Overload LED connected we open the PINOUT table of the Controllino and find it.

Here we can see that the OVL LED is connected to the 7th bit of the PORT E on ATmega2560. There is no arduino number for this pin so we cannot set it like other arduino i/o pins.
The manipulation of this pin is shown in the next example:

void setup() 
{

 //Define the LED as an OUTPUT
 DDRE = DDRE | B10000000;
 
}

void loop() 
{

 //Set the 7th bit of the PORT E to HIGH without influence on other bits (OR logic)
 PORTE = PORTE | B10000000;
 delay(1000);
 //Set the 7th bit of the PORT E to LOW without influence on other bits (AND logic)
 PORTE = PORTE & B01111111;
 delay(1000);
 
}

To check the state of the Overload LED:

void setup() 
{
 Serial.begin(9600);
 DDRE = DDRE & B01111111; //Set PE7 (OVL pin) as INPUT
 Serial.println("CONTROLLINO Overload read:");
}

void loop() 
{
 Serial.print("Overload signal: ");
 int Overload_signal = PINE >> 7;
 if (Overload_signal == 1) Serial.println("OFF");
 else Serial.println("ON");
 delay(1000);
}

The MAXI Automation is the version of Controllino MAXI specifically tailored for the needs of automation specialists! It is the perfect compromise between compact size and big input and output number. The core competence is its flexibility.
In this example the usage of Controllino real analog (0-10V) outputs will be shown.
Controllino Maxi Automation has special:

• 2x Analog Inputs 0-10V
• 2x Analog Outputs – 0-10V (0-20mA)

If you need two current (0-20mA), and not voltage (0-10V) outputs for your project, you can change them into current outputs by simply removing two 0 Ω resistors on Maxi Automation controll board. This process will be shown in next steps.

Hardware Required

• Controllino MAXI Automation
• 24V DC Power supply
• Soldering iron
• Tweezers

Circuit

Note*
Pin header is working on 5V TTL levels. Voltage levels over 5.5V can damage the Controllino permanently.

Code

Controllino MAXI Automation

To set your real analog outputs for your needs you can use the builtin example from Controllino Library, or you can copy the example from below.

#include <Controllino.h> /* Usage of CONTROLLINO library allows you to use CONTROLLINO_xx aliases in your sketch. */

// the setup function runs once when you press reset (CONTROLLINO RST button) or connect the CONTROLLINO to the PC
void setup() {
 // initialize all used digital output pins as outputs
 pinMode(CONTROLLINO_AO0, OUTPUT);
 pinMode(CONTROLLINO_AO1, OUTPUT);                            
}

// the loop function runs over and over again forever
void loop() {
 int analogOut0 = 127;                     // 0 - 255 to be set (0 - 10 000 mV, or 0 - 20 000 uA)
 int analogOut1 = 255;                     // 0 - 255 to be set (0 - 10 000 mV, or 0 - 20 000 uA)
 analogWrite(CONTROLLINO_AO0, analogOut0); // set the analog output 0 to 5V or 10mA
 analogWrite(CONTROLLINO_AO1, analogOut1); // set the analog output 1 to 10V or 20mA                      
}

If you are not able to compile the sketch, choose the Controllino MAXI Automation board!
To make the outputs and relays work, CONTROLLINO pins have to be set up as OUTPUTs!

pinMode(CONTROLLINO_xx, OUTPUT);

Steps

In the following steps we will show you how to turn the voltage to the current outputs.

Step 1:

Remove the Controllino MAXI Automation cover by lifting marked sides of the cover with flat-head screwdriver:

Step 2:

Remove the plastic sides and disconnect the Controllino connection board

from the Controllino MAXI Automation.

Step 3:

Locate the two 0 Ω resistors of the Controllino relay board:

Step 4:

In order to get the two current outputs (0-20 mA) on Controllino MAXI Automation, apply heat and take the tweezers to remove two 0 Ω resistors:

To get back the voltage outputs (0-10V), simply solder the resistors back on Controllino MAXI Automation control board.

Note*
To test the outputs use previous example or example from the CONTROLLINO library for the Controllino MAXI Automation.
0-10 V -> 0-20 mA
If you are not able to compile the sketch, choose the Controllino MAXI Automation board!