Consult the Glossary

The glossary provides a short definition of the most common terms, and provides links to the related entries.

4D Systems

The 4D Systems boards combine a colour touch screen with a controller.

  • The IoD boards are powered by an ESP8266 MCU, They rely on the ESP8266 boards package for the Arduino IDE with a modified file and the specific TFT display library.

  • The PICadillo-35T board combines a PIC32 MCU with a 480x320 TFT screen. The IDE used to be MPIDE with additional files and the specific TFT display library. As MPIDE is deprecated, the board is supported by the Arduino IDE with the chipKIT boards package.


Related entries: Arduino , Boards , MPIDE

Install: Install the 4D Systems Platform

Adafruit

Adafruit offers a large range of hilghly-compact boards based on the ATtiny85x and the ATmega328P.

The installation of the Adafruit boards is performed with the Boards Manager on the Arduino 1.6 IDE.


Related entries: Arduino , Boards

Install: Install the Adafruit Platform

Upload: Upload to Adafruit Boards

Debug: Check the Configuration

Application libraries

The application libraries are optional libraries to provide additional features, like managing the specific I²C and SPI ports.

They are defined by each of the IDEs.

By default, no application library is included.

They require to be explicitly mentioned with the #include statement on the main sketch and listed on the main makefile after the APP_LIBS_LIST variable.

embedXcode+ lists all the application libraries for the selected platform on the main makefile.


Related entries: Framework , Libraries

Architecture

The MCUs are grouped in families or architectures.

As example, one characteristic of the architectures is the number of bits used to process data. It could be

  • 8-bit for the ATmega,

  • 16-bit for the MSP430

  • or 32-bit for the ARM.

Other characteristics include the structure of the hardware and the instruction set.

Each architecture requires its dedicated tool-chain.


Related entries: Arduino , Boards , MCU , Particle , Platform , Tool-chain

ArduCAM

ArduCAM specialises in cameras and offers two boards with WiFi and an Arduino form-factor.

The ArduCAM CC3200 is based on the CC3200 and runs on Energia.

The ArduCAM ESP8266 is based on ESP8266 and runs on Arduino 1.6 IDE. The installation is performed with the Boards Manager.


Related entries: Arduino , Boards , Energia , ESP8266

Install: Install the ArduCAM Platform

Upload: Upload to ArduCAM CC3200 Board

Arduino

The Arduino name includes hardware, a framework and an IDE.

The boards are based on three major architectures:

  • 8-bit ATmega,

  • 32-bit ARM SAM for the Arduino Due and the Arduino Zero Pro,

  • 32-bit ARM SAMD for the Arduino Zero and the Arduino M0 Pro.

The Arduino IDE version 1.8 now supports all the boards from previous organisations and IDEs, Arduino.CC with IDE version 1.6 and Arduino.ORG with IDE version 1.7.


Related entries: 4D Systems , Adafruit , Architecture , ArduCAM , Boards , DFRobot , ESP32 , ESP8266 , Framework , Glowdeck , IDE , Intel , Internet of Things , LightBlue Bean , Little Robot Friends , MediaTek LinkIt , Microduino , Microsoft , Moteino , MPIDE , panStamp , Particle , RedBear , RFduino , Seeeduino , Simblee , TinyCircuits , Udoo Neo

Install: Install the Arduino Platform

Upload: Upload to Arduino Yún Using Ethernet or WiFi , Upload to Arduino M0 Pro , Upload to Arduino Zero

Debug: Check the Configuration , Connect the Segger J-Link to the Arduino Due , Select the USB Port for the Arduino M0 Pro

ARM mbed

The ARM mbed framework is designed for the ARM MCUs.

It includes a hardware abstraction layer and runs on a large range of boards based on Cortex-M0, M3 and M4 MCUs. It also features a real time operating system, or RTOS.

Up to now, mbed was available solely online. It can now be downloaded and used off line with standard tools as the GCC tool-chain and the OpenOCD debugger.

Most of the high level libraries of ARM mbed are written in C++. The mbed SDK has gone through major updates, first with mbed OS 3.0 and now mbed OS 5.0

Support for mbed Classic has been discontinued since embedXcode release 5.0.


Related entries: Boards , C++ Language , Framework , Freedom , GNU Compiler Collection , Nordic , Nucleo , Open On-Chip Debugger

