Evolution of Programmable Boards as a Response to Market Changes and Technological Paradigm Developments

Abstract

This article examines the evolution of programmable development boards in the context of dynamic market and technological changes, as well as new approaches to embedded system design. It presents the history of evaluation board development and its impact on engineering, emphasizing the shift from closed ecosystems to open-source software. Particular attention is paid to the role of open source and modular architectures in shaping modern solutions. An important component of this paper is the description of the original OpenCPLC evaluation system, dedicated to microcomputer control systems. The OpenCPLC project illustrates how a layered design approach can increase the flexibility and range of PLC applications in both industry and education. The evolution of development boards indicates a clear trend in which openness and modularity are becoming key factors in determining the future of embedded systems.

1. Introduction

Programmable logic boards, also known as development or evaluation boards, have played a crucial role in the development of embedded systems since the dawn of microelectronics [1,2,3]. They are an indispensable tool in the design process, especially in the early stages, and also serve educational and demonstration purposes. Their development did not proceed in isolation but was closely linked to the evolution of microcontrollers and the programming tools that enable their programming [4,5,6]. These boards resulted from technological advances in microcontrollers and available tools rather than being a standalone development. This is consistent with the dynamically changing technology, growing engineers’ needs, and market demands [6].

In the world of technology, programming is becoming increasingly complex (often at the request of the developers themselves) [4,7]. Sometimes, the complexity of an application is disproportionate to the problem it solves or the value it delivers. The expectation is that new solutions should be as simple as possible, the interface should be intuitive, and the technological effort minimal. Well-known tools such as Visual Studio Code, the Git version control system, and the C language are used, which, despite its advanced age, is still the number one language among embedded system developers [8,9].

As microprocessor systems have developed, the profile of engineers dealing with their software in automation system applications has changed. In the past, when programmers were few and automation was primarily handled by electricians, designing the ladder logic (LAD) language was a bull’s-eye. It was based on the logic known from electrical systems. Today, the situation is reversed: C code is often more readable for engineering graduates than a logic tree composed of contacts and coils. It should be noted that C was created as a general-purpose language, which is why it is characterized by great versatility, especially compared to the sandboxes provided by PLC manufacturers [10].

These tools have evolved from the early 1970s to the present day [6,7,11]. The market is currently dominated by PLC-based systems that require specialized software and complex hardware. On the other hand, the widespread use of microprocessor systems is leading to the emergence of increasingly affordable and easily programmable embedded systems. One of them is the OpenCPLC system developed by the authors. It can be used in both engineering education and industrial applications.

The aim of this paper is to present the original OpenCPLC project concept, along with a sample application as the next step in the evaluation board development. The capabilities of the developed runtime environment are demonstrated and examples of its practical application are presented. In order to show the ways of evaluating microprocessor systems, a short history of such systems is also given. In contrast to the classical paper [6], the evaluation boards are the main focus considered in the first part of this paper.

The structure of this paper is designed to guide the reader step by step through the evolution of programmable boards (Figure 1):

Figure 1. Progress in development board design.

• The birth of microprocessors—the beginnings of the development of integrated circuits and the first test boards.
• Early development of microprocessor technology—more advanced evaluation boards and the first design support tools.
• The beginnings of the C language and IDE—higher-level programming languages and integrated development environments.
• Further development of microcontrollers—increasing integration of peripherals and the emergence of the ARM architecture.
• Minimalism and open standards—a new philosophy of simplicity, accessibility, and knowledge sharing.
• SoC systems—strong integration of multiple functions in one a single system.

The final part of the paper covers two issues:

• PLC controllers: their specificity, standards and applications in automation.
• OpenCPLC Project: an open-source combination of development boards with PLC functionality.

Early computers (e.g., IBM) and later microcomputers (e.g., Raspberry Pi), designed to run operating systems and FPGAs can also be considered evaluation boards and are undoubtedly part of embedded systems [12,13]. However, this article ignores this topic to focus solely on microcontrollers.

Section 2 provides information on the history of microprocessor systems. Section 3 presents the concept of using open-source software. Section 4 discusses System-on-Chip systems, and Section 5 presents the results of a historical analysis. Section 6 describes PLC systems, and Section 7 presents the proprietary OpenCPLC controller. Section 8 presents a selected control application using the OpenCPLC controller.

2. A Bit of History

2.1. The Birth of Microprocessors

The early 1970s saw the beginning of microprocessor development. The first to appear was the 4-bit Intel 4004, an arithmetic logic unit (ALU) requiring additional external circuitry, such as I/O controllers, RAM (Random Access Memory), and ROM (Read-Only Memory). Programming was performed by storing the program in ROM, which was permanently programmed during the manufacturing process. Logic diagrams were often designed using punched cards.

In subsequent years, more integrated systems, which could be described as microcontrollers, began to appear on the market because they contained RAM and ROM memories, eliminating the need for external modules. Examples of such systems include the TMS 1000 from Texas Instruments and the 8-bit Intel 8048, which also featured a hardware timer. These were programmed in assembler using simple terminals. The use of EEPROM (Electrically Erasable Programmable Read-Only Memory) allowed for multiple programming without replacing the chip, facilitating quick code modifications.

