When microcontroller development platforms like the Arduino and Raspberry Pi (RPi) first appeared on the scene circa 2005 and 2012, respectively, they were generally regarded as being of interest only to students, hobbyists, and makers.

Over time, however, the open source nature of the hardware and software associated with these platforms – coupled with the huge hardware and software ecosystems that evolved around them – resulted in professional engineers using them as low-cost evaluation platforms for sensors, actuators, and peripherals, and as prototyping platforms for next-generation embedded systems and Internet of Things (IoT) devices.

By the start of 2020, it was estimated that at least 50 million RPi platforms had been sold in around ten different models/versions. By comparison, there are around 20 different Arduino platforms, some with multiple versions. Unfortunately, there is no accurate record as to how many Arduinos have been sold. If only “official” systems are counted, then the number of Arduinos is probably less than that for the RPi; if unofficial clones are also accounted for, however, then the number of Arduinos almost certainly exceeds that for RPi platforms.

Prototyping to Production Problems

Engineers are driven to create. Many engineers work with hardware and software in their own time, experimenting at home with peripherals and sensors, and developing prototype versions of potential products. Due to the low cost of entry, they often use Arduino or RPi development boards as their prototyping platforms of choice.

In addition to the open source nature of these platforms, Arduino shields and RPi HATS are available with almost every sensor, actuator, and peripheral one can dream of.

Unfortunately, problems arise when the efforts the engineers have undertaken at home arrive at work, at which time their prototypes need to be translated into industrial solutions. As one simple example, Arduino and RPi platforms are commercial products designed to support commercial temperature ranges and environments – they aren’t intended for use in hostile environments that feature shocks, vibration, noisy power supplies, high humidity, and extreme temperatures.

Another issue is that the creators of products intended for the consumer market – like the Arduino and RPi development boards – are happy to change components and make substitutions as and when circumstances dictate (“these are both 10pF ceramic capacitors, so there won’t be a problem if we use them interchangeably”). This philosophy is unacceptable in the case of products intended for medical, industrial, or military use.

The bottom line is that it simply is not possible to “drop” an Arduino or RPi prototype into a box and call it an industrial solution.

There are, of course,  many existing industrial platforms available, but they each have different register maps and hardware interfaces when it comes to talking to things like general-purpose input/output (GPIO) pins, pulse-width modulator (PWM) functions, analog to digital converters (ADCs), digital to analog converters (DACs), and communication functions like I2C, SPI, UART, etc. This makes it difficult to take the software and drivers developed for an Arduino or RPi and migrate them to an industrial platform.

MRAA, UPM, and SMARC to the Rescue

A hardware abstraction layer (HAL) is an abstraction layer, implemented in software, between the physical hardware of a computer and the software that runs on that computer. The HAL’s function is to hide differences in hardware from the operating system (OS) kernel, so that most of the kernel-mode code does not need to be changed to run on systems with different hardware.

The MRAA (pronounced “em rah”) is a library from Intel that performs the role of a HAL and simplifies the logic for connecting to different sensor pins. In addition to allowing users to program in C++, Python, JavaScript, or Java, MRAA is portable, thereby allowing the same code to be run on multiple platforms.

Arduino Create is an integrated online platform that enables makers and professional developers to write code, access content, configure boards, and share projects. In the case of the RPi, multiple integrated development environments (IDEs) are available. MRAA can be used as the HAL for both Arduino and RPi platforms.

Last but not least, UPM is a high-level repository that provides software drivers for a wide variety of commonly used sensors and actuators. These software drivers – which are available for both Arduino and RPi platforms -- interact with the underlying hardware platform through calls to MRAA APIs.

A high-level view of the software/hardware stack (Image source: Max Maxfield)

The term SMARC (“Smart Mobility ARChitecture”) refers to the module definition for a versatile, small form-factor computer targeting applications that require low power, low costs, and high performance. All SMARC modules can support a temperature range of -20 to +85?C, and some support a range of -40 to +85?C. The SMARC specification was created under the auspices of the Standardization Group for Embedded Technologies (SGET), whose membership boasts many “big names” such as ADLINK, NXP, and Texas Instruments (TI).

All of these hardware and software components come together in the form of ADLINK’s Industrial Pi (I-Pi) SMARC Development Kit.

Introducing the I-Pi SMARC

The image below shows ADLINK’s I-Pi SMARC development kit. The transparent acrylic shielding surrounding the I-Pi SMARC balances requirements for protection and access. The kit also includes a power supply, a USB programming cable, and an SD memory card containing the Linux OS.

ADLINK’s I-Pi SMARC development kit (Image source: ADLINK)

The above image shows the top view of the I-Pi SMARC; a view of the underside of the platform is presented below. Observe that the I-Pi is the larger carrier board providing all of the interfaces to the outside world, while the SMARC processor module is the smaller board that is plugged into the I-Pi carrier. It’s also important to note that this kit boasts functions that are necessary when creating many embedded systems and devices for the IoT -- like a real-time clock (RTC) -- but that aren’t included on platforms like the RPi.

An underside view of ADLINK’s I-Pi carrier and SMARC processing module (Image source: ADLINK)

It really isn’t possible to overemphasize the difference between the underlying nature of consumer platforms like the RPi and Ardunio, as compared to the professional nature of ADLINK’s I-Pi SMARC. As was previously noted, the creators of products intended for the consumer market – like the Arduino and RPi development boards – are happy to change components and make substitutions as and when circumstances dictate without such substitutions being communicated to the end users in any way.

By comparison, ADLINK’s I-Pi SMARC follows industry standard ECN (engineering change notice) and PCN (process change notice) practices, which means that end users have access to an audit trail the defines what changes, if any, have been made and why those changes were made. (ECNs are items that affect the fit, form, or function of the product; PCNs are changes to how the product is made.)

A related issue is the reporting and debugging of production quality issues. Developers have no way to do this with consumer platforms like the RPi and Ardunio; by comparison, reporting and debugging mechanisms are in place for industrial-grade platforms like ADLINK’s I-Pi SMARC.

Another issue involves after-sales support and RMAs (return merchandise authorizations), which are part of the process of returning a product to receive a refund, replacement, or repair during a product's warranty period. As for all of its other products, ADLINK fully warranties and supports the I-Pi SMARC.

Last, but certainly not least, consumer platforms like the RPi and Ardunio have no guarantee of longevity and they can be discontinued at any time without notice, which can throw products based on these platforms into turmoil. By comparison, professional grade platforms like ADLINK’s I-Pi SMARC come with a guaranteed 10-year availability.

ADLINK’s I-Pi SMARC development kit supports a variety of deployment scenarios. For example, developers who have already created prototypes using Arduino or RPi platforms can leverage those sensor ecosystems and libraries and can quickly and easily migrate their designs into a long-lived, revision-controlled, industrial production environment.

When the time comes to move from prototype to production, the team can use the open source specification of the I-Pi carrier as a starting point to create their own carrier containing only those functions and interfaces that are required (many embedded systems and IoT devices will have no use for an HDMI port, for example).

Although some engineers may continue to develop their initial home-based prototypes using Arduino and RPi platforms, it is expected that -- due to the affordable nature and numerous advantages offered by the I-Pi SMARC -- many engineers will start to use it as their prototyping platform of choice, both at work and at home.