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

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);
}

Interrupts are useful for automatically executing things in microcontroller programs and can solve timing problems. Good tasks for using an interrupt may include reading a rotary encoder or monitoring user input.
The Arduino Uno has 2 and the Mega has 6 external interrupt pins available:

• Arduino Uno/Controllino MINI/INT.x interrupt:                   2/IN0/INT.0  –  3/IN1/INT.1 
• Arduino Mega/Controllino MAXI,MEGA/INT.x interrupt: 2/D0/INT.0  –  3/D1/INT.1  –  18/IN0/INT.5  –  19/IN1/INT.4  –  20/SDA/INT.3  –  21/SCL/INT.2

On the other hand the pin change interrupts can be enabled on many more pins.

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

Controllino MINI/MAXI/MEGA

#include <Controllino.h>

const byte digital_output = CONTROLLINO_D0;
const byte interruptPin = CONTROLLINO_IN1;
volatile byte state = LOW;

void setup() {
 pinMode(digital_output, OUTPUT);
 pinMode(interruptPin, INPUT);
 attachInterrupt(digitalPinToInterrupt(interruptPin), blink, CHANGE);
}

void loop() {
 digitalWrite(digital_output, state);
}

void blink() {
 state = !state;
}

Controllino MEGA has 24 High Side digital outputs available. The first 20 outputs we can control using the standard Arduino functions (e.g. digitalWrite and analogWrite), but for D20-D23 digital outputs we have to know how to use PORT manipulation on ATmega2560. On the connection picture we can see that there are no Arduino pins assigned to these outputs.

To see more about PORT manipulation please click here.

Hardware Required

• Controllino 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

Controllino MEGA

void setup() 
{
 DDRD = DDRD | B01110000; //Set the ports PD4, PD5, PD6 as outputs
 DDRJ = DDRJ | B00010000; //Set the port PJ4 as output
}

void loop() {
 int del = 100;
 //Digital output 20
 PORTD = PORTD | B00010000; //Set HIGH
 delay(del); 
 PORTD = PORTD & B11101111; //Set LOW
 delay(del);

}


/*
//Digital output 21
 PORTD = PORTD | B00100000;
 delay(del); 
 PORTD = PORTD & B11011111;
 delay(del);


//Digital output 22
 PORTD = PORTD | B01000000;
 delay(del); 
 PORTD = PORTD & B10111111;
 delay(del);
 

//Digital output 23
 PORTD = PORTD | B10000000;
 delay(del); 
 PORTD = PORTD & B01111111;
 
 
 PORTJ = PORTJ | B00010000;
 delay(del); 
 PORTJ = PORTJ & B11101111;
 delay(del);

 
 PORTD = PORTD | B01110000; // sets Digital Outputs 20,21,22 in one shot to HIGH
                            // -> turns the LEDs ON
 PORTJ = PORTJ | B00010000; // sets Digital Output 23 in one shot to HIGH 
                            // -> turns the LED ON


 PORTD = PORTD & B10001111; // sets Digital Outputs 20,21,22 in one shot to LOW 
                            // -> turns the LEDs OFF
 PORTJ = PORTJ & B11101111; // sets Digital Output 23 in one shot to LOW
                            // -> turns the LED OFF
*/