Figure 2 presents views of cases of the microprocessors Intel 4004 (Figure 2a) and Intel 8048 (Figure 2b) (Intel Santa Clara, CA, USA), whereas Figure 3 shows views of development boards included in these microprocessors.

Figure 2. Microprocessor Intel 4004 (a) and microcontroller 8048 (b).

Figure 3. Development boards: (a) MCS-4 with Intel 4004; (b) iSBC-80/10 with 8048 microcontroller.

As shown in Figure 2a, Intel 4004 contains only 16 pins. In contrast, Figure 2b shows that Intel 8048 contains 40 pins.

Figure 3 shows that development boards of both the considered microprocessors have large dimensions. These boards contain many ICs. For Intel 4004 (MCS-4 board) it is up to 40 ICs, whereas for Intel 8048 (iSBC-80/10 board)—over 55 ICs. Both boards contain edge connectors to connect to other components of the computer system.

At that time, development boards were not perceived as tools for learning or experimenting, but as key tools aimed at streamlining the implementation of specific projects, and their functionality was similar to the microcontroller itself.

2.2. Early Development of Microprocessor Technology

It was quickly recognized that a technological revolution was coming, and that microcontroller-based technologies, developed since the 1970s, had significant potential for further development and improvement. Therefore, a need arose to present their functionality to a wider audience. In response, development boards began to be designed as more sophisticated and comprehensive products, intended for engineers and electronics specialists from various industries.

The groundbreaking prototype design, the SDK-85 (Intel Santa Clara, CA, USA) [14] with an Intel 8085 microprocessor (Figure 4), provided a comprehensive test environment. It enabled assembly language programming both via an external terminal connected via a 20 mA current loop interface and via the built-in keyboard and display. This was particularly important at a time when computerization was still limited, and this option proved more ergonomic for most engineers. Furthermore, the keyboard and display could be used directly from the application. The SDK-85 development board also featured:

• System clock 3 MHz;
• RAM memory 256 B/512 B;
• EPROM memory 2 kB/4 kB;
• 14-bit programmable timer;
• 22 I/O lines (+16 I/O with expansion).

Figure 4. SDK-85 development board with 8085 microprocessor.

As shown in Figure 4, the SDK-85 board contains the indispensable components of the microprocessor system together with some peripherals, like the display and the keyboard. This board also contains a place to assemble other peripherals indispensable in applications using such microprocessor system.

Following Intel’s lead, other manufacturers also introduced their own development boards, including:

• Zilog ZDS Z80 (Zilog Inc., Milpitas, CA, USA);
• Motorola M68HC11 Evaluation Board (Motorola, Chicago, IL USA);
• National Semiconductor SC/MP II (National Semiconductor, Santa Clara, CA, USA);
• Texas Instruments TMS 9900 (Texas Instruments, Dallas, TX, USA);
• MOS Technology KIM-1 (MOS Technology, Hsinchu, Taiwan).

However, none of them achieved the success of SDK-85, primarily due to their late introduction to the market. Intel introduced SDK-85 in 1976, and in 1980, an improved version, SDK-86, which supported operating systems. Competing solutions appeared later, significantly limiting their market advantage.

2.3. The Beginnings of the C Language and IDE

The 1980s saw the emergence of the first microcontrollers supporting the C language, significantly facilitating software development in embedded systems. One of the pioneers was the Intel 8051, which, in conjunction with the EVK-51 development board, gained popularity thanks to the Keil C51 (Keil Elektronik GmbH, Leipzig, Germany) ecosystem [15]. This package integrated key tools, including a compiler, debugger, and programmers such as the Willem EPROM Programmer, enabling data to be written to the microcontroller’s memory using the ISP (In-System Programming) method, and in later versions also via UART (RS-232) (Universal Asynchronous Receiver/Transmitter).

However, in the late 1990s, thanks to broader support for various architectures, IAR Embedded Workbench [16] gained increasing popularity. This tool, although based on similar assumptions, met more standards, which made it the preferred choice for industrial, medical, and automotive applications. Later, Keil refreshed and expanded its IDE (Integrated Development Environment), which in the following years adopted the name µVision, strengthening its position, especially in systems based on ARM microcontrollers.

Early embedded systems engineers desired tools that would enable quick and convenient software development without the need to manually configure numerous, separate components. The first IDEs were characterized by full integration, high stability, and technical support, which contributed to their market dominance.

The introduction of C to embedded systems significantly facilitated software development, providing both low-level control over hardware and code portability across different architectures [17]. Thanks to its efficiency, flexibility, and established position as the first widely used language in this field, C remains the dominant standard in microcontroller programming.

2.4. Further Development of Microcontrollers

