The Arduino platform's simplicity, open architecture and ease of use helped make it the most popular embedded development tool within the Maker community. In this article, we will look at the new Linino framework, which makes it possible to seamlessly integrate Linux into the Arduino platform as well as some of the boards, protocols and development tools that can support advanced functionality, such as real-time control of multiple functions, IoT applications and integration of cloud-based services.
In the Beginning
The first Arduino boards were powered by Atmel's AVR family of 8-bit microcontrollers that were great for simple tasks such as controlling lights, power supplies or motors. However, as Arduino's popularity grew, new boards sporting more powerful 16-and 32-bit MCUs were introduced to support increasingly-demanding applications. Likewise, many new plug-in "shields" added powerful wired and wireless networking capabilities, as well as I/O options ranging from motion sensing to motor control.
Arduino + Linux = Open-Source Awesomeness
Fig.1: The Arduino Yun is a 3rd-generation dual-processor Arduino board (left) which uses the Linino Bridge Protocol to share resources and act as a command/data pipeline (right). Images credit: Arduino.org.
Now, a third generation of Arduino boards is emerging that contains two processors. 3rd-gen boards such as the Arduino Yun. (Fig.1) have an embedded microcontroller (MCU) and a more powerful microprocessor Unit (MPU), similar to those found in PCs and mobile devices. The MCU (typically an Atmel ATmega32x device) supports the real-world I/O functionality traditionally handled by the Arduino platform. The MPU is typically based on the MIPS architecture (such as the Atheros AR9331) and powerful enough to support application languages such as C/C++, Python and Java. The microprocessor can also support multiple communication protocols (Wi-Fi, TCP/IP, HTTP etc) and web-based services (Chat, e-mail, Twitter, AllJoyn etc).
This division of labor frees the MCU to handle all the traditional close-to-hardware functions that the original Arduino was designed to, leaving the CPU free to support higher-level applications and compute-intensive communications tasks. Splitting functionality also allows the microprocessor to run LininoOS, a Linux distribution based on OpenWRT (Fig.2) while the MCU to still runs conventional Arduino code. The Arduino MCU communicates with its higher-powered companion using a protocol stack called LininoIO.
Fig.2: Linino's IO/OS subsystem enables the MCU to transparently share its I/O peripherals with the platform's MPU. Image credit: Arduino.org.
The MCUIO/LININOIO subsystem allows a microprocessor, connected to the Arduino's MCU, to see the MCU's peripherals as standard Linux peripherals (i.e. GPIOs, I2C adapters, PWM channels, etc). The basic communication protocol is completely generic, it just defines ways to read and write a (virtualized) memory space on the MCU. Standard vendor independent memory maps are then defined for each kind of MCU peripheral, so that hardware-specific implementation details can be ignored by the MPU. The protocol is transport independent, requiring only a wired or wireless bidirectional channel (for instance rs232 or even a network connection). Linino IO also enables a single microprocessor to communicate with up to 128 MCUs. As a result, an MPU running Linino OS can run applications written in higher-level languages (Python, Bash, Lua etc), which controls the entire board and all the devices attached to it.
Communication between the MPU and MCU is normally handled by the Bridge library (Fig1b), a collection of utility classes that support different kinds of functionality. The Bridge library facilitates communication between the two processors, giving Arduino sketches the ability to run shell scripts, communicate with network interfaces and receive information from the AR9331 processor.
The third pillar of the new software architecture is Arduino Ciao, a library of routines that enables Arduino sketches to communicate with the "outside World" (Fig.3). By simplifying interactions between the MCU and Linino OS, Ciao makes it easy to establish a variety of connections with most common protocols, third-party services and social networks.
Fig.3: The Arduino Ciao library enables the MCU to access web-based services and resources. Image credit: Arduino.org.
The Ciao library's modular routines support several logical connections capable of interacting with system resources (file system, console and memory). Others can be used to communicate with the most common and useful protocols (XMPP, HTTP, WebSocket, COAP, etc) and applications (Jabber, WeChat, Twitter, Facebook, etc.)
Together, the Linino OS, Linino IO, Bridge and Ciao form a complete Linux system for Internet of Things (IoT) applications.
A New Development Environment
In order to support concurrent operation of Arduino and Linino code, the folks at Arduino had to create Arduino Studio, a new development environment that breaks from the monolithic architecture and a centralized development model of the original Arduino IDE. Arduino Studio is intended to serve as a single editor for all environments, enabling developers to use it as a stand-alone, web/cloud-based or onboard embedded editor. By leveraging the versatility of Adobe Brackets Studio supports all the functionality of the original Arduino IDE, but also offers a full-featured Linux development environment. Arduino Studio's features include Code Completion, an in-line Quick Language Reference and a Debugger that currently supports the Arduino M0 Pro platform.
There are already several boards that support the dual-processor Linino architecture. Many of these boards contain both an MPU and an MCU device, but as we will see shortly, the Linino platform also makes it possible to create extremely low-cost systems based on a single MCU.
The Arduino Yún is based on the ATmega32u4 and the Atheros AR9331 (Fig.1a). It includes built-in Ethernet, a USB-A port, micro-SD card slot, 20 digital input/output pins (of which seven can be used as PWM outputs and 12 as analog inputs), a micro USB connection, an ICSP header and three reset buttons. Yún also has a Wi-Fi module built on board, allowing it to connect to a wireless router, or act as an access point. The Yún's ATmega32u4 has built-in USB communication, eliminating the need for a secondary processor. This allows it to appear to a connected computer as a mouse and keyboard, in addition to a virtual (CDC) serial / COM port.
Fig.4: The Arduino Yún Mini. Image credit: Arduino.org.
Arduino Yún MINI is a compact breadboard PCB powered by an ATmega 32u4 MCU and a Qualcomm Atheros AR9331 CPU. It has built-in WiFi and nearly all of the full-size Yún's I/O compliment, including a USB-based COM port. This open-source board design is also available as the Linino One from Linino.org.
Fig.5: Arduino Tian, scheduled for initial release in November 2015. Image credit: Arduino.org.
Arduino TIAN is similar to the Yun, but designed for projects that require more processing power and I/O capability. TIAN is equipped with Atmel’s 32-bit ARM-based SAMD21 MCU and the Qualcomm Atheros AR9342 MPU. Its integrated Wi-Fi module supports IEEE802.11n 2x2 2.4/5 GHz dual-band operation. It is also equipped with 4GB of eMMC memory that can store application code or additional Linux libraries.
Fig.6: Linino Chiwawa LGA module and evaluation board (left) and its companion Evaluation Board(right). Images credits: Arduino.org and Linino.org
The Linino Chiwawa is an LGA module based on Arduino's open-source 101 Industrial design. It is intended to be a low-cost drop-in LininoOS device for commercial applications and is expected to cost $10 or less in production quantities. It contains an Atheros MIPS AR9331 MPU, but does not include an MCU. The board has built-in Ethernet and Wi-Fi support, a USB-A port, micro-SD card slot, a micro-USB connection, PoE module connection and reset button. Chiwawa can connect to one or more Arduino MCU devices via a daughter board (aka "collar"), such as the Chiwawa EVB that serves as the module's evaluation/development board.
Fig.7: The Arduino Industrial 101 evaluation board, scheduled for a November 2015 release, provides an Atmel MCU, a USB-based console interface and bridging of other real-world signals for the Arduino Industrial LGA module. Images credits: Arduino.org and Linino.org
The Arduino Industrial 101 is another evaluation/development board for the 101 Industrial LGA module described above. The board's integrated ATmega 32u4 MCU supports the LininoIO and Bridge libraries exports all the signals required to support communication, reset, 1 PWM output and two analog inputs. It also brings its USB and an Ethernet signal out to pin headers for easy diagnostic and debug.
To contact the author of this article, email firstname.lastname@example.org