Install: Install the mbed Framework

BeagleBone

The BeagleBone is a board featuring a Cortex-A8 AM3358 processor from Texas Instruments and running on Linux. The recommended Linux distribution is Debian.

Support for the BeagleBone board has been discontinued since embedXcode release 5.0.


Related entries: Boards

Install: Install the BeagleBone Board

Upload: Upload to BeagleBone Board

Boards

A board is hardware defined by its MCU.

For example, the LaunchPad Stellaris is based on the ARM Cortex-M4 LM4F120H5QR MCU.

All the embedded computing boards use a Processing-based Wiring-derived Arduino- like IDE or run on the mbed platform.

For the Wiring / Arduino framework, the boards share the same Processing-based IDE, use the same Wiring-derived framework and bring the same Arduino-like programming with sketches written in C++.

The IDE includes the tool-chain specific to the boards.

For the mbed framework, the boards feature an ARM Cortex-M0, -M0+, M3 or M4, use the same mbed SDK on the GCC tool-chain.


Related entries: 4D Systems , Adafruit , Architecture , ArduCAM , Arduino , ARM mbed , BeagleBone , C++ Language , chipKIT , DFRobot , Digistump , ESP32 , ESP8266 , Framework , Freedom , Glowdeck , IDE , Intel , LaunchPad , LightBlue Bean , Little Robot Friends , Maple , MCU , MediaTek LinkIt , Microduino , Microsoft , Moteino , Nordic , Nucleo , panStamp , Particle , Platform , RedBear , RFduino , Robotis , Seeeduino , Simblee , Teensy , TinyCircuits , Udoo Neo , Wiring

C++ Language

The C++ is a programming language based on the C language. It features object-oriented features like classes.

It is used for programming the embedded computing boards.


Related entries: ARM mbed , Boards , File .cpp , File .h , File .ino , File .pde , Framework , IDE , Sketch , Tool- Chain

chipKIT

chipKIT uses the PIC32 MCUs.

The IDE used to be MPIDE. The installation of the chipKIT board is now performed with the Boards Manager on the Arduino 1.6 IDE.

An optional chipKIT PGM provides an external programmer-debugger to the chipKIT boards.


Related entries: Boards, Debugger , MPIDE

Install: Install the chipKIT Platform

Upload: Upload to chipKIT Board using a Programmer-Debugger

Core libraries

The core libraries include all the basic functions required for development.

Each platform provides its own set compatible with the Wiring and Arduino framework.

All the core libraries are included for compilation using one single #include statement on the main sketch. The same #include statement is also required on the header files.

This is done with

  • the #include "Arduino.h" statement for the Arduino, Energia, Microduino and Teensy platforms,

  • the #include "Wiring.h" for the call , while Wiring platform, and

  • the #include "WProgram.h" for the chipKIT MPIDE and Maple IDE platforms.


Related entries: File .h , Framework , Libraries

Cosa

Cosa is an object-oriented framework compatible with Arduino for the AVR-based boards.

The installation of the Cosa framework is performed with the Boards Manager on the Arduino 1.6 IDE.


Related entries: Framework

Install: Install the Cosa Framework

Debugger

Debugging allows to execute a program one line at a time, check and change the values of the variables, trace the calls of functions, ... It consists on a combination of hardware and software.

There are two ways of debugging:

  • Software debugging, most of the time performed by injecting code like the basic printf("i=%d\n", i) or Serial.println(i, DEC);.

  • Hardware debugging, with a specific chip called a debugger or emulator along the MCU being debugged, and a dedicated application.

The LaunchPad line of boards by Texas Instruments is the only one to include a built-in hardware debugger. It requires the external application GDB, or GNU debugger included in the GCC tool-chain.

The chipKIT PGM provides an external programmer-debugger to the chipKIT boards.


Related entries: chipKIT , Energia , IDE , LaunchPad , MPIDE , Tool-chain

DFRobot

The BLuno and Wido boards from DFRobot provide an easy introduction to the internet-of-things.

The BLuno board integrates Bluetooth 4.0 or BLE into a standard Arduino Uno board and the Wido board integrates WiFi into a standard Arduino Leonardo board.

The BLuno board is considered as a standard Arduino Uno board and the Wido board as a standard Arduino Leonardo board, so no specific plug-in is required.