In the mid-1980s, a clear division emerged between CPUs (Central Processing Units) and MCUs (Microcontroller Units). Microprocessors were developed for personal computers and operating systems, while microcontrollers integrated a growing number of peripherals onto a single chip, such as analog-to-digital converters (ADCs) and digital-to-analog converters (DACs), comparators, serial peripheral interfaces (SPIs), UARTs, and I²Cs (Inter-Integrated Circuits), as well as advanced phase-locked loop (PLL) clocking (Table 1). Today, many of these features have become standard and are integrated into most general-purpose MCU designs, eliminating the need for many external components, including on demonstration boards.

Table 1. Breakthrough microprocessors where new functionality became standard and those that gained widespread popularity (including development board).

Year	MPU or SoC	Peripheries and Special Features	Devboard
1976	Intel 8048	RAM + ROM + Timer	Intel MCS-48 Dev Kit
1976	Intel 8051	Interface UART	Keil MCB51
1978	Texas Instruments TMS770C	ADC (10-bit) converter	TMS770C Development Kit
1979	National Semiconductor COP420	Analog comparator	COP420 Evaluation Kit
1980	Motorola 68HC05	Interface SPI	Motorola 68HC05 EVB
1982	Intel 8096	Generator PWM	Intel 8096 Evaluation Board
1985	Philips 8051XA	Interface I2C	Keil MCB51 (dla 8051)
1986	Atmel AT89C51	Compatible with Intel 8051, popular in education	Atmel AT89C51 Development Kit
1987	Motorola MC68HC11	PLL	Motorola MC68HC11 EVB
1991	Motorola MC68HC16	DAC	-
1992	Freescale MC68HC05 × 4	Interface CAN	-
2000	Philips LPC2000	32-bit, popular	LPC2148 Olimex
2004	Microchip PIC18F4550	Interface USB	PICDEM FS USB (Microchip)
2007	Microchip PIC18F97J60	Interface Ethernet	Microchip Ethernet Starter Kit
2008	Atmel ATmega328P	Popular	Arduino Uno
2012	Nordic nRF51	Bluetooth	Nordic nRF51 DK
2013	Infineon AURIX TC2xx	ADAS vehicle control	AURIX TC2xx Triboard
2014	ESP8266 (Espressif)	Wi-Fi	ESP8266 NodeMCU
2016	ESP32 (Espressif)	2 × Wi-Fi + Bluetooth	ESP32 DevKit V1 (DOIT)
2019	STM32H7	AI-ready	STM32H7 Nucleo
2020	STM32WLE5	LoRa	STM32WLE5 Nucleo

Designed for use with “full-fledged” microcontrollers were boards from the PICDEM series [18] (Figure 5a) from Microchip Technology (Santa Clara, CA, USA) and the STK500 series [19] (Figure 5b) for Atmel AVR systems. Aimed primarily at professionals and students at technical universities specializing in embedded systems, they offered a wide range of interfaces, connectors, and test elements, such as LEDs, buttons, potentiometers, buzzers, displays, and a prototyping area. This enabled rapid implementation and testing of new solutions. The use of sockets allowed for work with various microcontroller models, providing flexibility in system selection. These boards were representative examples of solutions of their era, playing a significant role in education and the professional development of embedded systems.

Figure 5. Development Boards (a) Microchip PICDEM 2 (b) Atmel STK500.

They used dedicated programming interfaces: Microchip’s ICSP, Atmel’s ISP, and JTAG (Joint Test Action Group), which first became an open standard for programming and debugging. It quickly gained popularity, and most modern processors and microcontrollers now incorporate it.

With the emergence of the first advanced editors with modular architectures (enabling the integration of custom solutions), microcontroller manufacturers of the period decided to utilize them. Microchip adapted Net-Beans to create MPLAB, while Atmel based its environment on Visual Studio, developing AVR Studio, which later evolved into Atmel Studio. Despite widespread support, these never achieved the popularity of the solutions that preceded and followed.

Although AVR and PIC microcontrollers perfectly met market needs, it was quickly recognized that a more efficient approach was to separate core development, licensed from ARM, from peripheral design by microcontroller manufacturers. This model contributed to the growing dominance of ARM processors in the late 20th century, as microcontrollers gained increasing industrial importance. The first ARM7-based microcontrollers combined high performance with energy efficiency. Among the pioneers were the LPC2000 from Philips (now NXP, Eindhoven, Nederland) with the LPC-P2148 board [20] (Figure 6) from Olimex (Plovdiv, Bulgaria) and the STR7 series from STMicroelectronics (Geneva, Switzerland), which ushered in the era of 32-bit microcontrollers.

Figure 6. LPC-P2148 Development Board with LPC20000 Microprocessor.

3. Minimalism and Open Standards

At the beginning of the 21st century, with the emergence of the Arduino (Monza, Italy) platform (Figure 7a), the approach to designing evaluation boards changed [21]. The new concept involved minimizing costs by limiting the number of components on development boards, which increased their accessibility to a wide range of users by reducing the entry barrier through dedicated IDEs, support for only selected microcontrollers, and high-quality documentation and additional materials. This resulted in the development of an active community, whose involvement in creating new solutions further stimulated the platform’s development.

