Portenta Machine Control User Manual

This user manual provides a comprehensive overview of the Portenta Machine Control, covering its major hardware and software elements. With this user manual, you will learn how to set up, configure, and use all the main features of the Portenta Machine Control.

This User Manual teaches how to use the Portenta Machine Control with the new

Arduino_PortentaMachineControl

Arduino_MachineControl

Hardware and Software Requirements

Hardware Requirements

• Portenta Machine Control (x1)
• Micro-USB cable (x1)
• +24 VDC/0.5 A power supply (x1)
• 2.4 GHz RP-SMA male antenna (x1) (only required for testing Wi-Fi®/Bluetooth® capabilities)

Software Requirements

• Arduino IDE 2.0+ or Arduino Web Editor
• Arduino_PortentaMachineControl library

This User Manual shows how to use the Portenta Machine Control using the Arduino IDE environment. To learn more about how to use it with IEC-61131-3 languages and the PLC IDE, check out our tutorials here.

Portenta Machine Control Overview

The Portenta Machine Control is designed for efficiency and adaptability in industrial environments. It is compatible with the Arduino framework and other embedded platforms and provides a flexible solution for controlling various equipment and machinery. The Portenta H7 board (included) is central to its operation, which ensures stable performance across a broad temperature spectrum, ranging from -40 °C to +85 °C, without external cooling requirements.

This controller offers many connectivity options, from USB and Ethernet to Wi-Fi® and Bluetooth® Low Energy, as well as industry-specific protocols like Modbus and Canbus. It can also connect with various external sensors, actuators, and different Human Machine Interfaces (HMI), such as displays and touch panels, showcasing its adaptability. It is designed for harsh industrial operations with features like DIN bar compatible housing, compact size, and an integrated Real-Time Clock (RTC). For real-time control or predictive maintenance tasks, the Portenta Machine Control is a solid choice for businesses aiming to enhance production and equipment management processes.

Portenta Machine Control Main Components

The Portenta Machine Control features a secure, certified, and durable design that enables it for automation and industrial applications.

Here is an overview of the controller's main components shown in the image above:

Microcontroller: At the heart of the Portenta Machine Control is the STM32H747XI, a powerful, robust, and high-performance dual-core microcontroller from STMicroelectronics®. This microcontroller is built around an Arm® Cortex®-M7 and an Arm® Cortex®-M4 32-bit RISC cores. The Arm® Cortex®-M7 core operates at up to 480 MHz, while the Arm® Cortex®-M4 core operates at up to 240 MHz.

Memory and storage:

• 2 MB of Flash Memory
• 1 MB of RAM
• Additional onboard memory of 8 MB SDRAM
• 16 MB Flash QSPI

Security: The controller features an onboard ready-to-use secure element from NXP®, the SE0502. This secure element, specifically designed for Internet of Things (IoT) devices, provides advanced security features, perfect for Industrial IoT (IIoT) environments where security is critical.

Power architecture: The controller's power system was designed to be resilient. It operates at an input voltage of +24 VDC, with reverse polarity protection, ensuring the controller remains safeguarded from power irregularities.

Digital and analog ports: Equipped with a versatile set of input and output ports, the Portenta Machine Control supports:

• 8x digital input ports with 8x Status LEDs labeled as

  DIGITAL INPUTS

• 8x digital output ports with 8x Status LEDs labeled as

  DIGITAL OUTPUTS

• 3x software-configurable analog input ports labeled as

  ANALOG IN

• 4x analog output ports labeled as

  ANALOG OUT

• 12x digital programmable input/output ports labeled as

  PROGRAMMABLE DIGITAL I/O

Temperature sensing: With three software-configurable temperature channels, the Portenta Machine Control can measure a variety of temperature ranges using:

• Type K thermocouples
• Type J thermocouples
• PT100 sensors

Communication interfaces and protocols: Seamless connectivity is a hallmark of this controller. The Portenta Machine Control offers high-speed, software-configurable communication interfaces and protocols such as:

• CAN bus
• RS-232
• RS-422
• RS-485
• I2C interface (accessible via a Grove connector)
• Modbus RTU (over RS-485)
• Modbus TCP (over Ethernet)

Ethernet and USB: The Portenta Machine Control features onboard Ethernet connectivity and full-speed USB-A and half-speed micro-USB Type B connectors for wired communication.

Wireless connectivity: The Portenta Machine Control supports 2.4 GHz Wi-Fi® (802.11 b/g/n) and Bluetooth® Low Energy (4.2 supported by firmware and 5.1 supported by hardware).

Additional features: The Portenta Machine Control features an onboard RTC with at least 48 hours of memory retention and two encoder channels. Moreover, Electrostatic Discharge (ESD) protection on all inputs and output ports ensures the longevity and durability of the controller.

Form factor: The Portenta Machine Control can be standalone on a DIN rail, a grid, or a panel, providing quick and easy access to all input/output ports and peripherals.

Portenta Machine Control Core and Libraries

The

Arduino Mbed OS Portenta Boards

portenta

Arduino Mbed OS Portenta Boards

The

Arduino_PortentaMachineControl

1. Navigate to Tools > Manage Libraries... or click the Library Manager icon in the left tab of the IDE.
2. In the Library Manager tab, search for

   portentamachinecontrol

   and install the latest

   Arduino_PortentaMachineControl

   library version. If the IDE asks you to install additional dependent libraries, install all of them.

Arduino PLC IDE

PLC IDE is the Arduino solution to program Portenta Machine Control devices using the five programming languages recognized by the IEC 61131-3 standard.

The IEC 61131-3 programming languages include:

• Ladder Diagram (LD)
• Functional Block Diagram (FBD)
• Structured Text (ST)
• Sequential Function Chart (SFC)
• Instruction List (IL)

In the PLC IDE, you can mix PLC programming with standard Arduino sketches within the integrated sketch editor and share variables between the two environments. You can also automate tasks in your software applications; this gives you control over scheduling and repetition, enhancing the reliability and efficiency of your project. Moreover, communication protocols such as Modbus RTU and Modbus TCP can be managed effortlessly using integrated no-code fieldbus configurators.

Check out the following resources that will show you how to start with the Arduino PLC IDE and use IEC 61131-3 programming languages with the Portenta Machine Control:

• Arduino PLC IDE download page and tutorials
• Portenta Machine Control tutorials

Pinout

The complete pinout is available and downloadable as PDF from the link below:

• Portenta Machine Control pinout

Datasheet

The complete datasheet is available and downloadable as PDF from the link below:

• Portenta Machine Control datasheet

STEP Files

The complete STEP files are available and downloadable from the link below:

• Portenta Machine Control STEP files

First Use

Powering the Portenta Machine Control

Portenta Machine Control can be powered in different ways:

• Using an external +24 VDC/0.5 A power supply connected to Portenta's Machine Control power supply terminals. Please refer to the pinout section of the user manual.
• Using a micro-USB cable (not included) for programming purposes only.

The Portenta Machine Control has several LEDs that indicate how the board is being powered:

• If the board is powered using a micro-USB cable, the 3V3 LED (red) will be turned on.
• The 12V LED (yellow) and the 24V LED (green LED) will be turned on if the board is powered using an external +24 VDC power supply.

Portenta Machine Control Terminals Features

Access to the main components and features of the Portenta Machine Control is provided through onboard terminal blocks, specifically from the SPTAF-1 connector series by Phoenix Contact. These connectors are distinguished by their low profile, ability to handle high currents, and intuitive push-in wire termination system. Below are the technical specifications of the Portenta Machine Control terminals:

• Pitch: 3.5 mm
• Connection method: Push-in spring connection
• Connection direction: 45º

The connector and wire specifications for the Portenta Machine Control terminals are outlined in the table below, indicating supported conductor cross sections and their respective capacities:

Hello World Example

Let's program the Portenta Machine Control with a modified version of the classic

hello world

Blink

Arduino_PortentaMachineControl

Remember to install the

Arduino Mbed OS Portenta Boards

Arduino_PortentaMachineControl

Copy and paste the sketch below into a new sketch in the Arduino IDE.

Copy
1// Include the Arduino_PortentaMachineControl library
2#include <Arduino_PortentaMachineControl.h>
3
4void setup() {
5    // Initialize the digital outputs terminals of the Arduino_PortentaMachineControl library
6    MachineControl_DigitalOutputs.begin();
7}
8
9void loop() {
10    // Turn on the digital output at channel 0
11    MachineControl_DigitalOutputs.write(0, HIGH);
12    delay(1000);
13    // Turn off the digital output at channel 0
14    MachineControl_DigitalOutputs.write(0, LOW);
15    delay(1000);
16}

The sketch begins by including the

Arduino_PortentaMachineControl

setup()

loop()

setup()

0

To upload the sketch to your Portenta Machine Control, click the Verify button to compile the sketch and check for errors; once verification is successful, click the Upload button to program the controller with the sketch.

Upon successful upload, observe the red LED on your controller's digital output labeled as

00

Digital Outputs

The Portenta Machine Control has up to eight digital output channels, as shown in the image below.

Some of the key features of the digital output channels of the Portenta Machine Control are the following:

• Digital outputs are high-side switches (TPS4H160AQPWPRQ1), handling up to 500 mA.
• All digital output terminals have overcurrent protection. If the current exceeds 700 mA (with a tolerance of ±20%), the channel opens to prevent damage.

The digital output channels must be connected to an external +24 VDC power supply through pin

24V IN

24V IN

GND

There are two modes of overcurrent protection in the digital output channels:

1. Latch mode: When overcurrent is detected, the digital output channel remains open and can only be closed manually via software.
2. Auto retry: Upon detecting overcurrent, the channel opens. After a short duration (several tens of milliseconds), it attempts to close automatically. If the overcurrent condition persists in the channel, it will keep toggling.

Ensure each channel does not exceed a maximum current of 500 mA to avoid potential damage or malfunctions in the digital output channels.

The example sketch below showcases a "scanning" effect using the digital output channels of the Portenta Machine Control, activating each channel sequentially. This method also provides visual feedback through the Arduino IDE's Serial Monitor, indicating which channel is active at any given moment.

Copy
1/*
2  Portenta Machine Control's Digital Outputs 
3  Name: portenta_machine_control_digital_outputs_example.ino
4  Purpose: Demonstrates a "scanning" effect using the digital output channels.
5  @author Arduino PRO Content Team
6  @version 1.0 01/10/23
7*/
8
9#include <Arduino_PortentaMachineControl.h>
10
11void setup() {
12  // Initialize serial communication at 9600 bauds
13  Serial.begin(9600);
14
15  // Initialize the digital outputs to latch mode (true)
16  MachineControl_DigitalOutputs.begin(true);
17
18  // Turn all channels off at startup
19  MachineControl_DigitalOutputs.writeAll(0);
20}
21
22void loop() {
23  // Sequentially activate each channel from 00 to 07
24  for (int i = 0; i < 8; i++) {  
25    // Turn on the current channel
26     // Wait to make the effect visible
27    MachineControl_DigitalOutputs.write(i, HIGH); 
28    Serial.println("- CH" + String(i) + ": ON");
29    delay(200);
30
31    // Turn off the current channel
32    // Wait to smooth the transition
33    MachineControl_DigitalOutputs.write(i, LOW);
34    delay(200); 
35  }
36}

Note that the sketch shown above uses the following functions from the

Arduino_PortentaMachineControl

• MachineControl_DigitalOutputs.begin(true)

  : This function initializes the digital outputs channels with overcurrent behavior set to latch mode, meaning that upon overcurrent detection, channels remain open until manually toggled in software.

• MachineControl_DigitalOutputs.writeAll(0)

  : This function initially sets all digital output channels to an open state (off).

• MachineControl_DigitalOutputs.write(channel, HIGH/LOW)

  : This function controls individual channel states, turning them either on (

  HIGH

  ) or off (

  LOW

  ). In the example sketch, this function creates the "scanning" effect by activating one channel at a time.

The expected behavior of the digital output channels LEDs is shown below.

Analog Outputs

The Portenta Machine Control has up to four independent analog output channels, as shown in the image below. These analog output channels enable precise voltage control for various applications.

Some of the key features of the analog output channels of the Portenta Machine Control are the following:

• Analog outputs can be configured with specific PWM periods, affecting the frequency and resolution of the voltage output.
• Each channel supports voltage outputs ranging from 0 VDC to 10.5 VDC and can source up to 20 mA.

Each analog output channel is designed with a double low-pass filter and a high-current operational amplifier (OPA2990IDSGR) set up in a non-inverting topology with a gain factor of 3.3. This design allows for an effective filtering and amplification of the signal, resulting in a high-quality/low-noise analog output signal.

The output signal of the analog output channels of the Portenta Machine Control is a DC voltage whose amplitude is a function of the defined PWM duty cycle.

Below is an example demonstrating using a single analog output channel to generate a sine wave voltage output.

