MicroEJ OS API Specifications

Features upon request

Block Features API
CORE Secure Multi-Application Engine: Virtual Processor/JVM java.io, java.lang, java.lang.annotation, java.lang.ref, java.lang.reflect, java.util, java.security, java.util.concurrent
Memory Management: Smart RAM Optimizer ej.bon
CPU & Power Management ej.power
Components Management: Static/Dynamic Loader, Sandboxing ej.kf, ej.components
Languages: Multi-Languages Interface (SNI, Shielded Plug) ej.sni, ej.sp
Utilities, Logger, Localization – Test: Test Suite Harness java.util.logging, org.apache.logging.log4j, org.slf4j, android.util, ej.nls, com.is2t.testsuite.support, org.junit
IO Sensors, Actuators android.hardware, ej.com.io
GPIO, DAC/ADC, PWM ej.hal.gpio
NUM Numerical Computing, Linear Algebra, Signal Processing, Ranges ej.numeric, ej.numeric.linear, ej.numeric.signal, ej.numeric.range
FILE & DATA Persistent Data, XML, JSON ej.bon, org.kxml2, org.xmlpull.mxp, org.json.me
File System (USB MS, SD Card, external flash) java.io, ej.wadapps.storage
COMM Wired: Ethernet, USB, Serial (UART, USB Serial, Bluetooth Serial, I2C, SPI), CAN, USB Host java.net, ej.ecom, ej.com.comm, ej.ecom.io, ej.ecom.can, javax.usb
Wireless: 2G/3G/4G, Wi-Fi, Bluetooth, BLE, Z-Wave, WM-Bus, NFC, ZigBee java.net, ej.ecom.bluetooth, android.bluetooth, android.bluetooth.le, ej.driver.zwave, ej.ecom.wmbus
NET & SEC Internet Protocols/Cloud: UDP-TCP/IP, IPv6, 6LoWPAN, HTTP/HTTPS Client, HTTP & REST Server, REST Client, SNTP Client, Netlink Sockets, Websocket, protobuf java.net, javax.net.ssl, com.is2t.server, ej.rest, android.net, com.is2t.netlink, ej.websocket, com.google.protobuf
Security: SSL/TLS client & server, Certificates/KeyStore, Crypto, DTLS, SAML javax.net.ssl, java.security, java.security.cert, javax.crypto, org.eclipse.californium.scandium, org.opensaml
IOT Middleware: MQTT, CoAP, DDS, AllJoyn, XMPP, AMQP, Thread org.eclipse.paho.client.mqttv3, org.eclipse.californium.core, ej.dds, org.alljoyn
GUI MicroUI: Drawings, Images, Fonts, Event Manager ej.microui
MWT: Dynamic Layouts ej.mwt
Widgets, Transitions (Flows), Composite Layouts, Styling Motions, Gestures
ej.widget, ej.color, ej.transition, ej.composite, ej.style ej.motion, ej.gesture
STORE App Launcher, Lifecycle Manager, App Browser Client ej.wadapps, ej.wadapps.admin, ej.wadapps.client

MicroEJ OS CORE

MicroEJ OS Core provides a secure engine that can run multiple applications. It is based on an optimized – for performance – and compact – for footprint: down to 30 KB – Java virtual machine (JVM) running its own compact HW-independent code so applications can be binary portable across the variety of embedded processor architectures and do not depend on a particular C/C++ compiler. The JVM performs runtime checks and exception handling well-known by Java developers for easing application robustness and debug.
The MicroEJ OS Core can run on “bare metal” hardware or on top of any underlying real-time operating system (RTOS) such as FreeRTOS, Micrium µC/OS, Express Logic ThreadX, SEGGER embOS, Green Hills Sofwtare Integrity, Wind River VxWorks, Linux and others. Java threads are managed by the JVM predictive scheduler – which itself is a thread of the underlying RTOS in the case MicroEJ OS runs on an RTOS.
MicroEJ Core OS provides a smart RAM optimizer (known as garbage collector or gc) for the management of Java objects so there are no memory leaks or rogue pointers, and no memory fragmentation.
MicroEJ OS also uses a shared C-Java heap for immortal objects (fixed address, untouched by gc) that allow zero copy buffers and are compatible with DMA systems. MicroEJ OS manages static persistent objects in flash called immutable objects.
MicroEJ OS controls the CPU allocation per application to ensure quality of service. It manages app permissions to access system resources in order to enforce security policies.
MicroEJ OS also provides an efficient power management API to control the power states of HW components.
MicroEJ OS allows static and dynamic app code loading and manages the lifecycle of binary apps – install, start, stop, uninstall.
MicroEJ OS uses a sandboxing technique to isolate the execution contexts of binary apps so apps cannot crash each other or the entire system. It also allows efficient inter-app communications. MicroEJ OS controls which OS API are available to apps – as defined by the device software developer – so apps cannot access critical system functions – whether for footprint, security, business or IP protection reasons.
MicroEJ OS core provides an efficient Java-to-C native interface so integration of legacy C/C++ code to MicroEJ OS or applications is optimal.
Additional utilities, logger, and localization features are available to ease application development.
A test suite harness allows hardware-in-the-loop (HIL) testing.
Performance traces can be obtained for graphics (frame-per-second or FPS), CPU load (%),and threads.