Figure 7. Development boards (a) Arduino Uno (b) Nucleo STM32G0RB.

The standard design of these boards included only the essential elements, such as a microprocessor with a bootloader (enabling programming without an external programmer), a voltage regulator, a quartz resonator, and pin headers (gold pins) for connecting peripheral systems.

Over time, development module manufacturers began adapting test board pinouts to be compatible with this standard connector spacing, which facilitated integration and became common practice thanks to the use of open-hardware licenses (CC BY-SA) [22]. This solution reduced costs and reached an even wider audience. Microchip followed Arduino’s lead, introducing the open microBUS standard, which, despite a more refined design, did not achieve widespread popularity.

From that point on, most modules and test boards began to be made available as open projects. Although they offered only basic functionality, they were accompanied by comprehensive technical documentation, significantly simplifying their integration into more complex systems. This enabled embedded system engineers to select appropriate modules and begin development even before designing a PCB. Open-source demonstration libraries are available to accelerate the product implementation process.

Currently, the most popular development platform is Nucleo (Figure 7b) [23], which is directly linked to the success of STM32 microcontrollers. The board’s low price, around €10–20, plays a significant role, as it also includes the ST-Link programmer/debugger. Other popular platforms include FRDM (NXP) and LaunchPad (Texas Instruments). However, a key element determining the popularity of a given solution is its “ecosystem.” In addition to high-quality documentation, users expect the availability of libraries, demonstration examples for both firmware and software, and long-term support. The development of this “ecosystem” does not have to depend solely on microcontroller manufacturers. Companies producing modules, such as Waveshare, Adafruit, and communities publishing on forums or GitHub, can actively contribute to its development. Due to the diversified nature of this “ecosystem,” the openness of solutions and access to their sources are key factors in their success. Developer boards constitute an important part of this ecosystem, and their success is closely correlated with its market performance.

At the beginning of the 21st century, the approach to IDEs began to change. More and more engineers recognized the interdependencies between the compiler, debugger, programmer, and programming language, revealing the limitations of highly integrated environments. Their closed architecture often hindered flexible adaptation to specific project requirements. The answer was the modular and open Eclipse, supported by IBM, which, thanks to its plug-in system, allowed for flexible extension of functionality.

Interestingly, STMicroelectronics did not have its own IDE at the time. The need was so great that the Atol-lic TrueSTUDIO project, based on Eclipse, developed from scratch. It was later absorbed and expanded into the official STM32CubeIDE (Figure 8). This is a prime example of the power of the online community. NXP also took advantage of a similar solution, developing MCUXpresso on Eclipse.

Figure 8. Evolution of IDEs considering their relative popularity.

VSCode (Visual Studio Code) [24] is gaining popularity, distinguished by its speed, intuitiveness, and open architecture. Its lightweight structure consumes fewer resources than traditional IDEs, and its extensive extension ecosystem enables easy integration with embedded systems programming tools. Currently, Arduino has abandoned further development of its own IDE, adapting VSCode to its needs, and PlatformIO is also developing dynamically (Figure 8). In this figure the number of stars denotes our subjective score based on popularity and reliability in the embedded systems (more star—better).

4. SoC Systems

As a given functionality began to appear more frequently, especially in the case of interfaces and communication protocols such as USB, CAN, or Ethernet (Table 1), it was integrated as another peripheral device, extending the microcontroller’s capabilities. However, when the devices became too complex and extensive, as in the case of Bluetooth, Wi-Fi, or LoRa (Table 1), the natural consequence was to encapsulate several modules within a single integrated circuit, but with looser integration. This was no longer achieved through registers, as in the case of classic peripherals, but through buses (e.g., internal SPI) or separate cores with dedicated firmware. As a result, previously external devices became part of a programmable system, a concept we call an SoC (System on Chip).

Development boards with this type of circuitry must be equipped with appropriate components to fully utilize the available features. This includes radio circuits for wireless systems and transceivers that adapt signal levels and transmission methods to the requirements of wired communication standards.

One of the most popular SoCs is the ESP32 [25] (Figure 9a), valued for its low cost and ease of implementation. It includes integrated Wi-Fi and Bluetooth modules. In more advanced applications, chips from Nordic Semiconductor, Trondheim, Norway, (nRF52 [26]) (Figure 9b) and STMicroelectronics (STM32WB, STM32WL) are commonly used. The development of these technologies is closely related to the IoT (Internet of Things) and the computerization of industry (Industry 4.0).

Figure 9. Development boards (a) ESP32 (b) Nucleo nRF52.

5. Conclusions from Historical Analysis

The dynamic development of microcontrollers, development tools, and evaluation boards reveals a clear trend. Initially, commercial, proprietary solutions dominated, conquering the market by quickly adapting to its needs. However, in the long run, they proved to be a barrier to innovation, giving way to open-source technologies. It is these open standards that have stood the test of time and continue to be developed, while many closed ecosystems have been abandoned.

