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

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

The LiquidCrystal library allows you to control LCD displays that are compatible with the Hitachi HD44780 driver. These are the LCDs that are usually connected over a 16-pin interface.

This example sketch prints “Hello World!” to the LCD and shows the time in seconds since the Arduino was reset. To see more about 16×2 LCD and related pins please visit https://www.arduino.cc/en/Tutorial/HelloWorld?from=Tutorial.LiquidCrystal

Required Hardware

• Controllino MINI/MAXI/MEGA (no Pure versions, as the 5V Pin Headers are needed)
• 12/24V DC Power supply
• 16×2 LCD
• 10k ohm potentiometer
• hook-up wires

Circuit

Instead of the pins that we use in this example you can use every other communication, output and input pin. We suggest to use first communication and output pins because of internal resistors and then input pins.
In this example we don’t need UART and SPI communication and we are using these pins to have all input and output pins free.

Code

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

/*
 LiquidCrystal Library - Hello World

 Demonstrates the use a 16x2 LCD display. The LiquidCrystal
 library works with all LCD displays that are compatible with the
 Hitachi HD44780 driver. There are many of them out there, and you
 can usually tell them by the 16-pin interface.

 This sketch prints "Hello World!" to the LCD

 This example code is in the public domain.

 https://www.arduino.cc/en/Tutorial/LiquidCrystal
 */

// include the library code:
#include <LiquidCrystal.h>
//#include <Controllino.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(1, 0, 53, 51, 50, 52);

void setup() {
 
 // set up the LCD's number of columns and rows:
 lcd.begin(16, 2);
 
 // Print a message to the LCD.
 lcd.print("Controllino MAXI");
 
}

void loop() {
 
 // set the cursor to column 0, line 1
 // (note: line 1 is the second row, since counting begins with 0):
 
 lcd.setCursor(0, 1);
 
 // print the number of seconds since reset:
 lcd.print("Hello World!");
 
 delay(5);
 
}

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 terminal “12V/24V” and “GND” on the upper side of the CONTROLLINO terminals are for the supply voltage connection. You can supply the CONTROLLINO with 12V or 24V. The range of voltage should be in the range of 10.8V-13.2V and 21.6V-26.4V direct voltage.

IMPORTANT! Please make sure using a stabilized supply voltage!

The maximal supply current I not the same for MINI, MAXI and MEGA:

• MINI: 8A
• MAXI: 20A
• MEGA: 30A

Exceeding the maximum current would lead to a fusing of the internal fuse of the CONTROLLINO.

The right supply voltage will be indicated by 2 LEDs. The LEDs are marked with “12V” and “24V”. Depending on the supply voltage the LEDs will show the state of the CONTROLLINO.

12V LED 24V LED state

green orange 12V supply voltage active

orange green 24V supply voltage active

orange orange supply voltage outside of supported range

INFO: After connecting the supply voltage CONTROLLINO will start immediately executing the loaded program!