Copy
1/*
2  Portenta Machine Control's Analog Output 
3  Name: portenta_machine_control_sine_wave_example.ino
4  Purpose: This sketch demonstrates the generation of a sine wave 
5  using an analog output channel of the Portenta Machine Control.
6
7  @author Arduino PRO Content Team
8  @version 1.0 01/10/23
9*/
10
11#include <math.h> 
12#include <Arduino_PortentaMachineControl.h>
13
14// PWM period set to 4 ms (or 250 Hz)
15#define PERIOD_MS 4 
16
17void setup() {
18  // Initialize serial communication at 9600 bauds
19  Serial.begin(9600);
20
21  // Initialize the analog output channels
22  MachineControl_AnalogOut.begin();
23  
24  // Set the PWM period for channel 0 to 4 ms (or 250 Hz)
25  MachineControl_AnalogOut.setPeriod(0, PERIOD_MS);
26}
27
28void loop() {
29  // Iterate through 360 degrees, generating a complete sine wave output
30  for (int i = 0; i < 360; i += 5) {
31    
32    // Calculate the sine wave voltage output from 0 to 10 VDC
33    float voltage = 5 + 5 * sin(i * (PI / 180)); 
34
35    // Set the voltage for channel 0
36    MachineControl_AnalogOut.write(0, voltage);
37
38    // Print the current voltage to the IDE's serial monitor (with two decimal precision)
39    Serial.println("Channel 0 set at " + String(voltage, 2) + "V");
40
41    // Introduce a delay to adjust the frequency of the sine wave
42    delay(15); 
43  }
44}

In the example sketch, the sine wave signal is generated by iterating through 360 degrees; the sine function is computed for each degree value. The sine function yields a value between -1 and 1; to convert this into a voltage value between 0 and 10 VDC, an offset of 5 VDC is added, and the result is then multiplied by 5. With this formula, the sine wave oscillates between 0 to 10 VDC. The delay introduced at the end of each iteration helps adjust the frequency of the sine wave signal, resulting in the desired waveform at the analog output.

Notice that the sketch shown above uses the following functions from the

Arduino_PortentaMachineControl

• MachineControl_AnalogOut.begin()

  : This function initializes the analog output channels, preparing them for voltage output.

• MachineControl_AnalogOut.setPeriod(channel, period)

  : This function configures the PWM period for the specified analog output channel. In the example shown above, it is set to 4 ms or 250 Hz.

• MachineControl_AnalogOut.write(channel, voltage)

  : This function controls the voltage output for the specified channel. In the example above, a sine wave is generated for channel

  AO0

  ranging from 0 to 10 VDC.

The expected result of the generated sine wave measured with an oscilloscope in the analog output channel

AO0

Digital Inputs

The Portenta Machine Control has up to eight digital input channels, as shown in the image below. Each channel incorporates a voltage divider comprising a 680 kΩ and a 100 kΩ resistor, which scales an input from 0 to 24 VDC down to 0 to 3 VDC.

Below is an example sketch showcasing how to periodically read data from all the digital input channels.

Copy
1/*
2  Portenta Machine Control Digital Input Example
3  Name: portenta_machine_control_digital_input_example.ino
4  Purpose: This sketch demonstrates how to periodically read 
5  from all the digital input channels on the Portenta Machine Control.
6
7  Author: Arduino PRO Content Team
8  Version: 1.0 01/10/23
9*/
10
11#include <Arduino_PortentaMachineControl.h>
12
13const int totalChannels = 8;
14const int channelPins[totalChannels] = {DIN_READ_CH_PIN_00, DIN_READ_CH_PIN_01, DIN_READ_CH_PIN_02, DIN_READ_CH_PIN_03, DIN_READ_CH_PIN_04, DIN_READ_CH_PIN_05, DIN_READ_CH_PIN_06, DIN_READ_CH_PIN_07};
15
16void setup() {
17  // Initialize serial communication at 9600 bauds
18  Serial.begin(9600);
19
20  // Initialize Wire transmission
21  Wire.begin();
22
23  // Initialize the digital input channels
24  // If initialization fails, notify via Serial Monitor
25  if (!MachineControl_DigitalInputs.begin()) {
26    Serial.println("- Failed to initialize the digital input GPIO expander!");
27  }
28}
29
30void loop() {
31  // Read the status of each digital input channel and display it
32  for (int i = 0; i < totalChannels; i++) {
33    uint16_t readings = MachineControl_DigitalInputs.read(channelPins[i]);
34    Serial.print("- CH0" + String(i) + ": " + String(readings) + "\t");
35  }
36
37  // Print a new line for better readability
38  Serial.println();
39  delay(500);
40}

Note that the example sketch uses a loop to individually read each digital input channel using the

MachineControl_DigitalInputs.read()

Arduino_PortentaMachineControl

Analog Inputs

The Portenta Machine Control has up to three independent analog input channels named

AI0

AI1

AI2

The configuration of Portenta's Machine Control analog input channels is determined by an analog switch (TS12A44514PWR), which allows switching between three different operational modes:

• 0-10V: The analog input channel uses a resistor divider consisting of a 100 kΩ and a 39 kΩ resistor for this mode. This scales down an input voltage in the 0 VDC to 10 VDC range to a range of 0 VDC to 2.8 VDC. The resulting input impedance in this configuration is approximately 28 kΩ.
• 4-20 mA: The analog input channel connects to a 120 Ω resistor for this mode. This configuration allows a 4 mA to 20 mA input current to be converted to a voltage in the 0.48 VDC to 2.4 VDC range.
• NTC: For this mode, the input is connected to a 3 VDC voltage reference (REF3330AIRSER). A 100 kΩ resistor is then placed in series, forming a part of the resistor divider powered by the voltage reference.

Each analog input channel has an output voltage pin supplying +24 VDC for powering sensors. This pin has integrated protection through a 500 mA PTC resettable fuse.

To use a specific operational mode with Portenta's Machine Control analog input channels, the

MachineControl_AnalogIn.begin(SensorType)

Arduino_PortentaMachineControl

MachineControl_AnalogIn.begin(SensorType)

• SensorType::V_0_10

  : 0-10V mode

• SensorType::MA_4_20

  : 4-20mA mode

• SensorType::NTC

  : NTC mode

Below is an example sketch showcasing how to read voltages from the analog input channels set to the 0-10V mode.