Related entries: Arduino , Boards

Install: Install the DFRobot Platform

Digistump

The Digistump platform offers different boards.

  • The Digispark is based on the ATtiny85 and requires a specific upload procedure.

  • The DigiX is compatible with the Arduino Due.

The coming Oak is based on the popular ESP8266.

The installation of the Digistump boards is performed with the Boards Manager on the Arduino 1.6 IDE.


Related entries: Boards

Install: Install the Digistump Platform

Upload: Upload to Digistump Boards

embedXcode

embedXcode is a template for Xcode. It eases development for the most popular embedded computing boards.

A second version called embedXcode+ includes additional extended functionalities. The features specific to each version are listed at Appendixes - Versions.

embedXcode relies on the IDEs of the boards for the frameworks and tool-chains.


Related entries: embedXcode+ , Framework , IDE , Xcode

embedXcode+

embedXcode+ is a template for Xcode. It eases development for the most popular embedded computing boards.

embedXcode+ adds extended functionalities to embedXcode.

Just like embedXcode for the boards running on the Wiring / Arduino framework, embedXcode+ relies on the IDEs of the boards for the frameworks and tool-chains.

embedXcode+ also supports the boards running the ARM mbed framework. However, unlike the boards mentioned above, the framework and tool-chain require a manual procedure.

The features specific to embedXcode+ are mentioned by .


Related entries: embedXcode , Framework , IDE , Xcode

Energia

Energia is the Arduino 1.0-based IDE for the LaunchPad boards.

Although all the LaunchPad line of boards managed by Energia include a hardware debugger, the IDE doesn't feature the corresponding application.

So embedXcode uses two external applications and tools for debugging: GDB, or GNU debugger, already included in the GCC tool-chain, and OpenOCD, or open on chip debugger.


Related entries: ArduCAM , Debugger , Energia MT , GNU Compiler Collection , IDE , LaunchPad , Open On- Chip Debugger , RedBear

Energia MT

Energia Multi-Tasking or Energia MT is an extension of Energia based on TI-RTOS, the real-time operating system from Texas Instruments. Energia MT runs on a selected range of boards.

The Galaxia Library provides the main RTOS elements encapsulated in easy-to-use objects.


Related entries: Energia , LaunchPad

ESP32

The ESP32 by Espressif Systems is a SoC featuring WiFi and Bluetooth.

There are many boards based on the ESP32, to be programmed using the Wiring / Arduino framework.

The installation of the ESP32 board is performed with the Boards Manager on the Arduino IDE with a modified file and specific libraries for WiFi and Bluetooth.


Related entries: Arduino , Boards , ESP8266 , IDE , Internet of Things

Install: Install the Espressif Platform

ESP8266

The ESP8266 by Espressif Systems is a SoC featuring a WiFi radio and a limited set of inputs/outputs.

There are many boards based on the ESP8266, some of them more advanced like the NodeMCU board. Although promoted for Lua, the NodeMCU board can be programmed using the Wiring / Arduino framework.

The NodeMCU boards support over-the-air upload.

The installation of the ESP8266 board is performed with the Boards Manager on the Arduino 1.6 IDE.


Related entries: ArduCAM , Arduino , Boards , ESP32 , IDE , Internet of Things

Install: Install the Espressif Platform , Install the NodeMCU Platform

Upload: Upload to NodeMCU 1.0 Board , Upload to ESP8266 NodeMCU Boards using WiFi

File .cpp

File extension for C++ code file.

The C++ code file defines the classes and functions declared in a header file.

The files with .pde or .ino extensions are actually C++ code.


Related entries: C++ Language , File .h , File .ino , File .pde , Sketch

File .docset

File extension for documentation set, Apple’s proprietary format for Xcode help.


Related entries: File .tex

File .h

File extension for header file.

A header file contains the list of public constants, variables, classes and functions defined in a C++ code file.

A header file also lists the required libraries with #include statements.

Among other libraries, it is highly recommended to mention the core libraries. This is done using one single #include statement.


Related entries: C++ Language , Core libraries , File .cpp , Libraries

File .ino

File extension for the sketch, the main part of a program.

The .ino extension is used by Arduino 1.0 and 1.5, Digispark, Energia and Teensy.

It replaces the .pde extension.

