This guide contains steps to create, build, and debug applications for the generic microcontroller unit (MCU) on an Intel® Edison board using the MCU SDK. The MCU SDK is an Eclipse*-based software development kit for Windows*, Mac* OS X*, and Linux*, used to create applications for the MCU. It is separate from the Eclipse SDK for the Intel® Atom™ processor. The components of the MCU include:

  • Scripts and tools to set environment variables, download program binaries, monitor the MCU device trace, and so on
  • Documentation for the MCU API. The MCU API is separate from the API used to program the Intel Atom processor
  • A launcher to run Eclipse and apply updates to the MCU SDK
  • Cygwin to run Linux scripts on Windows

The MCU consists of a host CPU and the MCU itself. The MCU provides developers with simple and real-time peripheral control capabilities for GPIOs, UARTs, and I2C interfaces. For Intel® Edison boards, the host CPU is an Intel Atom processor running Linux, and the MCU is a Minute Intel® architecture CPU running Viper*, a Wind River real-time operating system (RTOS) that provides basic OS function support, including thread scheduling, memory management, interrupt dispatch, and more.

The MCU application runs as an application above the Viper kernel and independently controls the peripherals that connect to the MCU. For example, it can manage the GPIO ports, control and collect sensor data, and communicate with the host Intel Atom processor. The MCU can also be used to save power by keeping the Intel Atom processor on your board asleep and having the MCU wake the processor when needed.

The MCU driver provides IPC protocol support and allows you to download the MCU application to your device.

Diagram of the host CPU and MCU architecture

The MCU subsystem

The MCU subsystem features a low-power Minute Intel architecture (IA) 486-based CPU system, with Intel® Pentium® architecture compatibility, I/O (IPC, I2C, GPIO, HSU, DMA), and SRAM. The MCU subsystem features include:

  • The Minute Intel architecture is based on the 486 with Pentium IA ISA compatibility added.
  • In the fully active D0 device power state, the CPU frequency is 100 MHz; in S0ix “active idle” sleep states, the CPU frequency drops to 38.4 MHz.
  • SRAM: 192 KB SRAM for both code and data.
  • IPC: The MCU provides an IPC mechanism that allows subsystem control as well as thread-based communication between the MCU and the Intel architecture core.
  • I2C: I2C8 and I2C9 in the system controller unit (SCU) cluster are assigned for MCU usage.
  • UART: The MCU can access UART1 and UART2, which may be used as a Linux* kernel console as well.
  • GPIO: The MCU can access all GPIO ports.
  • The MCU shares all GPIOs with the host Intel architecture.
  • PWM: MCU shares all PWMs with the host Intel architecture.
  • MCU provides a microsecond-level (1 µs) high accuracy delay API. For details, see the Auxiliary API section.
  • MCU provides a tracing capability with different log levels for debugging purposes.
  • The MCU SDK is an Eclipse-based SDK for users to create, build, download, and debug MCU applications on multiple operating systems, including Windows, Mac OS X, and Linux.

If you are designing a whole system, make sure that the host system and MCU do not conflict with each other when accessing hardware resources.

The components of the MCU SDK are pictured below:

Diagram of the components of the MCU SDK

Where:

  • JRE is the Java Runtime Environment
  • Cygwin is provided to run Linux scripts on Windows
  • Toolchain is the gcc cross-compile toolchain for Intel® Edison Linux* OS
  • Launcher is the MCU SDK launcher user interface
  • Scripts and tools are provided to set environment variables, download binary, get trace from device, and more

MCU applications

An MCU application for the Intel® Edison board is a user application that runs on Viper*, a real-time operating system provided by Wind River. The MCU application’s binary file is stored on Linux* RootFS and downloaded by the MCU driver during Linux* kernel bootup. An MCU application can independently control GPIOs and UARTs, collect and preprocess sensor data, and communicate with the host CPU (an Intel Atom processor on the Intel® Edison board), which can enter a low power state while the MCU is still running. Intel provides an MCU SDK and a set of APIs to help you develop MCU applications.

Host side interfaces

TTY Channels and several sysfs nodes listed below are defined and exposed for user-space Linux applications to communicate with the MCU side.

TTY interfaces

  • /dev/ttymcu0: A message/data transmission channel between the host and the MCU. The host application can send and receive data to/from the MCU via this interface and an MCU application can communicate with host via the host_send and host_receive APIs.
  • /dev/ttymcu1: This channel is defined as an interface to get MCU log messages.

Sysfs interfaces

  • /sys/devices/platform/intel_mcu/control: A write-only control node to load the MCU application. Currently this node is for internal use only.
  • /sys/devices/platform/intel_mcu/fw_version: The version of the MCU SDK that is used to build MCU applications.
  • /sys/devices/platform/intel_mcu/log_level: A read/write node to set and get the current MCU application log level. Supported input strings include fatal, error, warning, info, and debug.

The MCU SDK

The MCU SDK includes an Eclipse plugin for MCU application development. It includes the prebuilt tools to build, download, and debug MCU applications. Template source code is included and will be deployed while creating projects. The main features of the MCU SDK include:

  • Creating an MCU project
  • Building an MCU application
  • Downloading an MCU application to target device
  • Showing debug messages

Known limitations

The following are known limitations regarding MCU implementation on the Intel® Edison platform:

  • The maximum message size for interprocess communication between the CPU and the MCU is currently limited to 255 bytes.
  • The current Viper OS release does not support unloading an MCU user application after it is loaded. The user must reboot the device to unload the downloaded binary.
  • The MCU application update requires a Linux reboot.
  • Maximum MCU binary size is limited to 120 KB currently.
  • Due to the limitations of the current Viper OS release, the MCU OS tick value is 10 ms.
  • You cannot install the SDK in any directory that has spaces in the path name. (For example, Program Files or My Documents is not allowed.)
  • There is no floating point support in MCU. (You can build a floating point code using MCU, but it will generate runtime exceptions.)
  • The MCU is limited to 2xI2C.
  • The MCU application is limited to single-thread usage.
  • You cannot boot the MCU without first booting Linux.
  • There is no access coordination between the Intel Atom processor and the MCU. Both can configure the same I/O at once. This can potentially cause conflicts and must be user-managed.
  • The MCU SDK (Eclipse) is different and separate from the C/C++ Eclipse SDK for the Intel Atom processor.
  • The MCU I/O API is not aligned with the API for the Intel Atom processor. You must rewrite code to move from the Intel Atom processor to the MCU.
  • The MCU does not have a watchdog timer.
  • Currently, the SPI feature is not supported for the MCU.
  • It may take a long time to launch the MCU SDK on Windows under some network configurations due to Eclipse or Cygwin limitations.
  • Pin muxing (Arduino extension board configuration) must be done through the Linux interface before starting the MCU. For details, see Setting the Intel® Edison board up to test system on a chip (SoC) GPIOs.
  • PWM runtime power management must be disabled from the Linux side in order to access this module. For details, see Controlling PWM ports.
  • There are no programmable timer interrupts available on the MCU.


有关编译器优化的更完整信息,请参阅优化通知