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.

Welcome to the “HTTP Web Client” tutorial using the CONTROLLINO MICRO. In this tutorial, we will learn how to create a web client that connects to a web server, using the provided example code as a starting point.

Prerequisites

• Installed Arduino IDE.
• CONTROLLINO MICRO board.

Example Code

Please grab the following example .ino file from Github:

Step-by-Step Guide

Step 1: Setup the Arduino Environment

1. Connect your MICRO to your computer.
2. Open the Arduino IDE.
3. Ensure that the appropriate board and port are selected in the Tools menu.

Step 2: Understanding the Code

The example code can be broken down into several key parts:

Initialization

• MAC Address: A unique identifier for your network interface. You can use the provided address.
• IP and DNS: Optionally, you can set a static IP and DNS server address if DHCP fails.

Setup Function

• Start Serial Communication: Initialize serial communication for debugging.
• Initialize Ethernet: Attempt to start Ethernet with DHCP. If it fails, it uses the static IP set earlier.

Loop Function

• Handle Incoming Data: If data is received from the Ethernet, it is printed to the serial monitor for debugging.
• Reconnect and Send Requests: Every 10 seconds (as set by postingInterval), the httpRequest function is called to send a new request.

HTTP Request Function

• Connect to Server: Attempt to connect to the specified server on port 80.
• Send HTTP Request: If the connection is successful, send an HTTP GET request.
• Handle Failed Connection: If the connection fails, print an error message.

Step 3: Create the Web Client

1. Modify the MAC Address: Change the mac[] array if you want to use a different MAC address.
2. Set IP and DNS (Optional): Modify ip and myDns if you need to use a static IP and DNS.
3. Change Server Address: Replace server[] with the address of the web server you want to connect to.
4. Upload Code: Connect your CONTROLLINO MICRO to your computer, select the appropriate board and port in the Arduino IDE, and upload the code.
5. Monitor Output: Open the Serial Monitor in the Arduino IDE to see debug output and responses from the server.

Conclusion

You now have a basic web client running on your CONTROLLINO MICRO. This client connects to a specified web server, sends an HTTP GET request, and prints the response. You can expand on this by modifying the request, handling different types of responses, or integrating this functionality into a larger project.

Remember, networking can sometimes be tricky, so don’t hesitate to experiment and troubleshoot as needed. Enjoy exploring the capabilities of your CONTROLLINO MICRO!

The I2C (Inter-Integrated Circuit) protocol is a popular means of communication between various sensors and devices. In this tutorial, we will learn how to create an I2C scanner using the CONTROLLINO MICRO, which is useful for detecting the I2C addresses of devices connected to your microcontroller.

Prerequisites

• Installed Arduino IDE.
• CONTROLLINO MICRO board.

Example Code

Please grab the following example .ino file from Github:

Step-by-Step Guide

Step 1: Setup the Arduino Environment

1. Connect your MICRO to your computer.
2. Open the Arduino IDE.
3. Ensure that the appropriate board and port are selected in the Tools menu.

Step 2: Understanding the Code

The Setup Function

void setup()
{
  Wire.setSDA(PIN_WIRE0_SDA);
  Wire.setSCL(PIN_WIRE0_SCL);
  Wire.begin();
  Serial.begin(9600);
  while (!Serial);
  Serial.println("\nI2C Scanner");
}

• Wire.setSDA() and Wire.setSCL(): Sets the SDA (data line) and SCL (clock line) pins for I2C communication.
• Wire.begin(): Initializes the I2C bus.
• Serial.begin(9600): Starts serial communication at 9600 baud rate.
• Serial.println("\nI2C Scanner"): Prints a message to the Serial Monitor.

The Loop Function

void loop()
{
  byte error, address;
  int nDevices;
  Serial.println("Scanning...");
  nDevices = 0;
  for (address = 1; address < 127; address++)
  {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    if (error == 0)
    {
      // Device found
    }
    else if (error == 4)
    {
      // Unknown error
    }
  }
  // Print scan results
  delay(5000); // Wait for next scan
}

• Scans I2C addresses from 1 to 126.
• Wire.beginTransmission(address): Starts transmission to a device at address.
• error = Wire.endTransmission(): Ends the transmission and returns an error status.
• If error is 0, an I2C device is found.
• If error is 4, there’s an unknown error at the address.

Step 3: Hardware Setup

1. Connect your I2C device(s) to the CONTROLLINO MICRO.
2. Ensure proper connections for SDA and SCL lines, along with power and ground.

Step 4: Using the I2C Scanner

1. Open the Serial Monitor in the Arduino IDE.
2. Set the baud rate to 9600.
3. Observe the output. The scanner will list the addresses of detected I2C devices.