The .pde and .ino files aren’t recognised as C++ code by Xcode. During the first compilation, the project is prepared by embedXcode: the files are recognised as C++ code to allow code-sense.


Related entries: C++ Language , File .cpp , File .pde , Sketch

File .pde

File extension for the sketch, the main part of a program.

The .pde extension is used by Arduino 0023, Maple and Wiring.

It has been superseded by the .ino extension.

The .pde and .ino files aren’t recognised as C++ code by Xcode. During the first compilation, the project is prepared by embedXcode: the files are recognised as C++ code to allow code-sense.


Related entries: C++ Language , File .cpp , File .ino , Sketch

File .tex

File extension for LateX file, a language for documents with high quality formatting.

The LateX files are generated by Doxygen and converted into PDF documents.


Related entries: File .docset

Framework

The framework includes a set of libraries (including core and application libraries) that provide an hardware abstraction layer.

The libraries are invoked by the #include statement.

Thanks to the hardware abstraction layer, the same code can virtually run on any boards with an IDE based on that framework.

The framework for the boards is mostly written in C and C++.

The two references are Wiring and Arduino.


Related entries: Application libraries , Arduino , ARM mbed , Boards , C++ Language , Core libraries , Cosa , embedXcode , embedXcode+ , IDE , Libraries , MCU , Platform , Tool-chain , Wiring

Freedom

The Freedom boards feature ARM MCUs from Freescale and run on mbed with the GCC tool-chain.


Related entries: ARM mbed , Boards , GNU Compiler Collection

Install: Install the Freedom Platform

Glowdeck

The Glowdeck board can also be used as a development board. It relies on a 32-bit ARM architecture.

The Glowdeck board requires a plug-in for the Arduino IDE.


Related entries: Arduino , Boards , IDE ,

Install: Install the Glowdeck Platform

Install: Install the Glowdeck Platform

Upload: Upload to Glowdeck Board

GNU Compiler Collection

The GCC or GNU Compiler Collection is de facto standard for many micro-controllers.

A specific version is available for the ARM MCUs.


Related entries: ARM mbed , Energia , Freedom , Nordic , Nucleo , Open On-Chip Debugger , Particle , Tool- Chain

IDE

IDE stands for integrated development environment and is an application used for developing programs.

The IDEs used for the boards are based on the Processing IDE, making them very similar.

They feature a text editor and runs on Windows, Linux or Mac OS X. They use on the Wiring and Arduino frameworks, use the C++ language and rely on different tool-chains.

They are used to develop programs to be run on different boards. Each board has its own version of the IDE, differentiated by the colours of the interface.

Another example of IDE is Xcode.


Related entries: Arduino , Boards , C++ Language , Debugger , embedXcode , embedXcode+ , Energia , ESP32 , ESP8266 , Framework , Glowdeck , Intel , LightBlue Bean , Maple IDE , MediaTek LinkIt , Microduino , MPIDE , panStamp , Platform , Processing , RFduino , Robotis OpenCM , Seeeduino , Simblee , Teensyduino , TinyCircuits , Tool-chain , Udoo Neo , Wiring , Xcode

Intel

Last June 16, 2017, Intel announced the end of support for the Galileo and Edison boards at December 16, 2017.

The Galileo and Edison boards by Intel features a 32-bit Pentium processor on an Arduino-compatible form-factor board.

The installation of the Intel boards is performed with the Boards Manager on the Arduino 1.6 IDE.

Contrary to other boards, the Galileo is not powered through USB.

  • First always connect the power supply to power the board.

  • Then check the Power LED is on.

  • Finally, connect the board to the computer through USB.

Powering the board directly through USB may damage the board.


Related entries: Arduino , Boards , IDE , Internet of Things

Install: Install the Intel Platform , Install the Yocto SDK for Intel Edison, Install the MCU SDK for Intel Edison

Upload: Upload to Intel Edison Using WiFi or Ethernet over USB

Internet of Things

The Internet of Things or IoT is a network of objects.

The things are objects powered by a micro-controller and featuring sensors and actuators.

The network can be local —LAN or local area network—, or wide —WAN or wide area network, through a connection to internet— via a router.

Connection is done through Bluetooth, Bluetooth Low Energy, WiFi, Ethernet, sub-1 GHz, LoRa, among other protocols.


