Introduction

This is my very first project that I post here in Hackaday.io, it is about an old project revamped
recently that I am going to share here, besides on my channel in YouTube.

This system, that I called Network Shared Control (NSC) provides both event-driven execution and the ability to handle RPCs. I developed it in 2003 as an operating system and virtual machine, designed to operate on a series of devices built around the Atmel (now Microchip) ATmega32 (same family of Arduino's) microcontroller,  and sold the IP rights to a company that commercialized those products. In 2012 the company shut down and the exclusivity upon the rights dropped.
So, after having purchased a number of devices I also extended the system into a framework and wrote an AppWizard to create templates that can be directly written in C and compiled with the Imagecraft ICC AVR compiler (or avr-gcc by changing some parts).

In fact, the original system was designed to accepted only IL programs for the OS' virtual machine generated with a specific IDE, compiler and network deployment tool, that I developed too.

While currently the code is written for the ICC AVR compiler, it can be relatively easily ported for AVR-GCC, and the AppWizard is ready for generating also code for GCC, however at the moment the AppWizard is a legacy program made with Visual Basic (and VC++) even though it seems to work fine even in Windows 10.

Networking operations are supported through the SFBP protocol (it is a simple protocol that have a small payload, well suited for command-oriented, multidorp, half duplex, masterless communication over a serial line such as RS485), however it can be excluded or replaced with other modules, in fact I also have made, but not yet finished, a MIDI module to directly drive musical instruments.

Why event based programming?

Event driven programming is based on a paradigm where unlike linear programs that work executing tasks sequentially in a infinite loop, specialized functions are called by the underlying system when specific events happen, executing the tasks intended for that specific events.

This allows to write smaller, more efficient and less error prone programs.

They are particularly indicated for programs that need to react on external stimuli, allowing to avoid for polling those events, and making the program less complex and clumsy.

Why RPCs?

RPCs or Remote Procedure Calls are a mechanism that allows to call functions that are located into a physically different device, often at distance. This means that you can seamlessy write a program that run into a device A that interact directly with the functions you wrote for a device B, may be located 1 km each others ...or may be just few inches.

Unfamiliar with these concepts? I have made a series of videos to explain this system, this one is the first introcuctory part:

What can be used for

The framework can be used to develop single, stand alone, and distributed event based applications for embedded microcontrollers.

The devices that I have designed are controllers similar to Arduino, however they was not originally meant to host external extensions (shields), save some exceptions, and have full featured inputs (with decoupling and filtering) and outputs (open collector up to 40V 300mA, typically) and have an RS485L transceiver for field networking communication (up to 127 deices, up to 1 Km, bus and star mixed mode supported for short routes).

Some of them also have powerful relais on board (can withstand spikes up to 300A for few ms) while others have the ability to read analog inputs and one wire thermometers (DS1820) and iButton keys, or sport a display such as the LCDG that have a 64x128 display + 2 OC outputs + 3 logic inputs, analog input, thermometer, 4 keys keyboard and RTC crystal on board.

Finally these devices are ruggedly built with on board power supply that can...