Copy
1/*
2  Portenta Machine Control's Analog Input 
3  Name: portenta_machine_control_analog_input_simple_example.ino
4  Purpose: This sketch demonstrates reading voltage values 
5  from the analog input channels set in the 0-10V mode 
6  of the Portenta Machine Control.
7
8  @author Arduino PRO Content Team
9  @version 1.0 01/10/23
10*/
11
12#include <Arduino_PortentaMachineControl.h>
13
14// Define the resistor divider ratio for 0-10V input mode
15const float RES_DIVIDER = 0.28057;
16
17// Define the ADC reference voltage
18const float REFERENCE   = 3.0;
19
20void setup() {
21  // Initialize serial communication at 9600 bauds
22  Serial.begin(9600);
23
24  // Initialize the analog input channels of the Portenta Machine Control in 0-10V mode
25  MachineControl_AnalogIn.begin(SensorType::V_0_10);
26}
27
28void loop() {
29  // Loop through each analog input channel
30  // Read its current voltage
31  // Print the current voltage value in the IDE's Serial Monitor
32  for (int i = 0; i < 3; i++) {
33    float voltage = readVoltage(i);
34    Serial.print("- Voltage CH");
35    Serial.print(i);
36    Serial.print(": ");
37    Serial.print(voltage, 3);
38    Serial.println(" VDC");
39  }
40  
41  // Add a delay for readability and a separator for the next set of readings
42  Serial.println();
43  delay(250);
44}
45
46/**
47  Reads the raw ADC value from the specified channel, then
48  calculates the actual voltage using the predefined resistor 
49  divider ratio and the reference voltage
50 
51  @param channel (int)
52  @return The calculated voltage value in volts
53*/
54float readVoltage(int channel) {
55  // Read the raw ADC value from the specified channel
56  float raw_voltage = MachineControl_AnalogIn.read(channel);
57  
58  // Convert the raw ADC value to the actual voltage 
59  // Use the resistor divider ratio and reference voltage 
60  // Return the calculated voltage
61  return (raw_voltage * REFERENCE) / 65535 / RES_DIVIDER;
62}

Note that the example sketch uses the

MachineControl_AnalogIn.read(channel)

RES_DIVIDER

REFERENCE