Related entries: Arduino , ESP32 , ESP8266 , Intel , LaunchPad , LightBlue Bean , MediaTek LinkIt , Microsoft , Moteino , panStamp , Particle , RedBear , RFduino , Simblee , Udoo Neo

LaunchPad

The LaunchPads are built by Texas Instruments and feature different architectures, most of them being supported by Energia:

  • 16-bit MSP430G2, MSP430F and MSP430FR,

  • 32-bit Cortex-M4 MSP432,

  • 16-bit C2000,

  • 32-bit Cortex-M3 CC1300 with sub-1 GHz and CC2650 with Bluetooth Low Energy,

  • 32-bit Cortex-M4 CC3200 with WiFi,

  • 32-bit Cortex-M4 Stellaris or Tiva C Series.

  • 32-bit Cortex-M4 MSP432.

The IDE is Energia, with the RTOS-based Energia Multi-Tasking extension for selected boards.


Related entries: Boards , Debugger , Energia , Energia MT , Internet of Things

Install: Install the LaunchPad Platform

Upload: Upload to LaunchPad C2000 , Upload to LaunchPad CC3200 WiFi , Upload to LaunchPad MSP430F5529 and MSP430FR5969

Debug: Check the Configuration , Configure the LaunchPad CC3200 WiFi

Libraries

There are four kinds of libraries:

  • The core libraries include all the basic functions required for development. Each platform provides its own set compatible with the Wiring or Arduino framework.

  • The application libraries are optional libraries to provide additional features, like managing the specific UART, I²C and SPI ports.

  • The user's libraries are developed by the user and stored under the Library sub-folder on the sketchbook folder.

  • The local libraries are part of the project and located on the same folder as the main sketch.

:fa-plus-square: embedXcode+ introduces a variant for the local libraries, the pre-compiled libraries.

  • Instead of using the source code, the pre-compiled libraries are already built and ready to use.

Libraries are managed with an #include statement on the main sketch and header files and with variables on the main makefile.


Related entries: Application libraries , Core libraries , File .h , Framework , Local libraries , User's libraries

LightBlue Bean

The LightBlue Bean by Punch Through Design combines an Atmega328P with a CC2540-based Bluetooth Low Energy radio. The board fits into a match-box.

LightBlue provides a plug-in to be installed on top of the Arduino IDE. Please refer to the relevant section for installation.

Upload and serial console are performed over-the-air through Bluetooth.


Related entries: Arduino , Boards , IDE , Internet of Things

Install: Install the LightBlue Platform

Upload: Upload to LightBlue Bean using Bluetooth

Little Robot Friends

The Little Robot Friends is a nice robot with sensors —touch, sound, light— and actuators —buzzer, LEDs. It can also be programmed.

It runs on an ATmega328P and requires a plug-in for the Arduino IDE 1.0.

The installation of the Little Robot Friends board is performed with the Boards Manager on the Arduino 1.6 IDE.


Related entries: Arduino , Boards

Install: Install the Little Robot Friends Platform

Local libraries

The local libraries are part of the project and located on the same folder as the main sketch.

They require to be explicitly mentioned with the #include statement on the main sketch.

By default, all the local libraries are included.

:fa-plus-square: embedXcode+ allows to create folders for local libraries and select them after the USER_LIBS_LIST variable on the main makefile.


Related entries: Libraries , Pre-compiled libraries

Maple

The Maple boards are based on 32-bit ARM MCUs.


Related entries: Boards , Maple IDE , Microduino , Robotis

Install: Install the Maple Platform

Maple IDE

MapleIDE is the Wiring-based IDE for the Maple boards.

The MapleIDE requires special drivers.

The Maple environment misses two important libraries: strings.h and stream.h.


Related entries: IDE , Maple , Microduino , Robotis OpenCM

MCU

MCU stands for micro-controller unit and includes all the parts of a computer: processing unit, read only memory or EEPROM, flash memory to store the programs and random-access memory or SRAM to store data. The MCUs are grouped in families or architectures.

It also includes general purpose inputs outputs or GPIOs. Some of them can be used for specialised buses like, among the most popular:

  • UART or universal asynchronous receiver/transmitter, most commonly serial port,

  • SPI or serial peripheral interface,

  • I²C or inter-integrated circuit,

  • TWI or two wire interface,

  • I²S or inter inter-chip sound,

  • CAN or controller area network.