The development of evaluation boards has shown that minimizing costs and simplifying implementations through a modular approach, the use of open standards, solid documentation and high-quality libraries and examples are key factors for ensuring success in the market.

When designing new solutions, it is important to rely on open standards and create software and hardware solutions in an open and modular manner, with a focus on the needs of the end user who will implement and use them. It is crucial that this process effectively supports the end user. This is particularly important in academic environments and wherever the goal is technology development, not just short-term profit.

However, market needs cannot be completely neglected, as the success of SoCs reminds us, where strong integration contrasts with a modular (layered) approach. This integration contributes to miniaturization and reduces the cost of the final product, and therefore will continue to evolve, as it has since the dawn of microprocessors.

The most important programmable devices, along with related evaluation boards and a highlight of subsequent integrated functions (in bold) and other key features, are listed in Table 1. The development of embedded systems is the result of the activities of many companies that, although often operating independently, influence each other, creating one dynamically evolving ecosystem.

6. PLC Controllers

PLCs (Programmable Logic Controllers) are programmable devices comparable to microcontrollers in that they possess I/O peripherals and interfaces. However, they differ in terms of standards and specific applications. Microcontrollers are versatile and can be used in various fields, while PLCs are dedicated to industrial automation and rely on a microcontroller as their central element. In this sense, a PLC acts as an abstraction layer above the microcontroller, offering additional functions to support industrial processes, but may also limit or restrict access to certain microcontroller functions.

The most popular commercial PLCs, such as the Siemens S7-1200 (Siemens AG, Munich, Germany), Wago 750-881 (WAGO GmbH & Co, Minden, Germany), or Allen-Bradley MicroLogix 1400 (Rockwell Automation, Milwaukee, WI, USA), work with dedicated software that allows for program creation and upload. At the heart of each controller is a microcontroller responsible for calculations, peripheral control, and communication. However, dedicated programming environments impose certain limitations, allowing only manufacturer-provided functions and blocks to be used. While this facilitates the creation of transparent programs, it limits access to lower layers, which can be problematic in advanced applications. Furthermore, a given manufacturer’s controllers can only be programmed within their respective environment, leading to greater vendor dependency, limiting programmer flexibility, and potentially negatively impacting market competitiveness and innovation.

It is clear that the technological paradigms for PLCs are completely different from those for microcontrollers, SoCs, and programmable logic boards. Instead of openness, which favors innovative development, priority is given to reliability, long lifecycles, resistance to industrial conditions, and security. Standards and certifications ensure stability and protection against unauthorized access, while ease of service allows for program modifications without interrupting system operation [27]. However, this does not mean that this trend will remain unchanged. Initially, many solutions based on microcontrollers and development boards were similar in nature to modern PLCs. This is evidenced by the growing popularity of open and layered PLCs, which increasingly use systems based on microcomputers (e.g., Raspberry Pi (Raspberry Pi Trading Ltd., Cambridge, UK) [28]) and modules adapted to automation standards. They provide much greater flexibility and simplify integration with computer systems and Internet infrastructure (Industry 4.0), finding application where traditional solutions prove insufficient [29].

To date, however, no fully open solution dedicated to simpler and more reliable processes and based on direct microcontroller programming has gained widespread popularity. This approach could provide greater stability, lower power consumption, and faster startup times compared to microcomputer-based controllers, making them an attractive choice for some industrial applications. From an educational perspective, such a solution allows not only learning PLC programming but also understanding the hardware and abstraction layers. This allows engineers to gain practical skills in working with microcontrollers, code optimization, and integration with automation. The platform’s openness fosters experimentation, encourages systems thinking, and eliminates the limitations of typical closed environments.

7. OpenCPLC Project

The OpenCPLC is an abstraction layer between the application and the microcontroller’s peripherals, which is similar to Arduino, but focused on automation. It does not require a proprietary IDE or C++. Multithreading is provided by VRTS, eliminating typical RTOS issues. The system has a built-in CMD console like Linux, and Wizard simplifies microcontroller programming to a Python-like level. Technologically, it is closest to Zephyr, but is simpler, closer to native solutions, with a working debugger, and is focused on automation rather than IoT.

The OpenCPLC project [30] is being developed as an open-source platform connecting the worlds of development boards and PLCs. Its goal is to develop a tool that maintains the stability and industry standards while remaining open and modular like classic development boards. Its foundation is the GitHub repository ecosystem, which includes, among others, the wizard.exe toolkit, a framework (HAL libraries, support for industrial protocols), and sample applications.

The system architecture is based on the C language, the ARM GCC compiler, and debugging via OpenOCD. A key element is the lightweight multithreading system VRTS [31], which eliminates the need for memory synchronization, making it significantly safer than traditional RTOSs. VRTS enables multithreading without the need for an operating system, ensuring rapid startup and predictable operation in industrial applications.

In contrast to this approach, other open controllers, such as PLCnext or Revolution Pi, are based on full operating systems (Linux), which increases their flexibility but is associated with typical operating system limitations such as:

