embARC is an open software platform to accelerate the development of embedded systems based on DesignWare® ARC® processors built on the ARCv2 ISA. embARC provides a solid starting foundation for embedded developers, simplifying development and improving time to market through software reuse.
The embARC software includes the following components:
- ARC Hardware Abstraction Layer (HAL) provides the necessary hardware abstraction for ARCv2 ISA compatible processors.
- Device HAL provides hardware abstraction for common platform devices and implementation of DesignWare IP drivers, such as UART, I2C and SPI.
- Board Support Package (BSP) layer provides support for different boards based on the ARCv2 processors.
- OS layer provides embedded operating system support, provide both traditional Real Time Operating System (RTOS) and light weight Internet of Things (IoT) OS options.
- Library layer provides basic common library support for embedded systems.
- Middleware layer includes mainstream embedded software stack solutions, including FAT file system, network stack and simple shell/Command Line Interface (CLI).
ARC Hardware Abstraction Layer
The ARC HAL provides hardware abstraction for ARCv2 ISA compatible processors. In this layer, the following functions are provided:
- Startup: common startup routines or templates to handle necessary initializations after power on, reset, and so on.
- Exception and interrupt management: a standard exception and interrupt processing model and related resource definitions.
- Unified intrinsic/built-in functions: covering both the MetaWare and GNU toolchains.
- Unified resource definitions: registers, data types, macros, and so on.
- Access to the resources: internal timers, cache, auxiliary registers, and build configuration registers.
Device Hardware Abstraction Layer
The device HAL provides abstraction for following devices:
Common features between different devices such as UART, I2C and SPI are abstracted in the device HAL. Object-oriented concepts are adopted to provide the common device operation API and the device information access API. The following diagram provides examples for UART, SPI/I2C and GPIO devices.
Board Support Layer
Peripherals Driver Instantiation
In embARC, an object-oriented design is applied for device drivers. The peripheral driver implementations in the device abstraction layer are similar to the definition of class, so for each board, the peripheral drivers should be instantiated.
Common Board Initialization Process
A standard bootup process is defined for each board. The entry of this process is board_init, defined by the specific board and called by the application.
Board Resource Unified Definitions
Most boards share common peripherals, so unified definitions are provided. Examples include the UART used to print messages, SD card interface, buttons, LEDs, etc.
Linker Scripts for Boards
To compile an application for different boards, developers need to provide proper linker scripts to describe the board memory resource schemes. Developers can define their own linker scripts for specific schemes.
The BSP layer currently supports the ARC EM Starter Kit.
Real Time Operating Systems
embARC provides a choice of well-known and accepted OS to use with DesignWare ARCv2 processors in embedded applications, with an emphasis on the IoT space. Three OS choices are currently supported in embARC: Contiki and FreeRTOS, which are delivered with embARC OSP, and ARC MQX RTOS, which is available separately from Synopsys.
FreeRTOS is the market-leading real time operating system (RTOS), and the de-facto standard solution for microcontrollers and small microprocessors.
- Single and independent solution for many different architectures and development tools
- Feature rich and undergoing continuous active development; Minimal ROM, RAM and processing overhead. RTOS kernel binary image typically in the region of 6K to 12K bytes
- Simple - the core of the RTOS kernel is contained in only 3 C files. The majority of the many files included in the .zip file download relate only to the numerous demonstration applications.
- Truly free for use in commercial applications
- Comes with a porting, platform development, or application development service if required
- Well established with a large and ever growing user base
- Ample documentation
- Scalable, simple and easy to use
Contiki is an open-source operating system for networked, memory-constrained systems with a particular focus on low-power wireless IoT devices such as street lighting systems, sound monitoring for smart cities, radiation monitoring systems, and alarm systems. Contiki was created by Adam Dunkels in 2002 and has been further developed by a world-wide team of developers from Atmel, Cisco, Enea, ETH Zurich, Redwire, RWTH Aachen University, Oxford University, SAP, Sensinode, Swedish Institute of Computer Science, STMicroelectronics, Zolertia, and many others.
Contiki comes out of the box with a very rich set of communication protocols and applications including:
- Full IP Networking: Contiki provides a full IP network stack, with standard IP protocols such as UDP, TCP, and HTTP, in addition to the new low-power standards like 6lowpan, RPL, and CoAP. The Contiki IPv6 stack, developed by and contributed to Contiki by Cisco, is fully certified under the IPv6 Ready Logo program.
- 6lowpan, RPL, CoAP: Contiki supports the recently standardized IETF protocols for low-power IPv6 networking, including the 6lowpan adaptation layer, the RPL IPv6 multi-hop routing protocol, and the CoAP RESTful application-layer protocol.
- The Rime Stack: In situations when bandwidth is at a premium or where the full IPv6 networking stack is overkill, Contiki provides a tailored wireless networking stack called Rime. The Rime stack supports simple operations such as sending a message to all neighbors or to a specified neighbor, as well as more complex mechanisms such as network flooding and address-free multi-hop semi-reliable scalable data collection. Everything runs with sleepy routers to save power. This is not an industry standard but a Contiki specific implementation.
- The Contiki shell: Contiki provides an optional command-line shell with a set of commands that are useful during development and debugging of Contiki systems. With Unix-style pipelines, shell commands can be combined in powerful ways. Applications can define their own shell commands that work together with existing commands.
- Coffee flash file system: For devices supporting an external flash memory chip, Contiki provides a lightweight flash file system, called Coffee. With Coffee, application programs can open, close, read from, write to, and append to files on the external flash. All of this can be done without worrying about flash sectors needing to be erased before writing or flash wear-leveling. The performance of Coffee is within 95% of the raw throughput of the flash memory.
The ARC MQX RTOS offers leading-edge technology for embedded designs based on the ARC processor platforms. Unlike general-purpose operating systems, the MQX RTOS was designed for speed and size efficiency in embedded systems. The MQX RTOS delivers true RTOS performance, with context switch and low-level interrupt routines hand-optimized in assembly, which can be configured to use as little as 3.4 KB of ROM, including kernel, interrupts, semaphores, queues, and memory manager. MQX RTOS components are linked in only if needed, preventing unused functions increasing the memory footprint. MQX RTOS is available separately from Synopsys.
embARC leverages several open source projects to deliver integrated IoT protocol stack choices for embedded devices based on ARC processors. This section describes various middleware packages that have ported and integrated for use in embARC.
Common middleware consists of ringbuffer and xprintf() packages; xprintf() is a lightweight printf() library used in embedded systems without support for floating point
- Shell Application: Natural Tiny Shell (NT-Shell)
Natural Tiny Shell (NT-Shell) is a tiny shell software component for small embedded systems. NT-Shell is licensed under an MIT license.
- File System: FatFs
FatFs is a generic FAT file system module for small embedded systems. The FatFs module is written in compliance with ANSI C (C89) and completely separated from the disk I/O layer and therefore platform independent.
FatFs is licensed under a permissive BSD style license.
- TCP/IP Stack: lwIP
lwIP is a small independent implementation of the TCP/IP protocol suite, initially developed by Adam Dunkels. The focus of the lwIP TCP/IP implementation is to reduce resource usage while still having a full scale TCP. This makes lwIP suitable for use in embedded systems with as little as tens of KBs of free RAM and 40 KB of code ROM.
Main features include:
- Protocols: IP, ICMP, UDP, TCP, IGMP, ARP, PPPoS, PPPoE.
- DHCP client, DNS client, AutoIP/APIPA (Zeroconf), SNMP agent (private MIB support).
- APIs: specialized APIs for enhanced performance, optional Berkeley-alike socket API.
- Extended features: IP forwarding over multiple network interfaces, TCP congestion control, RTT estimation and fast recovery/fast retransmit.
- Add-on applications: HTTP server, SNTP client, SMTP client, ping, NetBIOS nameserver.
- lwIP is licensed under a BSD-style license: http://lwip.wikia.com/wiki/License.
- TCP/IP Stack: uIP
IP stack integrated into Contiki, supports both IPv4 and IPv6, IPv4/IPv6, RPL, 6LowPAN.
uIP is licensed under a 3-clause BSD-style license as part of Contiki.
- IoT Protocols:
Contiki includes native support for CoAP. With FreeRTOS, sources from the libcoap project are used to provide CoAP functionality - http://libcoap.sourceforge.net/.
libcoap sources are redistributed under the available BSD 2-clause license.
Contiki includes native MQTT support. With FreeRTOS, sources from the iot.eclipse.org Paho project are used to provide MQTT functionality.
Contiki provides support for REST through the low-power Erbium (Er) REST Engine.
The REST layer is useful to develop server-side applications that can be run over either COAP or HTTP.
LWM2M is an Open Mobile Alliance (OMA) standard that is often used with CoAP.
It also supports the UDP Transport Layer Protocol and DTLS-based security.
- Parson is a lightweight JSON library written in C. It provides full JSON support and simple API.
- HTTP Parser
- HTTP Parser is a parser for HTTP messages written in C. It parses both requests and responses. The parser is designed to be used in performance HTTP applications. It does not make any syscalls nor allocations. It does not buffer data. It can be interrupted at anytime. Depending on architectures, it only requires about 40 bytes of data per message stream (in a web server that is per connection).
- Xively Library
- Xively Library is a c library is an extremely portable way to interface your embedded product to the Xively API. For more information about xively IoT cloud platform please visit the xively developer center.
- AWS IoT device SDK
- AWS IoT device SDK for embedded C is a collection of C source files which can be used in embedded applications to securely connect to the AWS IoT platform. It includes transport clients MQTT, TLS implementations and examples for their use. It also supports AWS IoT specific features such as Thing Shadow. For more information on the AWS IoT platform please visit the AWS IoT developer guide.
SSL/TLS are cryptographic protocols designed to provide communication security over a computer network. The embARC Open Software Platform provides support for the following implementations:
- MatrixSSL: An embedded SSL and TLS implementation designed for small footprint applications and devices
- wolfSSL: A lightweight, portable, C-language-based SSL/TLS library targeting IoT embedded systems
- mbed TLS: mbed TLS (formerly known as PolarSSL) makes it trivially easy for developers to include cryptographic and SSL/TLS capabilities in their (embedded) products, facilitating this functionality with a minimal coding footprint. mbed TLS is available as open source under the Apache 2.0 license. embARC supports mbed TLS in FreeRTOS.
- TinyDTLS: tinydtls provides a lightweight implementation of the DTLS protocol that can be used in devices with tight memory constraints, on the order of 100 KiB flash memory and about 10 KiB RAM. embARC supports tinydtls in Contiki.
U8glib is a monochrome graphics library for LCDs and OLEDs. It supports many different monochrome displays, a large number of fonts and well-defined C/C++ APIs. U8glib code is licensed under the terms of the new BSD license (two-clause BSD license).
- JSON and HTTP Parser
- JSON : Parson
Parson is a lightweight JSON library written in C. It provides full JSON support and simple API.
- HTTP Parser : http-parser
http-parser is a parser for HTTP messages written in C. It can parse both http requests and responses.
- YModem Protocol
YMODEM is a file transfer protocol used between microcomputers connected together using modems.