Other extras may include a real-time clock, a FPU or floating-point unit, ...


Related entries: Architecture , Boards , Framework , Platform , Tool-chain

MediaTek LinkIt

The MediaTek LinkIt boards are dedicated to IoT.

The MediaTek LinkIt One board features WiFi, Bluetooth 2.0 and 4.0 BLE, GSM and GPRS, GPS, on an Arduino form-factor.

The MediaTek LinkIt Smart 7688 Duo has the same dual-core configuration as the Arduino Yún board. The processor runs on Linux for WiFi and while the controller is an ATmega328 compatible with Arduino.

The MediaTek LinkIt 7697 board features WiFi, Bluetooth 2.0 and 4.0 BLE, on an compact form-factor.

The installation of the MediaTek boards is performed with the Boards Manager on the Arduino 1.6 IDE.


Related entries: Arduino , Boards , IDE , Internet of Things

Install: Install the MediaTek Platform

Microduino

The Microduino boards feature two different architectures on a highly compact form-factor.

The 8-bit ATmega architecture includes the Microduino-Core with an ATmega328P at 16 MHz and 5V, the Microduino-Core+ with an ATmega644PA at 16 MHz and 5V and the Microduino-Core USB with an ATmega32u4 at 16 MHz. Those boards run on a plug-in for the Arduino IDE.

The 32-bit architecture corresponds to the Microduino-Core STM32 board, and uses the MapleIDE as IDE.


Related entries: Arduino , Boards , IDE , Maple , Maple IDE

Install: Install the Microduino Platform

Microsoft

Microsoft has launched an IoT DevKit for its Azure cloud service.

The board combines a Cortex-M4 with WiFi and a large selection of sensors.

The installation of the Microsoft platform is performed with the Boards Manager on the Arduino 1.6 IDE.


Related entries: Arduino , Boards , Internet of Things

Install: Install the Microsoft Platform

Upload: Upload to Microsoft Azure IoT DevKit

Moteino

The Moteino platform by LowPowerLab combines an ATMega328 with a RFM69 sub-1GHz or a RFM95 LoRa radio.

The installation of the Moteino platform is performed with the Boards Manager on the Arduino 1.6 IDE.

The RFM69 sub-1GHz-based board requires the RFM69 library, while the RFM95 LoRa-based board requires the LoRa library from RadioHead.


Related entries: Arduino , Boards , Internet of Things

Install: Install the Moteino Platform

MPIDE

MPIDE is the Arduino 0023-based IDE for the chipKIT boards. A beta release is based on Arduino 1.5.

MPIDE stands for Multi-Platform IDE and targets boards with a PIC32 MCU.

MPIDE is deprecated. Use instead the Boards Manager featured by Arduino.CC IDE release 1.6.5.


Related entries: 4D Systems , Arduino , chipKIT , Debugger , IDE

Nordic

The Nordic boards provide an easy introduction to the internet-of-things, with Bluetooth 4.0 or BLE. The boards are based on the nRF51822 SoC, which combines a Bluetooth Low Energy radio and a Cortex-M0 MCU.

The boards run on mbed with the GCC tool-chain.


Related entries: ARM mbed , Boards , GNU Compiler Collection

Install: Install the Nordic Platform

Nucleo

The Nucleo boards feature ARM MCUs from STMicroelectronics and run on mbed with the GCC tool-chain.


Related entries: ARM mbed , Boards , GNU Compiler Collection

Install: Install the Nucleo Platform

Open On-Chip Debugger

The Open On-Chip Debugger, or OpenOCD, provides tools for programming and debugging MCUs. It runs with other software like GDB from the GCC tool-chain.

It requires a hardware programmer-debugger.


Related entries: ARM mbed , Energia , GNU Compiler Collection , Tool-chain

panStamp

The panStamp platform features a sub-1 GHz radio and includes two architectures, one 8 bits and another 16 bits. Both are managed by the same plug-in.

The 8-bit architecture corresponds to the panStamp AVR with an ATmega328P at 16 MHz and 5V, while the 16-bit architecture corresponds to the panStamp NG based on the MSP430.

The installation of the panStamp boards is performed with the Boards Manager on the Arduino 1.6 IDE.


Related entries: Arduino , Boards , IDE , Internet of Things