• Long start—several to several dozen seconds after turning on the power [32].
• Resource consumption—kernel and system processes load RAM/Flash and CPU [33].
• Security—difficult to ensure, requires updating and specialized knowledge [34].
• No time guarantees—no certain reactions to events and access to peripherals by drivers [35].

It is worth noticing that there are no “standard” or universal values for startup time or resource consumption—they are highly dependent on the specific SoC architecture, kernel configuration, bootloader, file system, and active services. In the case of Linux systems, initialization time, memory, and CPU usage can differ by up to an order of magnitude between two implementations based on the same kernel but with different configurations.

For example, system boot time to user space ranges from 0.33 s for highly optimized systems, such as Monolinux, to 43 s for a system without optimization. Similarly, RAM usage by the operating system ranges from 10 to over 64 MB.

Wizard.exe plays a key role, automating workspace configuration, tool installation, project switching, and example launching. This simplifies and standardizes workflows, whereas manual environment setup would require significant experience and be challenging for novice developers.

All controllers used are based on the STM32G0 family and are designed to fully exploit the microcontroller’s potential. They feature standardized dimensions suitable for DIN rail mounting and are equipped with detachable 5.0 mm terminals, simplifying installation and service. The entire controller line is designed as a coherent platform, with different models complementing each other functionally, allowing for easy integration into larger systems (Figure 10).

Figure 10. OpenCPLC controllers (a) Uno; (b) Eco; (c) Dio; (d) Aio.

The first controller (Uno) in the OpenCPLC family is versatile due to its wide range of peripherals. Although it serves a demonstration and educational purpose, it is also suitable for small projects.

The small and affordable Eco controller is designed for standalone operation, particularly in construction machinery. It is equipped with multiple potentiometers for computer-free configuration and a 10 V reference voltage for joystick operation and direct measurement on analog inputs.

The Dio controller is designed for medium- to large-scale projects as an expansion module (with a single communication bus). It features numerous digital inputs and outputs, with a second set of transistor outputs powered independently of the main power supply. It also has several analog inputs, useful for smaller projects.

The Aio controller is designed for medium- to large-scale projects. It can be used as a main unit or as an expansion module when additional analog channels are needed. It includes multiple analog inputs and outputs, a stable power supply, and a negative voltage for more accurate measurement and signal generation.

The framework provides an abstraction layer typical of automation. Instead of the familiar embedded GPIO (general purpose input output) or ADC (analog digital converter), the programmer works with TO, RO, DI, and AI, AO. The hardware is mapped to this layer, so each new driver requires only a new peripheral map to operate within the ecosystem. Table 2 describes the blocks included in each version of the OpenCPLC drivers.

Table 2. Designations of blocks present in the presented controllers.

Block Name	Description	Number of Blocks
		Uno	Eco	Dio	Aio
RO	Relay outputs: 5 A 230VAC, 7 A 30VDC and switching counter.	4	2	-	-
TO	Transistor outputs: 4 A controlled by the supply voltage. All can operate in PWM mode.	4	5	12	4
XO	Triac output: 12-230VAC. Zero crossing detection using digital input.	2	-	-	-
DI	Digital inputs: from 12VDC high. Supports 230VAC. Most can function as counters.	4	4	12	4
AI	Analog inputs: 0–10 V, 4–20 mA, 0–20 mA or 0–10 V with voltage follower.	2	4	4	10
AO	Analog output: 0–10 V, 0–20 mA rail-to-rail.	-	-	-	4
RTD	Resistance sensor input, suitable for PT100 and PT1000.	1	-	-	-
RS	RS485 communication interface with support for Modbus RTU, BACnet or bare metal.	2	1	1	2
I2C	Communication bus with 5 V buffer and 1 kΩ pull-up.	1	-	-	1
POT	Potentiometer. Works like an internal AI. Allows configuration without a computer.	1	6	3	-
BTN	Button or switch. Acts as an internal DI.	1	5	-	-
LED	RGB LED information diode.	1	1	1	1
FLASH	Non-volatile memory [kB]: program, configuration, EEPROM emulation.	512	128	512	512
RAM	Main memory [kB]: buffers and calculations.	144	36	144	144
RTC	Real-time clock: date and time.	1	-	1	1

OpenCPLC controllers are distinguished by their ability to operate in environments where typical PLCs fail. They support standard 24 V_DC automation, as well as 12 V_DC. They provide V_CC supply voltage measurement, which is important when powering the controller directly from a battery. They accept direct 230 VAC signals at the inputs, eliminating the need for additional modules. 4 A outputs allow for direct load control, and the FW firmware, loaded without an operating system, ensures quick startup and high operational stability. Each controller is factory-configured as an expansion module but can be easily reprogrammed to operate as a standalone PLC. Table 3 compares the parameters of selected proprietary PLCs and the OpenCPLC controller. In this table the sign denotes fulfilling of the criteria, but the sign denotes that the criteria is not fulfilled.

Table 3. Parameters of selected PLC controllers.

