https://community.element14.com/challenges-projects/design-challenges/on-the-line/A design challenge centred on adding intelligence to production lines, with projects that monitor processes, test products, and improve uptime through automation and data-driven control. Participants build and share practical industrial solutions, showingen-USTelligent Community 12https://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56981/smart-ventilation-motor-monitoring-system-1-the-project-and-the-received-kitsSun, 24 May 2026 12:37:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:5aa996e5-38a8-4ed6-b7c6-bf2de2ae34ebfyaocnTable of Contents Project Introduction: Why Ventilation Motors Need Smart Monitoring Core Goals of the System: ️ Hardware Deep Dive: The Brain and Sensors 1. Core Sensing Node: STEVAL-STWINKT1B 2. Peripheral Add-On: Industrial Connectivity How It Works: From Vibration Data to Predictive Insights Why This Project Fits the "On The Line" Challenge Next Steps & Updates 1 Project Introduction: Why Ventilation Motors Need Smart Monitoring THE project for the On The Line challenge is built around an intelligent edge monitoring system for industrial ventilation motors , with the STM STEVAL-STWINKT1B as industrial sensing node. Industrial ventilation motors are everywhere as of factories, data centers, and commercial buildings—but unexpected failures cause costly downtime, safety risks, and productivity hits. Traditional maintenance is often inefficient, reactive, or misses early signs of wear. That’s where this project comes in: a compact, smart monitoring node that keeps an eye on motor health in real time, with edge AI to spot faults before they escalate. Core Goals of the System: Real-time health tracking via vibration, temperature, and humidity sensing Edge AI-powered anomaly detection for predictive maintenance ️Early warning for common faults: bearing wear, rotor imbalance, overload, and more Seamless integration with existing infrastructure 2. Hardware Deep Dive and Labview: The Brain and Sensors The heart of this system is the STEVAL-STWINKT1B SensorTile wireless industrial node , which packs everything we need into a rugged, industrial-grade package. Core Sensing Node: STEVAL-STWINKT1B This kit is purpose-built for industrial IoT condition monitoring, and it’s perfect for this use case: MCU : STM32L4R9 (Cortex-M4, 120 MHz, ultra-low power) – handles sensor processing, edge AI inference, and communication with minimal power draw. Key Onboard Sensors : IIS3DWB : 3-axis high-bandwidth vibration sensor (up to 6 kHz) – Captures high-frequency vibration data critical for detecting bearing defects and rotor imbalance. ISM330DHCX : 6-axis IMU – adds auxiliary motion state analysis to cross-validate vibration readings and filter out environmental noise. CAN integration: Industrial Connectivity To hook into existing factory systems, paired the STWIN node with the Analog Devices MAX33041ESHLD CAN transceiver . This adds robust CAN bus support, a staple in industrial automation, so the monitoring node can send alerts and health data to information systems over the field bus. Smart Brain: Arduino Uno Q Acting as the central control and connectivity hub, the Arduino Uno Q adds a layer of flexible intelligence to the system. Role in the System : Receives pre-processed sensor data from the STWINKT1B over serial communication. Runs higher-level logic, including anomaly detection decision-making and fault classification. Manages communication with the CAN transceiver (MAX33041ESHLD) to send alerts and health data to industrial networks. Why Uno Q? Its robust ecosystem, ease of prototyping, and compatibility with industrial-grade add-ons make it perfect for rapidly developing and testing the system’s control logic, while the STWINKT1B handles the heavy lifting of high-frequency sensing. On the line - Online: LabVIEW : Real-Time Data Visualization Live plots of vibration, temperature/humidity trends, and motor health metrics. Alarms and color-coded indicators for fault conditions (bearing wear, imbalance, overload). On-Site Control & Logging The labview connects to the Arduino Uno Q over serial/USB, allowing on-site engineers to view live data, trigger manual checks, and adjust alert thresholds. Automated data logging to CSV files for post-analysis and predictive maintenance reporting. Rapid Prototyping with LabVIEW The trial version can quickly build the user interface and test communication with the Arduino and CAN bus without writing extensive low-level code. If availalbe, LabVIEW Machine Learning Toolkit can add a secondary layer of AI validation, cross-checking the edge AI results from the Arduino/STWINKT1B. 3 How It Works: From Vibration Data to Predictive Insights Here is the workflow: Continuous Sensing : The sample vibration, motion, temperature, and humidity data at high rates directly on the node and send with CAN bus. Edge AI Processing : Arduino Uno Q play as intelligent hub for smart processing. Alerting & Communication : When a fault is detected, the system triggers early warnings (via local status indicators or the CAN bus) to notify maintenance teams before a failure occurs. It also logs historical health data for trend analysis. 4 What for "On The Line" The "On The Line" challenge is all about building solutions that integrate seamlessly with existing industrial infrastructure, and this systemy: It uses the STWIN node’s industrial-grade sensors and low-power MCU for reliable, long-term operation on the factory floor. The CAN transceiver ensures compatibility with standard field bus networks, so it can drop into existing setups without a full overhaul. Edge AI brings predictive maintenance to the edge, solving a real pain point for facilities relying on aging ventilation equipment. 5 The kit received and Next Steps The kit is just arrived and as There are some parts not to be used in this project, and I shall try include as many as I can in next steps.https://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56950/1-electropolishing-station/235750Fri, 22 May 2026 14:51:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:53381770-9b74-422d-ad11-99947f8a802farvindsaLove your setup. A serious research setup. :)https://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56950/1-electropolishing-station/235743Fri, 22 May 2026 03:29:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:fc2ddc60-440b-4a1d-a842-c97d0d42b1eepandoramcThanks! I hope I meet your expectationshttps://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56950/1-electropolishing-station/235742Fri, 22 May 2026 03:28:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:29a66d12-5b92-46aa-8ecf-4aa682e4eba9pandoramcI work in embedded systems applications. Currently, I am carrying out electroplating and magnetic characterization with partners. In one of the labs, there is an equiment for vapour deposition, but I am not able at this moment for submerged arc technique. We are working to create a laboratory for designing equipment for specific applicationshttps://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56919/forum-2-interface-control-labview---ils/235661Tue, 19 May 2026 22:59:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:760defdd-2f3e-47b9-97f0-938010505c5dsaramicsearching the web, shows me that the Malaysian Element 14 does sell a 3 Month Pro subscription for 0.1 Malay Ringgit? 10 Malay cents? https://my.element14.com/ni-emerson/789550-35promo/labview-suite-download/dp/4178938 I presume there should be a similar download for participants of on-the-line challenge? any more information JoRatcliffe ?https://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56950/1-electropolishing-station/235651Tue, 19 May 2026 19:24:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:82c33eea-66db-4acb-9472-b06c0559c48eDABVery cool.https://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56950/1-electropolishing-station/235646Tue, 19 May 2026 16:53:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:4c0fb005-6938-4108-9c30-06ba2b7bfca8manojroy123Hi, I like your project. What is your background. Do you know anything about submerged arch graphene manufacturing.https://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56950/1-electropolishing-stationSun, 17 May 2026 23:35:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:3c30ed16-0690-4941-b48c-1578ba9fb9a5pandoramcIntroduction Electropolishing is an electrochemical process which objective is create a bright polish finished surface in conductive materials. The following video of ASTRO PAK shows the processing product in a metal. www.youtube.com/watch Video 1. Electropolishing process This method allows homogeneous processing of the surface. Moreover, the actual process seeks a polished surface in order to depose structured materials to create stable and regular crystals along a lattice. One of the challenges is the temperature rising during the polishing process. Since the process requires an electrical current between electrodes, the low resistance in the materials has a quasi-short circuit and the temperature in the fluid increases. The process depends on the current flow, voltage between the electrodes and the low temperature in an electrolyte available in the processing cell. Nowadays The actual electropolishing station is functional and is available in ESIQIE-IPN, a university in Mexico. Despite the functional operation, the terminal requires data traceability and process automation. These are required since long usage of the terminal raises the temperature in the cooling system. Figure 1. First electropolishing functional prototype One of the parameters to meet is when to turn on and turn off the compressor to avoid over temperature in the motor. On the other hand, the compressor must be operative if the temperature is not in a functional low temperature. Both temperatures in the system must be observed, the heat exchanger and the electrolyte. The temperature profiles will describe how the cell temperature changes during the process. If the cell does not work in the functional parameters, the polishing samples can be damaged. Figure 2. Electropolishing defects due parameter divergence Some of the parameters to work are current in the circuit, voltage in the cell, and temperature in the electrolyte. Furthermore, temperature observation is realized with an alcohol thermometer. The operator of the terminal must wait for the electrolyte achieves the temperature to start the operation; this requires additional assistance to activate and deactivate the current flow. Figure 3. Temperature tracking for operation starting Figure 4. Electrical parameters for polishing Only the cooling system requires about 30 minutes to reach the functional temperature. Once the cell has an acceptable temperature the current flow starts, the user stands for 6 minutes and stops the operation. This creates a polished surface, but it requires more process before the treatment. Figure 5. Aluminum sample without polising Figure 6. Aluminum sample after polishing process The future The challenge provided materials to work in the system incremental design. There are thermocouples to trace the temperature. But one of the challenges is have thermowell to avoid shot circuits and damage to the thermocouple. It is possible the signal conditioning by voltage/current transmitters or signal conditioner using PLC subsystems, but this could require additional communications as DeviceNet using CAN. On the other hand, temperature monitoring and decision taking will be aided by the Arduino UNO Q Board. Finally, the humidity sensor could track the refrigerant since it is composed of polyethylene glycol and distilled water (50%-50%) to avoid freezing in the thermal exchanger. We are ready to start new test and take new challenge to get a new polishing station. Figure 7. Temperature 4-20 mA transmitter Figure 8. Allen Bradlyy PLC with Themocouple conditioner and DeviceNet transceiverdesign challengeElectropolishingOn The Lineomegaarduino uno qhttps://community.element14.com/challenges-projects/design-challenges/on-the-line/m/managed-videos/151326Sun, 17 May 2026 23:35:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:608fd48c-381e-440d-b179-400f36b26ac8pandoramcThis is a microscopic section of stainless steel. The surface of this metal is flooded with electrolyte. When power is applied the phosphoric acid quickly forms a phosphate film on the surface that is very resistant to electrical current flow. The...ElectropolishingBeofre and after electropolishingMicroscopic view of electropolishingelcecchttps://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56960/on-the-line-challenge-developmentTue, 12 May 2026 19:30:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:04891c4a-b5d2-49f3-a985-5052db229a8fSensoredHacker0Well, there are officially 2 people using my Maintenance Protocol implementation in control applications. it enables treating PLCs like netowork peripherals. This means you can have the PLC, and get all the IO functionality, and program in whatever language you want. This is the design implementation Im shooting for with having an arduino act as a PLC. full operability with the PLC, HMI, client devices, or PC, offering all the busses and IO from the auduino. hows it going? Well, it was going great. Im learning more about the HMI. The downside of attaching the HMi to an arduino acting as a PLC is that 1, I have not implemented and API yet, and 2, That one has to define anything to begin with. The UNO Q isnt working out for me, but I really want that extra memory. where I do not have the extra memory, I have this issue of not having the registers ready to go. If I add 100 points to monitor, the arduino needs those registers ready to go when the HMI ask, or within 0.5 seconds, which is the hmi update timeout. fortunately, those registers only need to be available, they dont need real data in them. Im not sure if there is a method that would use minimal memory to respond with.... IDK theres a bunch of things to consider. this is the same on the PLC, but where Im implementing the arduino as a server, now I have to think about it. well, I dont mind having a sparse list. The HMI initialization always requies additional registers upon inclusion. The fc6a client library has no such requirements, it just reads values as they return, and or writes them, but it doesn't expect anything. The HMI isnt like that. if registers are defined, but not responding, the HMI is not going to initialize properly. Whats the point of this? One of the users here said something like you're going to have someone write PLC code with NV4 / windLDR, and arduino code, and some other PC code. ..? well, I understand that confusion. This is actually not the case. the PLC doesn't require code to be treated as a peripheral. in fact, it might work better without code on it. Thats been a pretty unpopular idea, and I dont want to get into it right now. The arduino here is just going to respond as a PLC would, with resulting IO from IO / buses as PLC registers. So, Im going to write the IO and bus functions, with a listener / debugger. Thats minimal ram. just defining the operations as PLC constructs is its own trouble. the idea now is to create a register buffer to whatever size I can manage, and populate it with arduino IO handlers. #include #include // Network config byte mac[] = { 0x00, 0x03, 0x7B, 0x20, 0xFE, 0xED }; byte ip[] = { 192, 168, 1, 50 }; EthernetServer server(2101); // Test register values uint16_t readDWord(int addr) { switch (addr) { case 158: return random(50, 101); // HMI test value case 560: return 26; // HMI expected value case 562: return 0; case 564: return 0; case 566: return 0; case 568: return 0; case 570: return 0; case 572: return 0; return 0; default: return 0; } } // BCC helpers byte xorBcc(byte *data, int len) { byte bcc = 0; for (int i = 0; i > 12) & 0xF]; tx[p++] = h[(v >> 8) & 0xF]; tx[p++] = h[(v >> 4) & 0xF]; tx[p++] = h[v & 0xF]; } byte bcc = xorBcc(tx, p); const char *h = "0123456789ABCDEF"; tx[p++] = h[(bcc >> 4) & 0xF]; tx[p++] = h[bcc & 0xF]; tx[p++] = '\r'; printHex("TX", tx, p); c.write(tx, p); } // Main handler void handle(EthernetClient c) { byte buf[64]; int len = 0; unsigned long lastRx = millis(); while (c.connected() && (millis() - lastRx = 14 && buf[0] == 0x05 && buf[4] == 'R' && buf[5] == 'D') { char a[5] = { (char)buf[6], (char)buf[7], (char)buf[8], (char)buf[9], 0 }; char l[3] = { (char)buf[10], (char)buf[11], 0 }; int addr = atoi(a); int nbytes = strtol(l, NULL, 16); Serial.print("READ D"); Serial.print(addr); Serial.print(" nbytes="); Serial.println(nbytes); replyReadD(c, addr, nbytes); } len = 0; } } } c.stop(); } void setup() { Serial.begin(9600); Ethernet.begin(mac, ip); delay(1000); server.begin(); randomSeed(analogRead(0)); Serial.print("Listening on "); Serial.print(Ethernet.localIP()); Serial.println(":2101"); } void loop() { EthernetClient client = server.available(); if (client) { Serial.println("Client connected"); handle(client); Serial.println("Client done"); } } LoL: what with the code block?industrialOn The Lineprogrammingarduinohttps://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56906/forum-1-introduction-industrial-line-sentinel-ils/235520Mon, 11 May 2026 03:39:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:ea3ca0ab-44bf-4e30-8dac-6f0269e0c884skruglewiczSo if I understand your running arduino ide on a Linux host and then flashing to the stm Mcu side of the UNO q. where that will work. you are under utilizing the dual brain MPU/MCU bridge architecture of the uno q but if works for you that’s all that matters. Nice idea..https://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56932/project-planing-and-more-arduino-uno-q-struggleMon, 11 May 2026 00:46:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:13f51f49-7a81-4795-b8d2-68f2ea4585ffSensoredHacker0An under discussed topic in PLC system design is documentation and register mapping. Unlike other systems, PLCs and their client devices, communicate with registers. Registers are blocks of memory, and data type effects the number of blocks used. No big deal youre thinking, everything is like that. And youre right! but PLCs map directly to memory locations. So when youre planning a project, you need to know the data types of every calculation, every step, and where every register will map to. Need? ok, maybe not need, but if you fail to define all the steps, want to add additional calcululations, or add features later, It is my sincere hope for you, that every register is mapped in a spreadsheet. PLCs dont play nice accross platforms typicaly. Youre forced to use a specific operating system, and reading the files output by any particular OEM software may not be readable outside the platform / software. I've learned this first hand, programing PLCs in Linux, without OEM support. So, I define my methods early. The very first thing I think about is what I call endian. How bits and bytes are packed into memory. PLCs only really know about Registers. Everything is a register. If you want to read a bit, that is a segment of a register. if you want to read a string, the number of registers is defined by the length of the string. Datatpyes like float, double, are 2, or 4 registers, and how you access those registers matters. When youre reading data, you need to know the starting registister, and what direction to read the succesive registers in. If youre not working in a larger orginazation, you can just pick something. if youre working in an enviornment where one order is perfered over the other, I'd reccommend keeping the pattern. What gets really confusing, is when the endain changes from one software to another. The next thing I do is define starting registers for multi-register datatypes. This is usialy even or odd numbers. While it is not critical, it is useful to be able to look at a block of registers, and know where variables start and end. For all my projects I put the first register for a multi-register datatypes on an even number. This makes keeping track of things easier in the long run. next, I would recommend, mapping your registers in a spreadsheet, or at least creating workspaces. I almost never do this at the start of a project, and I always wish I did. next I write out all my formulas, and the number of steps required to do an operation. You want to keep datatypes in mind, and how many registers each datatype uses. have to sum 3 numbers in ladder logic? Not so fast! You will have the option to sum 2 numbers, then store the result, and at 1 more number. Thats 4 registers if youre using words (16bit register) 8 if youre using floats, and 16 if youre using a double. Where does the temporary sum live? Do you put the final result in its own block of registers, or read the last step of the summing calculation? while its trivial initialy, for simple equations, or short programs, as your progams become more complex, keeping track of where every step in the process is becomes crucial. ################################################# In this project, the method I am using to read and write data to and from the Arduino is via an abstraction of performing operations on the arduino, then reporttng data back in 16bit registers. To do this, I need to know how the PLC expects to read the data I will provide from sensors and communication busses, and map it out accordingly, so the PLC / HMI or other devices in the PLC system can read it. Internaly, on the arduino, I have a bit more freedom to do things like read 3 registers at once, and sum them all in the same step. To ensure that process goes as smoothly as possible, I will now define my basic functionality. I am only going to support big endian for now. or the starting word is small, the the next numerical register is the upper byte(s) of the successive datatype. analogReadWord(pin,register) returns a single analog word to the register analogReadFloat(pin, register) returns 2 regisers to PLC digitalRead(pin, register) returns a bit, or bcd value to the PLC functions and operations: The PLC normaly does all the math, but its the arduino in this project. Fucntions should be declared with a datatpye in the name. I'll make some general purpose functions to convert from bits to words, words to floats, etc. The goal is to read data from the PLC / HMI, process it on the arduino, and return a PLC ready datatype. # For writing values back, beyond simple IO operations, I may need to track specific device details, like Rx, Tx, enable / disable, or status of specific sensors. This is where keeping a spreadsheet should be really helpful. Ideally, I would us the PLC to perform functions on the return values. but the PLCs, I have also have much more memory that the arduino I am using. PLCanlogWriteWord(output register, value) -> analog PLC device output. PLCdigitalWrite(output register, value) -> PLC output contacts PLCreadInputs(input register, value) -> PLC input status. PLCspecialNAME(register,value) -> functions defined for specific PLC internal functions. ## bus communication: bus coms suck on the PLC, but if its supported, Im not going to mess with it. This is bacnet, MQTT, Modbus, TCP and a couple others I never think about. SPI,i2C, and CAN are not supported on my PLC, so I will have to think about it eventualy. ## networking. Ok I just said Im leaving the PLC to handle specific communications, and my current deployment model is using ethernet. its reasonalble to think we could do both serail and TCP. NETWORK: 192.168.1.2 --PLC 192.168.1.10 --My computer 192.168.1.20 --HMI 192.168.1.50 --Arduino 192.168.1.7 --Opto22 Groov Rio ###Departure from conventional models. I like to plan these things out, but Im also not very patient. Normally, I would know what my project does, before I build it. Im trying to plan out tests, for compatibility, and use application, without knowing what the hiccups will be along the way. There could be a glitch in this plan. This is all very fringe, and niche theoretical. # I dont want the PLC to do anything except its special internal functions, control IO, and act as an interface. # The ARDUINO will to all the calculations, and handle its integrated busses / IO. # The ARDUINO will interface with all client IO, but im still going to treat the PLC like an output. ** better Go find some hardware. ############################ Well. I really tried to use the Arduino App Lab today. I took careful note of a few things. When you sign up to use the App Lab, it changes your system password. Mine was set, before running the app lab, so I noticed right away. Does this thing dial home or make an account on a remote server? God I hope not. Well, I rewrote my i2C rotary encoder code with Monitor.print. Aruino App Lab doesnt have find and replace, in the code editor, so that was tedious. It took forever to compile then still wouldn't communicate on a serial port inside the app. So then I wrote up a hello world sanity check. . it ran on the serial port, but was constantly disconnecting after every communication it disconnects. maybe there is something wrong in my implementation. Serial.print would open a connection and stay open. so maybe there is something where the Monitor is closing, or I can tell it to say open. the internet claims it is arduino-cli monitor -p /dev/ttyHS1 -b 115200 --watchhttps://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56930/it-works-arduino-as-a-plc-server/235516Sun, 10 May 2026 23:01:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:02848052-a34d-4aeb-8b24-8ca85efe8a7bsaramicwow great write - up, still trying to fully understand the implications of all these protocols and now you have added IDEC PLC — a programmable industrial controller made by Izumi Denki, programmed in ladder logic via their WindLDR software IDEC HMI — a touchscreen operator panel made by Izumi Denki, configured via their WindO/I-NV software, designed to display and interact with PLC register datahttps://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56930/it-works-arduino-as-a-plc-server/235506Sun, 10 May 2026 01:45:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:493a2a7d-c5b2-40cd-ad96-ad06d202e111kmikemooSensoredHacker0 Nice implementation. Good job! I liked the write up. I'm that beginner that couldn't fix the Ethernet shield. Keep it going!https://community.element14.com/challenges-projects/design-challenges/on-the-line/m/managed-videos/151312Sat, 09 May 2026 22:30:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:8418d35e-6320-4b0e-98ba-9f72929f03c3SensoredHacker0I wanted to use the UNO Q, but that thing is a pain in my butt. The initialization process is outlined in the NV4 embedded documentation. I'll post a github link to that in a little bit. The Gist: The HMI is looking for a date and time, before it ...plcHG2JOn the line design challengeelement14hmiHermon MainefarnellemersonidecQualcomBangor Makerspaceindustrial automationBangor Mainearduinohttps://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56930/it-works-arduino-as-a-plc-serverSat, 09 May 2026 22:29:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:fe340730-aab7-4370-b5d7-dfdd228ec22eSensoredHacker0www.youtube.com/watch Ok there are MANY ways to communicate with a PLC or HMI, or related devices. If youre not sure what a PLC is, allow me to paraphrase: Programmable Logic Controllers (PLCs) are industry-standard devices designed primarily for controlling high-voltage and industrial systems. Think of them as proprietary, industrial-grade Arduinos. They are not general-purpose computers, and often rely on obscure or archaic programming methods. First introduced in 1969, many PLCs still implement variations of Relay Control Logic (RCL), a system of representing electrical control diagrams that dates back over 160 years. PLCs are complex in their simplicity. While their core concepts remain consistent, OEMs implement a wide range of communication protocols to enable control and data exchange. Through investigation, clear similarities emerge across these protocols; however, a fully open standard that enables true interoperability between platforms does not yet exist. This lack of interoperability reinforces vendor lock-in. Once a system is built around a specific manufacturer’s ecosystem, future expansion becomes constrained by compatibility requirements. Even when more suitable or advanced components become available, the cost and complexity of redesigning the system discourages change. In practice, this often limits integration not only across different manufacturers, but even across product lines within the same OEM. This project explores the development of interoperable control systems using Arduino and Arduino-compatible devices to interface with and control PLCs. The goal is to investigate practical pathways toward more flexible, open, and adaptable industrial control architectures. #### Using the Arduino MEGA to Communicate with the HMI ############## The Arduino Mega is acting as an IDEC PLC so the IDEC HMI can connect to it over Ethernet to read and write read PLC data registers. The HMI expects the PLC at: 192.168.1.50:2101 The HMI initiates the connection, sends read requests, and waits for valid PLC-style replies. The HMI Has an initialization sequence where it first reads: Y-M-D-W-H-m-S as 16 bit data registers ( 16 bit words ) HMI -> connects to Arduino on TCP port 2101 HMI -> sends maintenance protocol read command MEGA -> replies with ACK + data HMI -> accepts data and updates screen ########## Wait What is Maintenance Protocol?? ######### Maintenace Protocol is one name for a UART style communication framing method. It follows the pattern: 05 ENQ / start of request 46 46 "FF" device number 30 "0" no continuation 52 "R" read command 44 "D" data register 30 31 35 38 "0158" = D158 30 32 "02" = read 2 bytes 32 44 BCC 0D carriage return / end of frame ########## I've never heard of such a thing! ########## Maintenance Protocol isnt one of the hot communication models at this time, but its use is wide spread across the IDEC product lines, and extends to other OEM and devices as well. There is documentation for the protocol, but its kind of chaotic. There are MANY documents, writen with varying levels of detail and quality. I happen to work with IDEC PLCs on a regular basis, and kinda just stumbled upon its use for a wide range of interesting applications. # How The protocol works:The protocol request pattern : ENQ = ACK/NAK DEVICE = FF/0:N #BYTE CONTINUATION = 1: wait for more instructions, or 0: don't. TYPE = Read / Write / Clear Datatype: bits, words, floats etc value=bytes varies based on datatype. checksum=BCC, an XOR operation on the sum of the data being requested. terminator = \verb|\0h| \\ # Then the server responds with: ACK/NAK = 06h / 15h indicating success or error DEVICE = Echo of the addressed device (FF / 1:N) STATUS = Execution result code (00 = OK, nonzero = error) DATA = Returned value; format depends on datatype (bit = 0/1, register = word/bytes) CONTINUATION = 1: more data follows, 0: final response CHECKSUM = BCC, XOR of all response bytes excluding ENQ and terminator TERMINATOR = \0d (carriage return) Sending Method work in both ASCII and HEXADECIMAL ########### Where are the DOCS?? ######## Im working on it. ###### Where is the source?? ########## Well, it exists, and I could share it, but its not like human readable, or even extensible for other functions yet. Ill post something when I have a more friendly interface. ###### TODO:: ################## * Write interfaces to Analog / Digital IO, I2C, SPI, and CAN to return registers * Write proper functions, and a human usable library. * Do more testing. *write a wrapper for Serial on arduino ####### PONIES ( Dreaming ) ######## I could Make: an automated system installer ( I already did this, but it uses a PC to run ) a Unit State Emulator a full system debuger use of any product compatible with Arduino, or IDEC in the same project code in C on a PLC Code in Python on a PLC. use the arduino as an IoT compatibility layer. any device or tool that was previously unavailable, or prohibithively expensive, using open scource design patterns. ##### Arduino UNO Q ############ TL;DR: the Arduino Uno Q isn't even an Arduino anymore, let alone an UNO. I originally intended to do this on the Arduino Uno Q, because on paper it actually looks amazing. It is basically a Linux SBC disguised as an Arduino. You get analog IO, shield compatibility, Linux, networking, and a lot of potential flexibility in one package. Unfortunately, using it for this particular project became increasingly impractical. That did not stop me from sinking about 12 hours of my precious free time into trying to make the thing cooperate. I am really trying not to crash out on the Uno Q, because there are things I genuinely like about it. The hardware concept is cool. The fact that it can run Linux while, still exposing Arduino-style hardware interfaces opens up a lot of interesting possibilities. I absolutely plan to use it for future projects. But for this project specifically, it fought me every step of the way. I only had to edit one Ethernet shield library source file to get the Ethernet shield working. That is not a huge obstacle for me personally, but it is absolutely a showstopper for a beginner. A beginner is going to plug in an Ethernet shield, compile an example, watch it fail, and assume either the board or the shield is defective. Then there is the Serial library. They changed the Serial behavior in a way that breaks a massive amount of existing Arduino code and examples. Yes, technically I can fix it. I probably will fix it by writing a wrapper or adding some compatibility macros. But that is not really the point. There are decades worth of code examples, tutorials, forum posts, libraries, videos, blogs, and existing user knowledge built around the traditional Arduino Serial behavior. Breaking that compatibility without providing a transparent compatibility layer creates a huge amount of unnecessary grief. So you end up in this bizarre situation where you have an Arduino that does not run Arduino code. It would be funnier if I were not trying to actually use the thing. The larger issue for me, is that I was trying to rapidly prototype a very specific industrial communication project using an existing knowledge base. I was not trying to stop in the middle of the project and learn an entirely new workflow that breaks the old one. In fact, that is the antithesis of what I was trying to accomplish. The goal here is to emulate an IDEC PLC well enough that an IDEC HMI would accept the Arduino as a real controller over maintenance protocol Ethernet communications. That required focusing on protocol behavior, packet structure, BCC generation, register mapping, and HMI polling patterns, not debugging framework compatibility problems on a brand new board ecosystem. So in the end, I went back to the Arduino Mega, implemented a sparse register map to conserve RAM, and got the HMI fully communicating over TCP port 2101 using maintenance protocol emulation.megaplcdesign challengeOn the line design challengehmiprogrammingidecindustrial automationuno qarduinohttps://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56919/forum-2-interface-control-labview---ils/235483Sat, 09 May 2026 04:34:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:0facbacc-732a-43bb-ac1c-428af8f99815shreaypatelHey thanks for putting together such an awesome collection of resources! I was wondering if you ended up figuring out how to get the 3 month labview trial to work.https://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56905/on-the-line-challenge-accepted/235479Sat, 09 May 2026 01:34:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:e1cc8a5b-a149-4ba9-acdc-6f3c0856651ckmikemooLooking forward to your progress.https://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56906/forum-1-introduction-industrial-line-sentinel-ils/235477Sat, 09 May 2026 01:23:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:bee66461-604f-457d-9d5f-443ed9ec763akmikemooskruglewicz That's great information - especially since I would have been trying to use my UNO R4. Not to worry... I try to stay up with as much of what goes on in the Community as I can. I actually read what people write. I don't always understand it all... but I try to learn from it. The connecting links are always handy. ☺https://community.element14.com/challenges-projects/design-challenges/on-the-line/f/forum/56906/forum-1-introduction-industrial-line-sentinel-ils/235473Fri, 08 May 2026 20:56:00 GMT93d5dcb4-84c2-446f-b2cb-99731719e767:093cc0a3-49de-4288-9cab-ecd762921b30SensoredHacker0Hi Skruglewicz, Im just using the Arduino IDE version 2.3.8. though frequently Ill type it in Geany, then put it into the Arduino IDE. Im not a fan of these fancy IDEs with 1000 options, and things that change my text as im typing, highlight all my typos... or whatever. its all very distracting. Ive made geany run a build macro to compile / build arduino code.