Install: Install the panStamp Platform

Upload: Upload to panStamp Boards

Particle

The Particle Core board combines an ARM STM32F103 with the CC3000 WiFi radio from Texas Instruments.

Particle provides a dedicated cloud to manage the board from anywhere in the world. A compiled sketch can be uploaded though USB connection or over-the-air using WiFi and the Particle Cloud.

Particle relies on the Wiring / Arduino framework and use the standard GCC tool-chain.

Up to now, there's only an online IDE. The offline IDE called Particle-Dev and based on Atom is currently in development.

Particle was previously Spark.


Related entries: Architecture , Arduino , Boards , GNU Compiler Collection , Internet of Things , Tool-chain , Wiring

Install: Install the Particle Platform

Upload: Upload to Particle Boards

Platform

A platform is a mix of IDE, frameworks, boards, architectures and tool-chains.

As an example, the Arduino platform includes

  • An IDE called Arduino;

  • Two frameworks, Arduino 1.0 and Arduino 1.5, the later still in beta;

  • Many different boards, which can be grouped in two architectures:

  • the 8-bit ATmega-based boards, as Arduino Uno or Arduino Mega2560,

  • and the 32-bit SAM-based Arduino Due board;

  • Two tool-chains, one for each architecture.


Related entries: Architecture , Boards , Framework , IDE , MCU , Tool-chain

Pre-compiled libraries

:fa-plus-square: embedXcode+ introduces a variant for the local libraries, the pre-compiled libraries.

Instead of using the source code, the pre-compiled libraries are already built and ready to use.

Just like the local libraries, they are part of the project and located on the same folder as the main sketch, they require to be explicitly mentioned by the #include statement on the main sketch and, they are all included by default.

A folder for a pre-compiled library, for example LocalLibrary, includes at least three files.

  • The file LocalLibrary.a is the pre-compiled library.

  • One or more .h files correspond to the header files.

  • The additional file .board gives the board or MCU the library has been compiled against.

embedXcode+ checks the consistency of the pre-compiled libraries with the current target based on the the file .board, and includes the pre-compiled libraries with extension .a during linking.


Related entries: Local libraries

Processing

All the boards use the Processing IDE, adapted for C++.

Processing doesn’t feature any board. Instead, it runs on the main computer and provides an easy interface for displaying graphs based on data acquired from the board.


Related entries: IDE

RedBear

The RedBear —formerly RedBearLab— boards provide an easy introduction to the internet-of-things.

The boards based on the Nordic nRF51822 feature Bluetooth 4.0 or BLE. The Nordic nRF51822 SoC combines a Bluetooth Low Energy radio and a Cortex-M0 MCU. Those boards can be used with the Wiring / Arduino framework as well as with the mbed framework, both with the GCC tool-chain. The installation of the RedBear board is performed with the Boards Manager on the Arduino 1.6 IDE.

The RedBear Duo board runs with the Wiring / Arduino framework and features WiFi and BLE connectivity. It requires a plug-in and a library for the Arduino 1.6.5 IDE.

The boards based on the CC3200 feature WiFi. The CC3200 from Texas Instruments combines a WiFi radio and a Cortex-M4 MCU. Those boards are supported natively by the Energia IDE.


Related entries: Arduino , Boards , Energia , Internet of Things

Install: Install the RedBear Platform , Install: Install the RedBear Platform for mbed

Upload: Upload to RedBear CC3200 Boards , Upload to RedBear Duo Board

RFduino

RFduino combines a Cortex-M0 MCU with Bluetooth Low Energy on a compact board.

RFduino requires a plug-in for the Arduino IDE 1.5.


Related entries: Arduino , Boards , IDE , Internet of Things , Simblee

Install: Install the RFduino Platform

Robotis

The Robotis OpenCM9.04 board is based on the 32-bit ARM MCU.

The Robotis OpenCM is the dedicated IDE.


Related entries: Boards , Maple , Robotis OpenCM ,

Install: Install the Robotis Platform

Upload: Upload to Robotis OpenCM9.04 Board

Robotis OpenCM

The Robotis OpenCM is the Wiring-based IDE for the Robotis boards.

The Robotis OpenCM requires special drivers.

The Robotis environment misses two important libraries: strings.h and stream.h.


Related entries: IDE , Maple IDE , Robotis , Wiring