PLC Controller	Power Supply	DI	DI 230 V	TO Type	TO Current	Get VCC	FW/OS
Siemens S7-1200	20.4–28.8 V	≥15 V		Source	0.5 A		FW
Siemens S7-1500	19.2–28.8 V	≥15 V		Both	0.5 A		FW
Mitsubishi iQ-F	20–28 V	≥15 V		Both	0.5 A		FW
Beckhoff CX7000	20.4–28.8 V	≥11 V		Source	0.5 A		OS
WAGO PFC200	18–31.2 V	≥15 V		Both	0.5 A		OS
Allen-Bradley	10–28.8 V	≥11 V		Source	0.5 A		FW
Schneider Modicon	20.4–28.8 V	≥15 V		Source	0.5 A		FW
Phoenix Contact	19.2–30 V	≥11 V		Both	0.5 A		OS
B&R X20	20.4–28.8 V	≥15 V		Sink	0.5 A		FW
Delta DVP-SS2	20.4–28.8 V	≥15 V		Both	0.5 A		FW
Eaton easyE4	12.2–28.8 V	≥9 V		Both	0.5 A		FW
ABB AC500	20–30 V	≥15 V		Both	0.5 A		FW
Bosch Rexroth	18–30 V	≥15 V		Both	0.5 A		FW
Unitronics	10.2–28.8 V	≥15 V		Both	0.5 A		FW
Turck TX500	10–32 V	≥12 V		Source	0.5 A		OS
OpenCPLC	11–32 V	≥9 V		Source	4 A		FW

The data in Table 3 is for illustrative purposes only. Most controllers allow for expansion with additional modules, for example, to provide higher current outputs or support 230 V signals. The values refer to standard digital inputs and transistor outputs.

OpenCPLC controllers are distinguished by their ability to operate in environments where typical PLCs fail. They support standard automation systems operating on 24 V_DC power supplies, as well as 12 V_DC, typical for mobile machinery in the construction industry or agriculture. They enable voltage measurement, which is important when powered directly from a battery. They accept direct 230 V_AC signals at their inputs, eliminating the need for additional buffering modules. 4 A outputs allow for load control directly from the controller without any additional buffers. This means that a smaller number of the control system is needed when OpenCPLC is used instead of other PLC controllers.

Its open architecture and compatibility with popular programming tools eliminate the limitations of closed systems. This makes the controller suitable as an educational platform, serving as a test and demonstration board in laboratories, as well as in industrial applications. This is demonstrated by the controller’s implementation in mobile machines, where it was used to control hydraulic valves [10], which in the case of typical PLCs would be more expensive, require a larger number of expansion modules, and take significantly more configuration time.