Step 5: Interpreting Results

• Addresses will be displayed in hexadecimal format.
• Note down the addresses of your I2C devices for use in your projects.

Conclusion

This tutorial has guided you through setting up an I2C scanner on the CONTROLLINO MICRO. This tool is invaluable for troubleshooting and setting up I2C communication with various sensors and peripherals.

This tutorial will guide you through setting up a Modbus RTU server on a CONTROLLINO MICRO. We’ll be using a modified version of an example code that demonstrates how to control an LED via a Modbus RTU server.

Prerequisites

• Installed Arduino IDE.
• CONTROLLINO MICRO board.

Example Code

Please grab the following example .ino file from Github:

Step-by-Step Guide

Step 1: Setup the Arduino Environment

1. Connect your MICRO to your computer.
2. Open the Arduino IDE.
3. Ensure that the appropriate board and port are selected in the Tools menu.
4. Install the ArduinoRS485 and ArduinoModbus libraries via the Library Manager in the Arduino IDE.

Step 2: Understanding the Modbus RTU Server Code

The provided code snippet establishes a Modbus RTU server. Here’s a breakdown:

• Libraries: Include ArduinoRS485 and ArduinoModbus.
• RS485 Configuration: Set up the RS485 serial communication.
• Setup Function: Initialize serial communication, set up the Modbus server and LED.
• Loop Function: Constantly checks for Modbus requests and toggles the LED based on the coil value.

Step 3: Testing the code

After uploading, your CONTROLLINO MICRO should be ready to respond to Modbus RTU client requests. Use a Modbus RTU client to send requests to your server:

• Writing a value of 1 to coil address 0x00 should turn the LED on.
• Writing a value of 0 should turn it off.

Troubleshooting

If the LED does not respond as expected, check the following:

• Correct wiring of the LED and Modbus connections.
• Verify the correct COM port and board settings in the Arduino IDE.
• Make sure the Modbus client is correctly configured to communicate with your server.

Conclusion

You have now successfully created a Modbus RTU server on your CONTROLLINO MICRO. This server can interact with Modbus clients, allowing for various automation and control applications. Experiment with different Modbus registers and functionalities to expand your project!

This tutorial will guide you through setting up a Modbus TCP server on a CONTROLLINO MICRO. We’ll be using a modified version of an example code that demonstrates how to control an LED via a Modbus TCP server.

Prerequisites

• Installed Arduino IDE.
• CONTROLLINO MICRO board.

Example Code

Please grab the following example .ino file from Github:

Step-by-Step Guide

Step 1: Setup the Arduino Environment

1. Connect your MICRO to your computer.
2. Open the Arduino IDE.
3. Ensure that the appropriate board and port are selected in the Tools menu.
4. In the Arduino IDE, include the SPI, Ethernet, ArduinoRS485, and ArduinoModbus libraries.

Step 2: Configure Network Settings

Define a MAC address and IP address for your device. Replace the mac and ip variables with your desired values.

Step 3: Initialize Ethernet and Modbus TCP Server

In the setup() function, start the Ethernet connection using Ethernet.begin(mac, ip). Verify Ethernet hardware and connection status and initialize the Modbus TCP server with modbusTCPServer.begin().

Step 4: Configure Digital Outputs & Modbus Coils

Set the LED pin as an output and initialize it to LOW (off). Configure a single coil at address 0x00 using modbusTCPServer.configureCoils(0x00, 1).

Step 5: Handling connections and updating the LED value

Handling Client Connections

In the loop() function, use ethServer.available() to listen for incoming clients. Once a client is connected, use modbusTCPServer.accept(client) to accept the connection.

Polling and Controlling the LED

Continuously call modbusTCPServer.poll() to listen for Modbus requests. Use updateLED() to read the coil value and update the LED state.

The updateLED Function

This function reads the coil value using modbusTCPServer.coilRead(0x00). It then sets the LED state based on the coil value.

Troubleshooting

• If the LED does not respond, check your network connection and ensure your Modbus client is configured correctly.
• Verify the MAC and IP address are correctly set for your network environment.
• Make sure the correct board and port are selected in the Arduino IDE.

Conclusion

You have now successfully created a Modbus TCP server on your CONTROLLINO MICRO. This server can interact with Modbus clients, allowing for various automation and control applications. Experiment with different Modbus registers and functionalities to expand your project!

In this tutorial, we will explore how to use the ECC608 Crypto Chip on a CONTROLLINO MICRO board to generate truly random numbers. This is particularly useful in applications requiring high levels of security, such as cryptographic operations, secure communications, or any scenario where unpredictability is crucial.

Prerequisites

• Installed Arduino IDE.
• CONTROLLINO MICRO board.