Seeeduino

Seeed Studio is a hardware manufacturer, especially known for its Grove system.

The Seeeduino is based on the ATmega 328 compatible with the Arduino Uno. The board features three Grove connectors: two I2C and one UART.

The installation of the Seeeduino board is performed with the Boards Manager on the Arduino 1.6 IDE.


Related entries: Arduino , Boards , IDE

Simblee

Simblee is an updated version of the RFduino board.

It combines a Cortex-M0 MCU with Bluetooth Low Energy on a compact board.

The installation of the Simblee board is performed with the Boards Manager on the Arduino 1.6 IDE.


Related entries: Arduino , Boards , IDE , Internet of Things , RFduino

Install: Install the Simblee Platform

Sketch

A sketch is basically a program written in C++ and based on the Wiring and Arduino framework.

The valid file extensions for a sketch are .pde or .ino.


Related entries: C++ Language , File .cpp , File .ino , File .pde ,

STM32duino

The STM32duino platform provides support for boards based on the STM32F1xx, STM32F3xx and STM32F4xx MCUs.

The installation of the STM32duino platform is performed with the Boards Manager on the Arduino 1.6 IDE.


Related entries: Arduino , Boards , IDE , MapleIDE

Install: Install the STM32duino Platform

Teensy

Teensy includes two major architectures:

  • 8-bit ATmega for Teensy 2 and

  • 32-bit ARM for Teensy 3.

The Teensy boards require Teensyduino, a plug-in for the Arduino IDE.


Related entries: Boards , Teensyduino

Install: Install the Teensy Platform

Upload: Upload to Teensy 3.0 and 3.1 Boards

Teensyduino

Teensyduino is the Arduino 1.6 IDE-compatible plug-in for the Teensy boards.

Please refer to Install the IDEs of the Boards — Teensy Boards to avoid possible conflicts with the Arduino 1.6 IDE.


Related entries: IDE , Teensy

TinyCircuits

TinyCircuits specialises in very compact circuits. The TinyScreen+ embeds a Cortex-M0 with an OLED display.

The installation of the TinyScreen+ board is performed with the Boards Manager and the Lbirary Manager on the Arduino 1.6 IDE.


Related entries: Arduino , Boards , IDE

Install: Install the TinyCircuits Platform

Upload: Upload to TinyScreen+ Board

Tool-chain

A tool-chain is a set of tools used to build, link, upload and debug a sketch to a board.

The tools from the tool-chain are called by the IDE.

The MCUs are grouped by architectures and each architecture has its specific tool-chain.

Most of the tool-chains used with the embedded computing boards are based on GCC, or GNU Compiler Collection.

Other tools include programmers and debuggers, like OpenOCD, or Open On-Chip Debugger.


Related entries: Architecture , C++ Language , Debugger , Framework , GNU Compiler Collection , IDE , MCU , Open On-Chip Debugger , Particle , Platform

Udoo Neo

The Udoo Neo is a board featuring a Freescale i.MX 6SoloX processor from Freescale. The processor is dual core with a Cortex-A9 MPU running on Linux and a Cortex-M4 MCU for real-time GPIO.

The MCU supports the Wiring / Arduino framework. Installation relies on the Boards Manager featured by Arduino.CC IDE release 1.6.5.


Related entries: Arduino , Boards , IDE , Internet of Things

Install: Install the Udoo Neo Platform

Upload: Upload to Udoo Neo Board

User's libraries

The local libraries are part of the project and located on the same folder as the main sketch.

By default, no user’s library is included.

They require to be

  • explicitly mentioned with the #include statement on the main sketch,

  • and listed on the main makefile after the and listed on the main makefile after the USER_LIBS_LIST variable.

:fa-plus-square: embedXcode+ lists all the user’s libraries for the selected platform on the main makefile.


Related entries: Libraries

Wiring

Wiring focuses on defining the framework.

Some boards are especially designed for Wiring, as the ATmega64-based Wiring S.


Related entries: Boards , Framework , IDE , Particle , Robotis OpenCM

Install: Install the Wiring Platform

Xcode

Xcode is the official IDE from Apple.

Xcode versions 8 and 9 are recommended for embedXcode.

For previous versions, consider the legacy releases of embedXcode.

Related entries: embedXcode , embedXcode+ , IDE ,