RemoteMCU - Benefits


Easy to Use. You can simply add a REMCU lib to your project as an ordinary shared library. A minimum configuration is required. The REMCU lib can be easily used in conjunction with any other libraries and frameworks. You can use comfort of your favorite IDE and don’t need to learn special microcontroller IDE. 

Chip Peripheral Forwarding. The REMCU lib lets us to use all the peripherals of MCU or SOC from a PC or embedded computers. A user space application running on your computer has an access to the chip's hardware subsystem as if it belonged to your computer without the development of microcontroller firmware and device drivers.

This way you can easily turn an MCU-based board into USB devices like a USB-I2C, USB-CAN, USB-GPIO, ADC analyzer, signal generator etc.

Reuse Code and Documentation. The REMCU Lib provides the same API as peripheral drivers from Software Development Kit (SDK) provided by semiconductor chip vendors or third parties for MCU firmware development. This removes the difference between interacting with peripheral modules directly from firmware code or desktop PC application.
You don’t need to learn new tools but can use documentation of the SDK. You can launch and run the SDK examples on your computer and even, you can just get your firmware code that uses the SDK drivers and run its on your computer.

Interactive work. If you ever wish to conduct a quick experiment with any chip peripheral module or explore it, then REMCU is the right tool for that. It can be easily integrated in Jupyter Notebook with a C++ interpreter. This IDE is free and it lets you run and execute C or C++ code on the go. This way you can call the functions of the driver directly and control chip in real time.
It saves a lot of time that is usually spent on development of experimental firmwares. And it helps to learn how to use new peripheral blocks quicker.

With that you can easily conduct amazing experiments in chip peripherals and MCU-based devices.

Backwards-portable code. The application code written in the C programming language using REMCU is backwards-portable, meaning it can be transferred from a desktop program to the MCU program and vice-versa. The code will work just as fine on a microcontroller as it works on your computer. That's why code written on desktop with REMCU can be used to develop stand-alone chip firmware

Using with High-Level Languages. It is also possible to use the REMCU lib with high level languages like Python, Java, C-Sharp and others. To make working with them less troublesome, we provide language wrappers. With these wrappers it becomes easy to work with hardware as it is using C or C++

Hardware testing by scripting. The C++ interpreter and Python enables to easily write scripts to control the MCU-based devices.  This provides to avoid the development of a test chip firmware. You can just write the test scripts using Jupyter Notebook IDE. The testing scripts are easier to write, to debug and to maintain than compiled programs.

The test scripts are useful in checking both simple board elements and complex chips with digital interfaces. Analog and digital signal generation, capture and analysis is very easy with test scripts. Another possible use case of test scripts is to check external communication interfaces of microcontroller  boards.

Cross-platform. The REMCU lib is a cross-platform library and works on all most common desktop operating systems (Windows, MacOS, Linux). And it can also be ported to the embedded systems.

Peripheral expansion of embedded computer. Very often, an embedded Linux processor  has a limited number of peripherals. And frequently this problem can be solved with external MCU or SOC. This approach requires a development of MCU firmware and additional software (a communication protocol, kernel drivers). But the REMCU lib provides to avoid this work and to remotely control chip's peripheral modules. The software of embedded system gets real simple and no longer requires the specific OS kernel drivers.

Architecture diversity. The REMCU lib supports many different types of microcontrollers, including 8-bit, 16-bit, 32-bit MCUs and even 64-bit Systems on a Chip.

Peripheral API diversity. The REMCU Project may have several implementations of library APIs. For example, in STM32 case, we can provide SPL, HAL, MBED, Arduino APIs.

Memory operations. The REMCU lib can work with non-peripherals blocks, namely, RAM, ROM, FLASH, EEPROM etc.  You can execute the load and store operations on MCU memory. Usually, it is required to work with a DMA module. The DMA provides buffering of data for other peripheral modules when work with fast signals and interfaces.