Example Code

Please grab the following example .ino file from Github:

Step-by-Step Guide

Step 1: Setup the Arduino Environment

1. Connect your MICRO to your computer.
2. Open the Arduino IDE.
3. Ensure that the appropriate board and port are selected in the Tools menu.

Step 2: Understanding the Provided Code

#include <SPI.h>
#include <ArduinoECCX08.h>

void setup() {
  Serial.begin(115200);
  while (!Serial);
  delay(2000);

  Wire.setSDA(2);
  Wire.setSCL(3);
  
  if (!ECCX08.begin()) {
    Serial.println("Failed to communicate with ECC508/ECC608!");
    while (1);
  }

  if (!ECCX08.locked()) {
    Serial.println("The ECC508/ECC608 is not locked!");
    while (1);
  }
}

void loop() {
  Serial.print("Random number = ");
  Serial.println(ECCX08.random(65535));

  delay(1000);
}

Code Breakdown

• Initialization: The setup() function initializes serial communication and sets up the I2C communication with specific SDA and SCL pins. It also checks if the ECC608 chip is properly communicating and locked for secure operations.
• Generating Random Numbers: The loop() function continuously generates a random number using ECCX08.random(65535) and prints it to the Serial Monitor every second.

Step 3: Running the Code

1. Copy the provided code into a new sketch in the Arduino IDE.
2. Upload the sketch to your CONTROLLINO MICRO.
3. Open the Serial Monitor (Tools > Serial Monitor) to view the random numbers being generated.

Troubleshooting

• If the Serial Monitor displays an error related to the ECC608 chip, ensure that the chip is correctly configured and locked.
• For any issues related to the Arduino IDE or board connections, consult the official Arduino forums or documentation.

Conclusion

By following this tutorial, you have successfully used the ECC608 Crypto Chip on your CONTROLLINO MICRO to generate truly random numbers. This functionality can be integrated into larger projects where secure random number generation is required.

Feel free to modify the code to suit your specific application needs, and explore other capabilities of the ECC608 chip to enhance the security of your projects.

Creating a self-signed certificate using the ECC608 crypto chip involves generating a private key within the chip and then creating a certificate that is signed with this key. This tutorial demonstrates the process using CONTROLLINO MICRO and the ECC608 chip.

Prerequisites

• Installed Arduino IDE.
• CONTROLLINO MICRO board.

Example Code

Please grab the following example .ino file from Github:

Step-by-Step Guide

Step 1: Setup the Arduino Environment

1. Connect your MICRO to your computer.
2. Open the Arduino IDE.
3. Ensure that the appropriate board and port are selected in the Tools menu.

Step 2: Understanding the Provided Code

The provided example code performs the following functions:

• Initializes the ECC608 chip.
• Checks if the chip is locked and prompts the user to lock it with a default TLS configuration if not.
• Gathers input for certificate details such as issue date, expiry, and slot numbers for key storage.
• Generates a new private key (if required) and a self-signed certificate.
• Outputs the certificate and its SHA1 fingerprint.

Step 3: Load the Example Code

1. Copy the provided code into a new sketch in the Arduino IDE.
2. Review the code to understand its flow and functionality.

Step 4: Modify the Code (Optional)

You can modify the default values or add additional functionality as needed. For instance, you might want to change the default slot numbers or the default years of validity for the certificate.

Step 5: Compile and Upload the Code

1. Click on the Verify button to compile the code.
2. Click on the Upload button to upload the code to your Arduino MKR board.

Step 6: Interact with the Program

After uploading, open the Serial Monitor. You will see prompts asking for various details needed to generate the certificate:

• Issue date and time of the certificate.
• Expiry duration of the certificate.
• Slots for storing the private key and certificate.
• Choice to generate a new key.

Step 7: Generate the Certificate

Respond to the prompts in the Serial Monitor. The program will generate a self-signed certificate based on your responses and display it along with its SHA1 fingerprint.

Troubleshooting

• If the Serial Monitor displays an error related to the ECC608 chip, ensure that the chip is correctly configured and locked.
• For any issues related to the Arduino IDE or board connections, consult the official Arduino forums or documentation.

Conclusion

You now have a self-signed certificate generated by the ECC608 chip. This certificate can be used for various cryptographic purposes, enhancing the security of your projects.

This tutorial will guide you through using the CAN (Controller Area Network) port on the CONTROLLINO MICRO to send data. We’ll use example code to demonstrate how to set up and send both standard and extended CAN messages.

Prerequisites

• Installed Arduino IDE.
• CONTROLLINO MICRO board.

Example Code

Please grab the following example .ino file from Github:

Step-by-Step Guide

Step 1: Initialization