MicroEJ OS LIBRARIES

The IO library allows access to HW I/Os and controls (like GPIO, DAC, ADC, PWM…) through the native hardware abstraction layer (HAL) with a high-level generic Java API. It allows to monitor device movement such as tilt, shake, rotation, or swing from direct user input or from physical environment. It also allows to acquire raw sensor data and control actuators through a sensor API for:

IO

  • Acceleration
  • Temperature
  • Magnetic field
  • Humidity
  • Proximity
  • Step
  • Rotation
  • Pressure
  • Proximity
  • Light
  • Gyro
  • Gravity
  • Heartbeat
The NUM library allows to process digital data/signal, prototype and test mathematical algorithms. It is based on a unified API, small and self-contained. It is ideal for numerical computing and provides operations such as:

  • Numerical functions (linear algebra)
    • Matrix and vector computation (e.g. Eigen decomposition)
      • FloatMatrix, DoubleMatrix: 32-bit & 64-bit real matrices
      • ComplexFloatMatrix, ComplexDoubleMatrix: 32-bit & 64-bit real complex matrices
  • Scientific functions (e.g. exponential & trigonometry computation)
  • Polynomial computation (e.g. factorization: LU, LUP)
  • Signal Processing (e.g. FFT)
  • Ranges
The FILE & DATA library allows to manage persistent data, manage HW storage, and supports standard data formats. It provides persistent data formats such as:

  • XML
  • JSON

It supports file system on:

  • Flash
  • RAM
  • SD Card
  • USB Mass Storage
The COMM library allows to connect to any types of networks, and write portable code across stacks. It provides wired connectivity for:

  • Ethernet
  • USB Host
  • Serial (UART, USB Serial, Bluetooth Serial, I2C, SPI)
  • CAN
  • Modbus
  • Fieldbus

It also provides wireless connectivity for:

  • 2G/3G/4G
  • Wi-Fi
  • Bluetooth, BLE
  • Z-Wave
  • WM-Bus
  • NFC
  • ZigBee
The NET & SEC library allows to support network protocols and write portable code across stacks. It allows to connect to Cloud infrastructure and perform secure communications. It provides support for Internet protocols:

  • UDP-TCP/IP
  • IPv6, Multicast
  • 6LoWPAN
  • HTTP and HTTPS client
  • HTTP and REST server
  • REST client
  • SNTP client
  • Netlink sockets
  • Websocket
  • protobuf

It provides support for security protocols:

  • SSL/TLS client and server
  • SAML
  • DTLS
  • Cryptographic keys & certificates storage (KeyStore)
  • Cryptographic operations
The IoT library allows to support standard IoT middleware & frameworks. It provides support for middleware and frameworks such as:

  • MQTT
  • CoAP
  • DDS (Data Distribution Services: publish/subscribe middleware)
  • XMPP
  • AMQP
  • AllJoyn
  • Thread
The GUI library provides scalable 2D graphics and touch for various displays and configurations. It allows portable apps for consistent user experience across all devices. It includes:

  • Micro Widget Toolkit (MWT – ESR011): universal widget-based framework
  • Embedded Java User Interface (MicroUI – ESR002): graphics base library

It provides support for:

  • MicroUI
    • Drawings
      • Rich vector 2D graphics
      • Raster decoding & processing
      • Antialiasing, transparency, clipping
      • 8-bit alpha channel layer management for graphical interfaces with transparency
      • Support of full range of available displays (64×32, 128×128, QVGA, WVGA, WQVGA, SVGA, WSVGA, HD, XGA, WXGA)
      • Color depth: from 1-bit to 24-bit (+ 8-bit alpha)
      • All pixel aspect ratios
      • Internationalization: NLS (native language support)
    • Images
      • Any image format taken as input at application deployment stage
      • PNG decoding at runtime – or other suitable formats
      • Dynamic deformation
      • Flying images for pointers
    • Fonts
      • Any image format as input + TTF and OTF
      • 1, 2,4, 8-bit anti-aliasing
      • Latin / Arabic / Asian, scalable
    • Event management
      • Event source abstraction: pointer, keyboard, keypad, command (buttons), state (switches)
    • LEDs
  • MWT & Widgets
    • Dynamic layouts: Grid, list, border, flow, scroll, split, custom
    • Button, image, label, progress, radio, slider, text, toggle, spinner…
    • Styling
      • Dynamic look & feel change (similar to CSS)
      • Fonts, images, colors, drawings
    • Flows: Page navigation management, transition effects
    • Media compatibility: Video stream
    • Motions: Provides a timestamp to create a specific motion (linear, bounce, elastic, easings)
    • Gestures: Touch & multi-touch
The STORE library allows to create an ecosystem through the application store server infrastructure. It allows to manage apps and resources for enhanced security. It provides a complete app lifecycle management framework leveraging the MicroEJ Core OS Components Management.

It allows to create future-proof products by expanding them with new apps/services in the field. The application store server infrastructure allows to industrialize app creation and manage open or closed ecosystems.

It provides a robust and safe execution environment with:

  • Secure data transmission
  • Reuse of already existing infrastructure
  • Support of multiple protocols
  • Dynamic download of apps
  • Heterogeneous infrastructure: one app is compatible with multiple versions of firmware and hardware
  • Cloud framework connectors
Back to Top