Industrial IoT Control with Arduino Portenta Machine Control

The EBM Papst CGC Fan Control unit is powered from the 24V rail and takes a 0 – 10V control signal from the PMC Analogue Output channel. All grounds are connected to the common GND rail.

Fan Controller connections:

The EBM Papst Fan, rated at 67W, connects directly to the 24V rail and common GND. It takes an Open Collector PWM control signal from the Fan Controller. There is also an Open Collector PWM tacho output that can be used to sense the fan speed, but we left this unconnected.

Fan Connections:

Step 2: Programming Environment

The Arduino IDE 2.0 version environment was downloaded and installed on a PC running Debian Linux, but it is also available for Windows and Mac OS. The PMC is compatible with the other Arduino environments and 3rd party ARM IDE’s.

To get the IDE to run, we had to change ownership to root and enable the setuid bit on the chrome-sandbox sub-directory of the Arduino-ide installation:

cd ~/arduino-ide_2.0.0-rc3_Linux_64bit
sudo chown root:root chrome-sandbox
sudo chmod 4755 chrome-sandbox

Arduino provides a custom library for the PMC – Arduino_MachineControl, which can be installed from the library manager or GitHub download.

There are several MQTT clients available which will run on the Portenta, including Arduino’s ArduinoMqttClient, but we had issues re-starting a connection if the client disconnected for some reason. In the end, the PubSubClient library proved reliable, so we used that for our MQTT client.

The same goes for JSON parsers. There are several to choose from, including Arduino_JSON, which is in Beta and doesn’t run for long periods without issues. We found the Arduino_JSON library to be very reliable and excellently documented.

Step 3: WiFi

The attached Portenta H7 module has a Murata 1DX dual WiFi and Bluetooth 5.1 onboard wireless module with the antenna connection brought out to an SMA connector on the front of the PCM board. You need to add a 2.4GHz SMA antenna as this does not come with the product.

The following standard code used in the main loop gave a reliable network connection which would reconnect if there were any network connectivity issues:

 if (WiFi.status() != WL_CONNECTED) {
    // Wifi.begin blocks until connect or failure timeout
    WiFi.begin(ssid, pass);
    delay(10000);
  }

Tip: We needed to use a hardcoded IP address for servers on our LAN, but hostnames worked for external addresses.

Step 4: MQTT

Maintaining a reliable MQTT connection proved to be the most difficult part of the project. We started by trying Arduino’s own MQTT client library but couldn’t get it to reconnect if the connection timed out and was disconnected.

After several attempts, we switched to the more mature PubSubClient library, which also had reconnection issues. In the end, we forced a disconnect if there were any connection errors, which is not ideal but proved to be very reliable.

The MQTT connection is tested each time through the main loop so that it will reconnect, followed by the polling loop to keep the connection alive:

 if (!mqttClient.connected()) {
    connectMQTT();
  }
  mqttClient.loop();

The connectMQTT function has the vital disconnect call followed by a delay if the connection fails. Once a connection is established, the client subscribes to the topic:

void connectMQTT() {
  if ((WiFi.status() == WL_CONNECTED) && (!mqttClient.connected())) {
    if (!mqttClient.connect("MCP01")) {
      mqttClient.disconnect();
      delay(10000);
    }
    else {
      mqttClient.subscribe(topic);
    }

Step 5: JSON Message

The remote MQTT server publishes a range of environmental data from its connected sensors, including temperature, humidity, CO2 and TVOC levels, and particulate concentrations. We chose to consume the whole JSON payload and extract just the CO2 level to control the fan.

Our JSON payload is reasonably complex, but with 8MB of RAM the PMC can handle the whole payload without any filtering code. Our payload looks like this when prettified:

{
	"hardwareId": "29616ce7",
	"thv": {
		"vocIndex": 97,
		"temperature": 24.0,
		"humidity": 40.1,
		"sensor": "THV0.2"
	},
	"pm": {
		"sensor": "PM20.2",
		"pm1.0": 2,
		"pm2.5": 4,
		"pm4.0": 6,
		"pm10": 7
	},
	"geohash": "77406",
	"co2": {
		"sensor": "CO20.2",
		"co2": 928
	}
}

The MQTT message is handled in a callback function. We used the ArduinoJSON library to create a JSON document before deserialising it and copying the CO2 value to a global variable for use later. A static JSON document was created since the PMC has plenty of memory headroom for our example. Still, it is also possible to use a dynamic document for much larger payloads.

Tip: Use the online ArduinoJson help tool to calculate the correct document buffer size for your implementation

void callback(char* topic, byte * payload, unsigned int length) {
  StaticJsonDocument<BUFFER_SIZE> doc;
  DeserializationError error = deserializeJson(doc, payload, length);
  if (error) {
    Serial.println(error.c_str());
    return;
  }
  co2 = doc["co2"]["co2"];
}

Step 6: Fan speed mapping

Once the CO2 level is extracted from the message payload, it can be mapped to an analogue voltage output as a control signal for the Fan Controller.

Arduino provides the Arduino_MachineControl library which wraps all the I/O functionality making it easy to work with from your code.

We sanitised the CO2 level before returning a valid voltage level between 0 – 10V. A built-in linear mapping function converts the input to a voltage level. The CO2 level at which the fan turns on is controlled by setting the minimum input value:

float mapInput(long input, long min_in, long max_in) {
  if (input < min_in) {
    input = min_in;
  }
  if (input > max_in) {
    input = max_in;
  }
  return (float)map(input, min_in, max_in, 0, MAX_VOLTAGE);
}

Setting the analogue output is done with the PMC library function analog_out.write() which takes the output channel (0 – 3) and voltage level as inputs:

float updateAnalogOut(int channel, float input) {
…
  float volts = input;
  analog_out.write(channel, volts);
  return volts;
}

Papst supplies a Windows-compatible configuration application for their Fan Controller module. It can be used to create custom fan speed maps and ramping profiles.

You attach the Fan Controller to a PC using a supplied custom USB cable which you can use to read and write mappings to the device.

Our default map ramps the fan speed linearly from 0 up to 50% maximum speed at 10V. Each Fan Controller can control up to 16 fans, and there are 4 PCM Analogue output channels, so that’s a maximum of 64 fans in this configuration without additional circuits.

Step 7: Programming

Programming the PMC is done by connecting the micro-USB connector mounted on the front of the PCB to the PC running the Arduino IDE. This provides sufficient power to flash the chip and test the code without the 24V supply. The USB cable is not supplied with the product.

You select the Portenta core in the IDE and the port it is connected to before uploading the binary. Any serial output is displayed in the Serial Monitor of the IDE.

There’s also an option to install Lauterbach’s powerful TRACE32 debugger software after obtaining a free licence key by registering your product.

Summary

The Portenta Machine Control is designed to enhance the intelligence of your products by adding Industrial IoT capabilities to standalone industrial machinery. It enables real-time data collection from the factory floor and supports the remote control of equipment from LAN or cloud.

This project has shown how to add remote sensing from an MQTT server to a fan control system using the PMC’s Analogue Outputs, which is just one example of the many capabilities of the Portenta Machine Control.

The full project code is available for download from the OKdo GitHub repo.

Portenta Machine Control is very well documented and comes with an ever-expanding list of example code – for further details, visit the Arduino product page  (222-6773) .