• Serial Begin: Initialize serial communication at 115200 baud rate to monitor the data sending process.cppCopy codeSerial.begin(115200);
• CAN Initialization: Start the CAN bus at 500 kbps. This is a common speed for CAN networks.cppCopy codeSPI1.setRX(PIN_SPI1_MISO); SPI1.setTX(PIN_SPI1_MOSI); SPI1.setSCK(PIN_SPI1_SCK); if (!CAN.begin(500E3)) { Serial.println("Starting CAN failed!"); while (1); }

Step 2: Sending Standard CAN Packets

• Begin Packet: Start a CAN packet with a standard ID (11 bits). In this example, 0x12 is used as the ID.cppCopy codeCAN.beginPacket(0x12);
• Write Data: Send the data bytes. Here, we’re sending the word ‘hello’.cppCopy codeCAN.write('h'); CAN.write('e'); CAN.write('l'); CAN.write('l'); CAN.write('o');
• End Packet: End the CAN packet transmission.cppCopy codeCAN.endPacket();

Step 3: Sending Extended CAN Packets

• Begin Extended Packet: Start an extended CAN packet with a 29-bit ID. Example ID: 0xabcdef.cppCopy codeCAN.beginExtendedPacket(0xabcdef);
• Write Extended Data: Similar to standard packets, but with different data. In this case, ‘world’.cppCopy codeCAN.write('w'); CAN.write('o'); CAN.write('r'); CAN.write('l'); CAN.write('d');
• End Extended Packet: Conclude the extended packet transmission.cppCopy codeCAN.endPacket();

Step 4: Loop

The loop() function sends these packets continuously at one-second intervals.

Testing and Validation

1. Monitor Serial Output: Open the Serial Monitor in your Arduino IDE to view the sending process and confirm successful transmission.
2. Check CAN Network: If possible, use a CAN analyzer or another CAN device to ensure the packets are being received correctly.
3. Troubleshooting: If there are issues in transmission, check connections, baud rate settings, and CAN IDs.

Conclusion

With this tutorial, you should be able to send both standard and extended CAN messages from your CONTROLLINO MICRO. This functionality is essential for many automotive and industrial applications using the CAN network.

In this tutorial, we’ll learn how to use the CAN (Controller Area Network) port on the CONTROLLINO MICRO to receive data. CAN is a robust vehicle bus standard designed to allow microcontrollers and devices to communicate with each other’s applications without a host computer.

Prerequisites

• Installed Arduino IDE.
• CONTROLLINO MICRO board.

Example Code

Please grab the following example .ino file from Github:

Overview of the Example Code

The provided example code is a simple CAN Receiver program. It initializes the CAN bus at a speed of 500 kbps and continuously checks for incoming CAN packets. When a packet is received, it prints its details and data to the Serial Monitor.

Key Functions

• CAN.begin(speed): Initializes the CAN bus at the specified speed.
• CAN.parsePacket(): Checks for incoming packets and returns their size.
• CAN.packetId(): Returns the ID of the received packet.
• CAN.packetExtended(): Checks if the packet uses an extended ID.
• CAN.packetRtr(): Checks if the packet is a Remote Transmission Request (RTR).
• CAN.read(): Reads a byte of data from the received packet.

Step-by-Step Guide

Step 1: Setting Up Your Environment

1. Connect your CONTROLLINO MICRO to your computer.
2. Open the Arduino IDE and select the correct board and port for your CONTROLLINO MICRO.

Step 2: Understanding the Code

1. Serial Communication: The Serial.begin(115200); command starts serial communication at a baud rate of 115200. This is useful for debugging and monitoring CAN traffic.
2. CAN Initialization: CAN.begin(500E3); initializes the CAN bus at 500 kbps. The if statement checks if the CAN bus starts successfully.
3. Receiving CAN Packets: Inside the loop(), CAN.parsePacket(); checks for incoming packets. If a packet is received, its details (like ID, type, size) are printed to the Serial Monitor.

Step 3: Modifying the Code for Your Application

• You can modify the loop() function to suit your application needs. For example, you might want to perform specific actions based on the packet’s ID or data.

Step 4: Uploading and Testing

1. Copy the provided example code into a new sketch in the Arduino IDE.
2. Upload the sketch to your CONTROLLINO MICRO.
3. Open the Serial Monitor to view the output.

Step 5: Debugging

• If you encounter issues, ensure your CAN bus is correctly configured and all devices are properly connected.
• Check the baud rate and CAN bus settings.

Conclusion

You now have a basic understanding of how to use the CAN port on the CONTROLLINO MICRO to receive data. This setup can be the foundation for more complex applications involving vehicle networks, industrial automation, and more.