The project is currently in early development and does not yet have a well-established user community. The system software is available through a GitHub repository (https://github.com/OpenCPLC/Framework (accessed on 4 December 2025)), with limited external contributions.

However, OpenCPLC was designed from the outset to be open-source. The authors intend to release the software and libraries under an open-source license (e.g., MIT or CERN OHL), enabling unrestricted use, modification, and adaptation of the system. The planned ecosystem will include publicly available documentation, hardware design files, and firmware source code, allowing future development of the tool with community participation.

8. Sample Application

This application involves using a standard excavator as a remote-controlled service system, designed for cleaning and servicing other machines in construction site conditions and during field work. The modernized design allows for safe operation without the operator needing to be in the cab, thus increasing flexibility and safety in challenging environments. During operation, the operator holds a battery-powered transmitter in their hands. The receiver, Eco controllers, and other system components are located on the machine and powered by the main battery, which is charged by the alternator.

The project utilizes a wireless control system from Irel. The central element is a handheld transmitter (controller, pad) equipped with a set of manipulators, the layout of which can be customized to meet the customer’s individual needs, both in terms of the number and type of controls and their arrangement. The pad transmits the current states of all manipulators (joysticks, switches, etc.) via radio to a dedicated receiver mounted on the machine. The receiver processes this data and generates the following output signals:

• analog signals in automation standards of 0.10 V or 4.20 mA for joystick manipulators,
• digital (ON/OFF) for switches.

The generated signals are sent to four OpenCPLC Eco modules mounted on the machine. These modules use dedicated software (firmware) to mix the input signals and control the proportional valves.

Additionally, safety features are supported. All modules run the same firmware, simplifying service and enabling quick replacement in the event of a failure. The entire system is housed in an IP55-rated enclosure, minimizing the impact of harsh environmental conditions.

Compared to commercially available amplifiers, this solution offers a wide control range and high precision, especially at low voltages and low core saturation, where high motion accuracy is required. During testing, selected commercial solutions failed to achieve sufficient control quality. Therefore, the feasibility of using the OpenCPLC system was tested. Figure 11 shows a conceptual diagram of the remote valve control system, and Figure 12 shows the connection of the Eco module to the actuators.

Figure 11. Conceptual diagram of the remote valve control system.

Figure 12. Wiring diagram for the remote valve control system.

As shown in Figure 11, the operator remotely controls the system using a Transmitter equipped with dedicated joysticks. The Receiver, mounted on the excavator, transmits signals from the Transmitter to four OpenCPLC control modules. Each of them controls proportional valves. The system under analysis uses eight such valves. Both the receiver and the controllers are powered by a battery located in the excavator being controlled.

Figure 12 shows that the OpenCPLC module in this application enables the simultaneous control of two proportional valves and uses power supplied by a battery installed on the same excavator. Additional external components act as a system switch and lighting.

Figure 13 and Figure 14 show photographs of the test excavator (Figure 13) and the switchboard containing, among other components, four OpenCPLC controllers. The vehicle shown in Figure 13 was not part of the project itself. Tests confirmed that the excavator with the developed control system correctly performed the planned tasks. The expected accuracy and repeatability of the work tool movements were achieved.

Figure 13. View of the excavator being tested with the control system.

Figure 14. View of the switchboard containing the developed OpenCPLC modules.

Despite its relatively simple implementation, the presented proportional valve control system is not considered one of the simplest solutions in industrial automation. In practice, it is commonly implemented using dedicated actuators. However, the ability to directly control such components, as well as other more demanding medium-power systems, directly from the controller enhances flexibility, simplifies the overall design, and reduces costs.

Most commercially available PLCs are designed exclusively for operation with a 24 V power supply, which limits their use in mobile systems where 12 V is the standard. However, the proposed controller’s ability to operate with both voltages does not require major modifications to the control architecture and has no significant impact of the device’s cost.

Support for the 12 V power supply standard brings real benefits: it facilitates integration with vehicle systems, eliminates the need for converters, and reduces overall system complexity. This represents a small effort for the manufacturer, but a significant convenience for the integrator and end user. It is difficult to pinpoint why compatibility with 12 V-powered industrial controllers remains rare in this class of devices.

It is worth noting that typical industrial automation systems are not designed for construction machinery. For this reason, satisfactory remote control has not been achieved using traditional PLC-based solutions. Furthermore, a comparison of the costs of a control system incorporating the OpenCPLC module described in this paper and one based on a traditional PLC controller is made below.

The cost of controlling the excavator considered in this study using a system containing four OpenCPLC modules is approximately $600. By comparison, a PLC-based system would cost approximately $1650. This cost includes the purchase of a power supply for the PLC ($250), a PLC controller with accessories ($800), and four valve control systems (4 × $150). Therefore, the proposed system solution is over 2.5 times cheaper than a solution containing a traditional PLC and contains fewer components, which contributes to improved system reliability.

9. Final Conclusions

The evolution of evaluation boards reflects the dynamic development of technology and changing market demands. From the 1970s, when development boards were primarily designed to meet industrial requirements, to the 1980s and 1990s, when presenting the capabilities of devices on a broader scale became crucial, this resulted in a wealth of peripherals and demonstration tools. Since the turn of the 21st century, microcontrollers have become an indispensable, and even key, element of microelectronics in industry. In each era, programmable logic devices and their associated ecosystems have adapted to current market needs.

The lack of major conceptual changes in recent years may indicate market maturity and little need for innovation. The OpenCPLC project departs from the mainstream, combining aspects of both development boards and PLCs. Although its intended use resembles that of PLCs, its technological approach is closer to that of a development board.

This combination, offering both theoretical learning and practical applications in real-world automation environments, is crucial for preparing future engineers for professional challenges in a dynamically evolving industry. Regardless of the direction of technological evolution, evaluation boards remain an essential tool in electronics engineering, playing a fundamental role in the creation of modern electronic devices.

It is also worth emphasizing that in the automation market, a growing number of companies and engineers are recognizing that proprietary designs can give them a strategic competitive advantage. Such solutions can scale with business growth and be tailored to the specific needs of the project. Problems can arise from designers’ lack of experience in embedded systems, the lengthy development time required from scratch, and the risk that, despite the resources invested, the project will simply fail. OpenCPLC simplifies this process by offering an open framework and a ready-made hardware base. The entire process can be implemented in a transparent, two-phase model.

The main advantages of the OpenCPLC system are its simple design, flexible application, and free, open-source software. The four controller variants described in this paper can be used in automation systems to control devices of varying complexity. A unique feature of this system is its ability to operate with input and output signals at mains voltage levels. Additionally, the high current capacity of the output transistors enables direct switching of actuators operating at currents up to 4 A.

The test results of the OpenCPLC system used to control an excavator, presented in Section 8, demonstrated its practical utility. The system effectively controlled proportional valves, enabling the work tool to follow a predetermined trajectory with high precision. Additionally, a control system using OpenCPLC modules is significantly less expensive than traditional systems based on PLC controllers.

The OpenCPLC system will continue to be developed to enhance the control software and broaden its range of applications. Comparative studies will also be carried out between control systems incorporating the OpenCPLC system and those using traditional PLCs. These studies will identify application areas in which the proposed system significantly outperforms conventional solutions, as well as reveal its limitations. Future plans also include developing OpenCPLC variants with power semiconductor devices capable of handling higher current, enabling direct control of high-power actuators.