*For each analog input channel, there is a resistor divider made by 100K and 39K resistors, meaning that the input voltage is divided by a ratio of 0.28 approximately (

RES_DIVIDER

REFERENCE

Programmable Digital I/O

The Portenta Machine Control has up to 12 programmable digital input/output channels, as shown in the image below.

The programmable digital input/output channels are powered via three quad-channel high-side switches (TPS4H160AQPWPRQ1). Each channel comes with a nominal current value of 0.6 A. However, due to internal circuit tolerances of the high-side switches, this value can spike up to 0.9 A.

The programmable digital input/output channels must be connected to an external +24 VDC power supply through pin

24V IN

24V IN

GND

There are two modes of overcurrent protection in the programmable digital input/output channels:

1. Latch mode: The channel is deactivated once the current limit is hit. The respective channel enable pin must be toggled to reactivate the channel.
2. Retry mode: The channel is momentarily shut down upon reaching the current limit but reconnects briefly.

The programmable digital input/output channels integrate an internal mechanism to protect against kickback from inductive loads. Additionally, there is an external safeguard via a 60 VDC, 2 A Schottky diode (PMEG6020ER). Each of the 12 digital input channels uses a resistor divider setup consisting of a 680 kΩ and 100 kΩ resistor; this configuration scales down a 0 to 24 VDC input to a 0 to 3 VDC range. While the high-side switches function separately from the digital input channels, it is possible to read the status of the high-side switches via the digital input channels.

Ensure each channel does not exceed a maximum current of 500 mA to avoid potential damage or malfunctions in the programmable digital input/output channels.

The sketch below showcases using the programmable digital input/output channels of the Portenta Machine Control. This example shows how to transmit values on the programmable channels periodically and also read from them regularly.

Copy
1/*
2  Portenta Machine Control's Programmable Digital I/Os
3  Name: portenta_machine_control_programmable_digital_io_example.ino
4  Purpose: Demonstrates the usage of the programmable digital input/output channels
5  on the Portenta Machine Control. It includes initializing the channels, 
6  setting digital outputs, reading digital inputs, and toggling the outputs.
7  
8  @author Arduino PRO Content Team
9  @version 1.0 01/10/23
10*/
11
12#include <Arduino_PortentaMachineControl.h>
13
14void setup() {
15  // Initialize serial communication at 9600 bauds
16  Serial.begin(9600);
17  
18  // Initialize I2C communication
19  Wire.begin();
20  
21  // Wait for serial port to connect, needed for native USB port only
22  while (!Serial) {
23    ; 
24  }
25
26  // Attempt to initialize the programmable digital input/output channels
27  if (!MachineControl_DigitalProgrammables.begin()) {
28    Serial.println("- Failed to initialize the programmable digital I/Os!");
29    return;
30  }
31  Serial.println("- Programmable digital I/Os initialized successfully!");
32}
33
34void loop() {
35  // Turn ON the digital output channel 3 using the defined macro
36  MachineControl_DigitalProgrammables.set(IO_WRITE_CH_PIN_03, SWITCH_ON); 
37  delay(1000);
38
39  // Read the status of digital input channel 3 using the defined macro
40  int status = MachineControl_DigitalProgrammables.read(IO_READ_CH_PIN_03);
41  Serial.println("- Channel 03 status: " + String(status));
42  delay(1000);
43
44  // Turn ON all digital output channels
45  MachineControl_DigitalProgrammables.writeAll(SWITCH_ON_ALL);
46  delay(1000);
47
48  // Read and display the status of all digital input channels
49  uint32_t inputs = MachineControl_DigitalProgrammables.readAll();
50  for (int i = 0; i < 12; i++) {
51    Serial.println("- CH" + formatChannel(i) + ": " + String((inputs & (1 << i)) >> i));
52  }
53  Serial.println();
54
55  // Toggle the states of all digital output channels
56  MachineControl_DigitalProgrammables.toggle();
57  delay(1000);
58  inputs = MachineControl_DigitalProgrammables.readAll();
59  for (int i = 0; i < 12; i++) {
60    Serial.println("- CH" + formatChannel(i) + ": " + String((inputs & (1 << i)) >> i));
61  }
62  Serial.println();
63}
64
65/**
66  Formats the channel number with leading zeros to 
67  achieve a consistent 2-digit format
68
69  @param channel
70  @return A string with the channel number in 2-digit format
71*/
72String formatChannel(int channel) {
73  if(channel < 10) {
74    return "0" + String(channel);
75  }
76  return String(channel);
77}

The example sketch uses the following Arduino_PortentaMachineControl functions:

• MachineControl_DigitalProgrammables.begin()

  : Utilized to initialize the programmable digital input/output channels, it returns a

  FALSE

  if the initialization fails.

  MachineControl_DigitalProgrammables

  is based on the I2C protocol. To work properly, it must be preceded by

  Wire.begin()

  , which initializes the I2C interface.

• MachineControl_DigitalProgrammables.set(pin, state)

  : Used to define a particular channel's state (ON/OFF).

• MachineControl_DigitalProgrammables.read(pin)

  : Used to discern the state of a specific channel.

• MachineControl_DigitalProgrammables.writeAll(state)

  : Used to configure the state (ON/OFF) for all available pins or channels simultaneously.

• MachineControl_DigitalProgrammables.readAll()

  : Used to read the states of all available channels collectively.

• MachineControl_DigitalProgrammables.toggle()

  : Used to invert the states of all the channels.

Open the Serial Monitor to watch the I/Os states. The sketch will showcase the reading and state control process of the I/Os of the channels.

Communication

This user manual section covers the different communication interfaces and protocols the Portenta Machine Control supports, including the Ethernet, Wi-Fi®, Bluetooth®, RS-485, Modbus, and CAN Bus.

Ethernet

The Portenta Machine Control features an onboard low-power 10BASE-T/100BASE-TX Ethernet physical layer (PHY) transceiver. The transceiver complies with the IEEE 802.3 and 802.3u standards and supports communication with an Ethernet MAC through a standard RMII interface. The Ethernet transceiver is accessible through the onboard RJ45 connector.

The

Arduino Mbed OS Portenta Boards

Ethernet

The sketch below enables a Portenta Machine Control to connect to the Internet via an Ethernet connection. Once connected, it performs a

GET

ip-api.com

Arduino_JSON

Copy
1/**
2  Portenta's Machine Control Web Client (Ethernet version)
3  Name: portenta_machine_control_ethernet_web_client.ino
4  Purpose: This sketch connects a Portenta Machine Control
5  to ip-api.com via Ethernet and fetches IP details for 
6  the controller
7
8  @author Arduino PRO Content Team
9  @version 1.0 01/10/23
10*/
11
12// Include the necessary libraries
13#include <Ethernet.h>
14#include <Arduino_JSON.h>
15
16// Server address for ip-api.com
17const char* server = "ip-api.com";
18
19// API endpoint path to get IP details in JSON format
20String path = "/json/";
21
22// Static IP configuration for the Portenta Machine Control device
23// Used only if DHCP IP configuration fails
24IPAddress ip(10, 130, 22, 84);
25
26// Ethernet client instance for the communication
27EthernetClient client;
28
29// JSON variable to store and process the fetched data
30JSONVar doc;
31
32// Variable to ensure we fetch data only once
33bool dataFetched = false;
34
35void setup() {
36  // Initialize serial communication at 115200 bauds
37  Serial.begin(115200);
38
39  // Wait for the serial port to connect,
40  // This is necessary for boards that have native USB
41  while (!Serial);
42
43  // Attempt to start Ethernet connection via DHCP
44  // If DHCP failed, print a diagnostic message
45  if (Ethernet.begin() == 0) {
46    Serial.println("- Failed to configure Ethernet using DHCP!");
47
48    // Try to configure Ethernet with the predefined static IP address
49    Ethernet.begin(ip);
50  }
51  delay(2000);
52}
53
54void loop() {
55  // Ensure we haven't fetched data already
56  // ensure the Ethernet link is active
57  // establish a connection to the server
58  // compose and send the HTTP GET request
59  if (!dataFetched) {
60    if (Ethernet.linkStatus() == LinkON) {
61      if (client.connect(server, 80)) {
62        client.print("GET ");
63        client.print(path);
64        client.println(" HTTP/1.1");
65        client.print("Host: ");
66        client.println(server);
67        client.println("Connection: close");
68        client.println();
69
70        // Wait and skip the HTTP headers to get to the JSON data
71        char endOfHeaders[] = "\r\n\r\n";
72        client.find(endOfHeaders);
73
74        // Read and parse the JSON response
75        String payload = client.readString();
76        doc = JSON.parse(payload);
77
78        // Check if the parsing was successful
79        if (JSON.typeof(doc) == "undefined") {
80          Serial.println("- Parsing failed!");
81          return;
82        }
83
84        // Extract and print the IP details
85        Serial.println("*** IP Details:");
86        Serial.print("- IP Address: ");
87        Serial.println((const char*)doc["query"]);
88        Serial.print("- City: ");
89        Serial.println((const char*)doc["city"]);
90        Serial.print("- Region: ");
91        Serial.println((const char*)doc["regionName"]);
92        Serial.print("- Country: ");
93        Serial.println((const char*)doc["country"]);
94        Serial.println("");
95
96        // Mark data as fetched
97        dataFetched = true;
98      }
99      // Close the client connection once done
100      client.stop();
101    } else {
102      Serial.println("- Ethernet link disconnected!");
103    }
104  }
105}

The sketch includes the

Ethernet

Arduino_JSON

setup()

Once the Ethernet connection runs, the sketch connects to the

ip-api.com

HTTP GET

Within the

loop()

HTTP GET

ip-api.com

Key IP details such as IP address, city, region, and country are extracted and then displayed in the IDE's Serial Monitor using the parsed data. If the Ethernet link happens to be disconnected, a corresponding message is printed to the Serial Monitor. Should the JSON parsing fail, an error message is showcased on the IDE's Serial Monitor, prompting the sketch to exit the current iteration of the

loop()

You should see the following output in the Arduino IDE's Serial Monitor:

Wi-Fi®

The Portenta Machine Control features an onboard Wi-Fi® module that provides seamless wireless connectivity, allowing it to connect to Wi-Fi® networks and interact with other devices Over-The-Air (OTA).

Some of the key capabilities of Portenta's Machine Control onboard Wi-Fi® module are the following:

• Wireless connectivity: The onboard Wi-Fi® module supports IEEE 802.11b/g/n Wi-Fi® standards, enabling devices to establish reliable and high-speed wireless connections to access the Internet and communicate with other devices.
• Secure communication: The onboard module incorporates various security protocols such as WEP, WPA, WPA2, and WPA3, ensuring robust data encryption and protection against unauthorized access during wireless communication.
• Antenna connector: Portenta Machine Control devices feature an onboard vertical SMA antenna connector (5-1814832-2) specifically matched for the onboard Wi-Fi® module RF requirements.

The

Arduino Mbed OS Portenta Boards

WiFi

The sketch below enables a Portenta Machine Control device to connect to the Internet via Wi-Fi® (like the Ethernet example). Once connected, it performs a

GET

ip-api.com

Arduino_JSON

You need to create first a header file named

arduino_secrets.h

Put

arduino_secrets.h

Copy
1#define SECRET_SSID "YOUR_SSID"; // Your network SSID (name)
2#define SECRET_PASS "YOUR_PASS"; // Your network password (use for WPA, or use as key for WEP)

Replace

YOUR_SSID

YOUR_PASS

Copy
1/**
2  Portenta's Machine Control Web Client (Wi-Fi version)
3  Name: portenta_machine_control_wifi_web_client.ino
4  Purpose: This sketch connects a Portenta Machine Control 
5  to ip-api.com via Wi-Fi and fetches IP details
6
7  @author Arduino PRO Content Team
8  @version 1.0 01/10/23
9*/
10
11#include <WiFi.h>
12#include <Arduino_JSON.h>
13
14// Wi-Fi network details
15char ssid[] = SECRET_SSID;
16char password[] = SECRET_PASS;
17
18// Server address for ip-api.com
19const char* server = "ip-api.com";
20
21// API endpoint path to get IP details in JSON format
22String path = "/json";
23
24// Wi-Fi client instance for the communication
25WiFiClient client;
26
27// JSON variable to store and process the fetched data
28JSONVar doc;
29
30// Variable to ensure we fetch data only once
31bool dataFetched = false;
32
33void setup() {
34  // Initialize serial communication at 115200 bauds
35  Serial.begin(115200);
36
37  // Wait for the serial port to connect,
38  // this is necessary for boards that have native USB
39  while (!Serial);
40
41  // Start the Wi-Fi connection using the provided SSID and password
42  Serial.print("- Connecting to ");
43  Serial.println(ssid);
44  WiFi.begin(ssid, password);
45
46  while (WiFi.status() != WL_CONNECTED) {
47    delay(1000);
48    Serial.print(".");
49  }
50
51  Serial.println();
52  Serial.println("- Wi-Fi connected!");
53  Serial.print("- IP address: ");
54  Serial.println(WiFi.localIP());
55  Serial.println();
56}
57
58void loop() {
59  // Check if the IP details have been fetched;
60  // if not, call the function to fetch IP details,
61  // set the flag to true after fetching
62  if (!dataFetched) {
63    fetchIPDetails();
64    dataFetched = true;
65  }
66}
67
68/**
69  Fetch IP details from defined server
70
71  @param none
72  @return IP details
73*/
74void fetchIPDetails() {
75  if (client.connect(server, 80)) {
76    // Compose and send the HTTP GET request
77    client.print("GET ");
78    client.print(path);
79    client.println(" HTTP/1.1");
80    client.print("Host: ");
81    client.println(server);
82    client.println("Connection: close");
83    client.println();
84
85    // Wait and skip the HTTP headers to get to the JSON data
86    char endOfHeaders[] = "\r\n\r\n";
87    client.find(endOfHeaders);
88
89    // Read and parse the JSON response
90    String payload = client.readStringUntil('\n');
91    doc = JSON.parse(payload);
92
93    // Check if the parsing was successful
94    if (JSON.typeof(doc) == "undefined") {
95      Serial.println("- Parsing failed!");
96      return;
97    }
98
99    // Extract and print the IP details
100    Serial.println("*** IP Details:");
101    String query = doc["query"];
102    Serial.print("- IP Address: ");
103    Serial.println(query);
104    String city = doc["city"];
105    Serial.print("- City: ");
106    Serial.println(city);
107    String region = doc["regionName"];
108    Serial.print("- Region: ");
109    Serial.println(region);
110    String country = doc["country"];
111    Serial.print("- Country: ");
112    Serial.println(country);
113    Serial.println("");
114  } else {
115    Serial.println("- Failed to connect to server!");
116  }
117
118  // Close the client connection once done
119  client.stop();
120}

The sketch includes the

WiFi

Arduino_JSON

setup()

Once the Wi-Fi® connection is established, the sketch is ready to connect to the

ip-api.com

HTTP GET

GET

The

loop()

HTTP GET

JSON.parse()

Arduino_JSON

loop()

Since the data is fetched only once, there's no need to send

HTTP GET

Bluetooth®

The Portenta Machine Control features an onboard Bluetooth® module that provides seamless wireless connectivity, allowing it to connect to other Bluetooth® devices and networks.

To enable Bluetooth® communication on the Portenta Machine Control, you can use the ArduinoBLE library. Let's use an example code demonstrating some of the capabilities of Poternta's Machine Control Bluetooth® module. Here is an example of how to use the

ArduinoBLE

Copy
1/**
2  Portenta's Machine Control Bluetooth
3  Name: portenta_machine_control_bluetooth.ino
4  Purpose: Read temperature from a thermocouple input of 
5  the Portenta Machine Control, then exposes the temperature 
6  value using a Bluetooth standard service
7
8  @author Arduino PRO Content Team
9  @version 1.0 01/10/23
10*/
11
12#include <ArduinoBLE.h>
13#include <Arduino_PortentaMachineControl.h>
14
15
16// Define the environmental sensing service and its temperature characteristic
17BLEService temperatureService("181A");
18BLEIntCharacteristic temperatureIntChar("2A6E", BLERead | BLENotify);
19
20
21void setup() {
22  // Initialize the digital outputs terminals of the Portenta Machine Control 
23  MachineControl_DigitalOutputs.begin();
24
25  // Initialize serial communication at 9600 bauds
26  Serial.begin(9600);
27
28  // Initialize the Portenta's Machine Control BLE module
29  if (!BLE.begin()) {
30    Serial.println("- Starting BLE failed!");
31    while (1)
32      ;
33  }
34  
35  // Initialize temperature probes
36  MachineControl_TCTempProbe.begin();
37  
38  // Set the local name and advertised service for the BLE module
39  BLE.setLocalName("Temperature Sensor");
40  BLE.setAdvertisedService(temperatureService);
41  temperatureService.addCharacteristic(temperatureIntChar);
42  BLE.addService(temperatureService);
43
44  // Start advertising the BLE service
45  BLE.advertise();
46  Serial.println("- Bluetooth device active, waiting for connections...");
47}
48
49void loop() {
50  // Check for incoming BLE connections
51  BLEDevice central = BLE.central();
52
53  // If a central device is connected
54  if (central) {
55    Serial.print("- Connected to device: ");
56    Serial.println(central.address());
57
58    // Turn on a digital output channel of the Portenta Machine Control when connected
59    MachineControl_DigitalOutputs.write(0, HIGH);
60
61    // While the central device is connected
62    while (central.connected()) {
63      // Read the temperature from a type K thermocouple,
64      // update the BLE characteristic with the temperature value
65      MachineControl_TCTempProbe.selectChannel(0);
66      float temp_ch0 = MachineControl_TCTempProbe.readTemperature();
67
68      Serial.print("- Temperature is: ");
69      Serial.println(temp_ch0);
70      temperatureIntChar.writeValue(temp_ch0 * 100);
71
72      delay(1000);
73    }
74
75    Serial.print("- BLE not connected: ");
76    Serial.println(central.address());
77  }
78
79  // Digital output channel of the Portenta Machine Control
80  // blinks when Bluetooth® is not connected to an external device
81  MachineControl_DigitalOutputs.write(0, HIGH);
82  delay(200);
83  MachineControl_DigitalOutputs.write(0, LOW);
84  delay(200);
85}

The example sketch shown above uses a standard Bluetooth® Low Energy service and characteristic for transmitting temperature read by one of the thermocouple input terminals of the Portenta Machine Control to a central device.

• The sketch begins by importing all the necessary libraries and defining the Bluetooth® Low Energy service and characteristics.
• In the

  setup()

  function, the code initializes the Portenta Machine Control and sets up the Bluetooth® Low Energy service and characteristics. Then, it begins advertising the defined Bluetooth® Low Energy service.
• A Bluetooth® Low Energy connection is constantly verified in the

  loop()

  function; when a central device connects to the Portenta Machine Control, channel 0 of its digital output terminals is turned on. The sketch then enters into a loop that constantly reads the temperature from a thermocouple input terminal. The temperature is printed to the IDE's Serial Monitor and transmitted to the central device over the defined Bluetooth® Low Energy characteristic.

RS-485 (Half/Full Duplex)

The Portenta Machine Control has a built-in RS-485 interface that enables the implementation of robust and reliable data transmission systems. RS-485 interface is a protocol widely used in industrial applications. The wide common-mode range enables data transmission over longer cable lengths and in noisy environments such as the floor of a factory. Also, the high input impedance of the receivers allows more devices to be attached to the communication lines.

The onboard RS-485 transceiver is the SP335 from MaxLinear. The SP335 is an advanced multiprotocol transceiver that supports RS-232, RS-485, and RS-422 serial standards. Integrated cable termination and multiple configuration modes allow all three protocols to be used interchangeably over a single cable or connector with no additional switching components.

The Portenta Machine Control has onboard termination resistors; its RS-485 interface can be configured to be half-duplex or full-duplex.

Some of the key capabilities of Portenta's Machine Control onboard RS-485 transceiver are the following:

• High-speed operation: The RS-485 transceiver can operate up to 20 Mbps.
• EMI Reduction: The slew rate is limited to 250 kbps to minimize electromagnetic interference (EMI), enhancing signal integrity.
• ESD protection: Transmitter outputs and receiver inputs are protected against electrostatic discharge (ESD) up to ±15 kV.
• High impedance: The transceiver inputs exhibit high impedance, allowing up to 256 devices on a single communication bus.
• Communication mode: The transceiver can be configured either half or full-duplex.
• Termination resistors: 120 Ω termination resistors are integrated and can be connected or disconnected through software.

RS-485 data lines in the Portenta Machine Control are labeled as described in the following table:

TX+

Data+

TX-

Data-

RX+

RX-

RS-485 data line labels differ between manufacturers. Most manufacturers will use

+

–

D+

D-

A

B

A

B

-

A

+

B

The example sketch below shows how to use the RS-485 interface of the Portenta Machine Control for half-duplex communication.

Copy
1/*
2  Portenta Machine Control's RS-485 Half-Duplex Communication
3  Name: portenta_machine_control_rs485_example.ino
4  Purpose: Demonstrates half-duplex RS-485 communication using
5  the Portenta Machine Control.
6
7  @author Arduino PRO Content Team
8  @version 1.0 01/10/23
9*/
10
11// Include the necessary libraries
12#include <Arduino_PortentaMachineControl.h>
13
14// Define the interval for sending messages
15constexpr unsigned long sendInterval { 1000 };
16unsigned long sendNow { 0 };
17unsigned long counter { 0 }; 
18
19void setup() {
20    // Initialize serial communication at 9600 bauds
21    Serial.begin(9600);
22
23    // Wait for the serial port to connect,
24    //tThis is necessary for boards that have native USB
25    while (!Serial);
26
27    Serial.println("- Initializing RS-485 interface...");
28
29    // Initialize the RS-485 interface with a baud rate of 115200 and specific timings,
30    // the timings define the preamble and postamble durations for RS-485 communication
31    MachineControl_RS485Comm.begin(115200, 0, 500);
32
33    // Set the RS-485 interface in receive mode initially
34    MachineControl_RS485Comm.receive();
35    Serial.println("- RS-485 initialization complete!");
36}
37
38void loop() {
39  // Check if there is incoming data and read it
40  if (MachineControl_RS485Comm.available()) {
41    Serial.write(MachineControl_RS485Comm.read());
42  }
43
44  // Send data at defined intervals
45  if (millis() > sendNow) {
46    // Disable receive mode before starting the transmission
47    MachineControl_RS485Comm.noReceive();
48
49    // Begin transmission and send a message with a counter
50    MachineControl_RS485Comm.beginTransmission();
51    MachineControl_RS485Comm.print("- Message: ");
52    MachineControl_RS485Comm.println(counter++);
53
54    // End the transmission and switch back to receive mode
55    MachineControl_RS485Comm.endTransmission();
56    MachineControl_RS485Comm.receive();
57
58    // Update the time for the next transmission
59    sendNow = millis() + sendInterval;
60  }
61}

In this example sketch, a message is periodically sent over the RS-485 interface of the Portenta Machine Control. The sketch initializes the RS-485 interface for half-duplex communication and sends a

String

The example sketch uses the following functions from the

Arduino_PortentaMachineControl

• MachineControl_RS485Comm.begin(baud, pre, post)

  : Initializes the RS-485 module with specified baud rate and timing settings.

• MachineControl_RS485Comm.receive()

  : Puts the module in receive mode.

• MachineControl_RS485Comm.noReceive()

  : Disables receive mode for transmission.

• MachineControl_RS485Comm.beginTransmission()

  : Prepares the module to start transmitting data.

• MachineControl_RS485Comm.endTransmission()

  : Ends data transmission and prepares the module to receive data.

• MachineControl_RS485Comm.available()

  : Checks if data can be read.

• MachineControl_RS485Comm.read()

  : Reads incoming data.

To receive and show the messages on your computer, you can use a USB to RS-485 converter, such as the converter used by the Arduino Pro Content Team. You can use the Arduino IDE's Serial Monitor to display the messages received in the converter or another serial terminal such as CoolTerm, a simple and cross-platform (Windows, Mac, and Linux) serial port terminal application (no terminal emulation) that is geared towards hobbyists and professionals.

As a practical example, we will establish a full duplex communication between two Portenta Machine Control devices. Follow the wiring below for the RS-485 full-duplex communication.

For both Portenta Machine Control devices, use the example sketch shown below; this example sketch can also be found on the Arduino IDE by navigating to File > Examples > Arduino_PortentaMachineControl > RS485_fullduplex.

Copy
1/*
2 * Portenta Machine Control's RS-485 Full Duplex Communication
3 * Name: RS485_fullduplex.ino
4 * Purpose: Demonstrates full duplex RS-485 communication using
5 * the Portenta Machine Control; the sketch shows how to send 
6 * and receive data periodically on the RS-485 interface
7 *
8 * @author Riccardo Rizzo, modified by Arduino PRO Content Team
9 * @version 1.0 01/10/23
10 */
11
12// Include the necessary libraries
13#include "Arduino_PortentaMachineControl.h"
14
15// Define the interval for sending messages
16constexpr unsigned long sendInterval { 1000 };
17unsigned long sendNow { 0 };
18unsigned long counter = 0;
19
20void setup() {
21  // Initialize serial communication at 9600 bauds
22  // Wait for the serial port to connect
23  Serial.begin(9600);
24  while (!Serial);
25
26  Serial.println("- Start RS485 initialization...");
27
28  // Initialize the RS-485 interface with specific settings,
29  // specify baud rate, preamble and postamble times for RS-485 communication
30  MachineControl_RS485Comm.begin(115200, 0, 500);
31
32  // Enable full duplex mode and 120 Ohm termination resistors
33  MachineControl_RS485Comm.setFullDuplex(true);
34    
35  // Set the RS-485 interface in receive mode initially
36  MachineControl_RS485Comm.receive();
37    
38  Serial.println("- Initialization done!");
39}
40
41void loop() {
42  // Check if there is incoming data and read it
43  if (MachineControl_RS485Comm.available())
44    Serial.write(MachineControl_RS485Comm.read());
45
46  // Send data at defined intervals
47  if (millis() > sendNow) {
48    // Disable receive mode before starting the transmission
49    MachineControl_RS485Comm.noReceive();
50
51    // Begin transmission and send a message with a counter
52    MachineControl_RS485Comm.beginTransmission();
53    MachineControl_RS485Comm.print("- Hello ");
54    MachineControl_RS485Comm.println(counter++);
55
56    // End the transmission and switch back to receive mode
57    MachineControl_RS485Comm.endTransmission();
58        
59    // Re-enable receive mode after transmission
60    MachineControl_RS485Comm.receive();
61
62    // Update the time for the next transmission
63    sendNow = millis() + sendInterval;
64  }
65}

Both devices will send and receive messages respectively through the RS-485 interface and will print them in the IDE's Serial Monitor, as shown in the animation below.

Modbus (RTU/TCP)

The Portenta Machine Control incorporates a built-in Modbus interface, enabling the implementation of robust and reliable data transmission systems. Modbus, in its RTU version that operates RS-485 serial transmission or in its TCP version that works over Ethernet, remains one of the most widely used protocols for industrial automation applications, building management systems, and process control, among others.

The many nodes connected in a Modbus network, whether RTU or TCP, allow high flexibility and scalability in constructing automation and control systems.

To use the Modbus protocol with your Portenta Machine Control, you will need the

ArduinoRS485

ArduinoModbus

Modbus RTU

Modbus RTU, generally operating in half-duplex mode, with its capability to handle noisy and long-distance transmission lines, makes it an excellent choice for industrial environments. Modbus RTU communication is supported using Portenta's Machine Control RS-485 physical interface.

The Portenta Machine Control has onboard termination resistors; its RS-485 interface can be configured as a half or full duplex.

The example below shows how to enable Modbus RTU communication between a Portenta Machine Control device and an Opta™ device. For wiring both devices, follow the diagram below:

The following example sketch will let the Portenta Machine Control device toggle the four onboard Opta™ LEDs via Modbus RTU. The Portenta Machine Control will be the client, while the Opta™ device will be the server.

For the Opta™ device, defined as the server, use the following example sketch below.

Copy
1/*
2  Opta's Modbus RTU Server Example
3  Name: opta_modbus_rtu_server_led_control.ino
4  Purpose: Demonstrates controlling the onboard LEDs of an 
5  Opta device using the Modbus RTU protocol
6
7  @author Arduino PRO Content Team
8  @version 1.0 01/10/23
9*/
10
11// Include the necessary libraries 
12#include <ArduinoRS485.h>
13#include <ArduinoModbus.h>
14
15// Define the baud rate for Modbus communication
16constexpr auto baudrate{ 38400 };
17
18// Define the number of coils to control LEDs
19const int numCoils = 4;
20
21// Calculate preDelay and postDelay in microseconds as per Modbus RTU Specification
22// Modbus over serial line specification and implementation guide V1.02
23// Paragraph 2.5.1.1 Modbus Message RTU Framing
24// https://modbus.org/docs/Modbus_over_serial_line_V1_02.pdf
25constexpr auto bitduration{ 1.f / baudrate };
26constexpr auto preDelayBR{ bitduration * 9.6f * 3.5f * 1e6 };
27constexpr auto postDelayBR{ bitduration * 9.6f * 3.5f * 1e6 };
28
29void setup() {
30  // Initialize serial communication at 9600 bauds
31  Serial.begin(9600);
32
33  // Print a startup message
34  Serial.println("- Modbus RTU Server");
35
36  // Set RS485 transmission delays as per Modbus specification
37  RS485.setDelays(preDelayBR, postDelayBR);
38
39  // Start the Modbus RTU server with a specific slave ID and baud rate
40  // Halt execution if the server fails to start
41  if (!ModbusRTUServer.begin(1, baudrate, SERIAL_8N1)) {
42    Serial.println("- Failed to start Modbus RTU Server!");
43    while (1)
44      ;  
45  }
46
47  // Initialize the onboard LEDs 
48  pinMode(LED_D0, OUTPUT);
49  pinMode(LED_D1, OUTPUT);
50  pinMode(LED_D2, OUTPUT);
51  pinMode(LED_D3, OUTPUT);
52
53  // Configure coils for controlling the onboard LEDs
54  ModbusRTUServer.configureCoils(0x00, numCoils);
55}
56
57void loop() {
58  // Poll for Modbus RTU requests and process them
59  int packetReceived = ModbusRTUServer.poll();
60
61  if (packetReceived) {
62    // Process each coil's state and control LEDs accordingly
63    for (int i = 0; i < numCoils; i++) {
64      // Read coil value
65      // Update discrete input with the coil's state
66      int coilValue = ModbusRTUServer.coilRead(i);       
67      ModbusRTUServer.discreteInputWrite(i, coilValue);  
68
69      // Debug output to the IDE's serial monitor
70      Serial.print("- LED ");
71      Serial.print(i);
72      Serial.print(" : ");
73      Serial.println(coilValue);
74
75      // Control the onboard LEDs based on the coil values
76      switch (i) {
77        case 0:
78          digitalWrite(LED_D0, coilValue);
79          break;
80        case 1:
81          digitalWrite(LED_D1, coilValue);
82          break;
83        case 2:
84          digitalWrite(LED_D2, coilValue);
85          break;
86        case 3:
87          digitalWrite(LED_D3, coilValue);
88          // New line for better readability
89          Serial.println();  
90          break;
91        default:
92          // Error handling for unexpected coil addresses
93          Serial.println("- Output out of scope!"); 
94          break;
95      }
96    }
97  }
98}