Is it possible to program BeagleBone's PRU with nanoframework?

[afshin-parsa]

From beagleboard.org:

The Programmable Real-time Unit and Industrial Communications Subsystem (PRU-ICSS / PRU-ICSSG) is a small processor that is tightly integrated with an IO subsystem, offering low-latency control of IO pins on ... SoC devices, including the AM335x, AM437x, AM57x, and AM65x Sitara™ processors.

The PRU-ICSS / PRU-ICSSG is customer-programmable and can be used to implement simple and flexible control functions, peripherals and state machines that directly access IO pins of the device, as well as can communicate with the application cores.

A programmable real-time unit (PRU) is a fast (200-MHz, 32-bit) processor with single-cycle I/O access to a number of the pins and full access to the internal memory and peripherals on the AM3358 processor on BeagleBones (BeagleBone, BeagleBone Black, BeagleBone Green, etc.). They are design to provide software-defined peripherals as part of the Programmable Real-time Unit Industrial Control SubSystem (PRU-ICSS) and are capable of implementing things like 25 pulse-width modulators, 4 soft UARTs, stepper motor drivers and much more. Having these controllers integrated is really handy to avoid throwing in another device to control or interface to a new peripheral

BeagleBone boards are .NET capable, but the PRU can be programmed with assembly or C (to my knowledge). Is it possible to program BeagleBone's PRU with nanoframework? If so, will there be a future release for it?

Thanks,

[josesimoes]

@afshin-parsa this doesn't exist today and it's not on our roadmap or even in the suggestion box.
I'm not familiar with the BeagleBone architecture would have to investigate it.

This is the first time something like this comes up so it begs the questions:

1. How useful it is?
2. Is there a compelling use case around this?
3. What's the effort involved in making this happen?

If you can help fill in the blanks that would be helpful. 😃

[afshin-parsa]

Hi Jose, hope you're doing well.

So when newcomers want to learn and experiment with IoT and robotics they usually have two choices: Arduino or Raspberry Pi.

Arduino (and many other boards like Micro:Bit and Teensy) is a real-time micro-controller whereas Raspberry Pi (and many other boards like TinkerBoard and Rock Pi) is a full computer that can run an OS (usually Linux).

Each have their own advantages. For example micro-controllers are good for time critical applications like a flight controller. And Linux boards are great when we need to interact with a server or have a GUI. Now I should mention that it is possible to do server interaction and GUI with a micro-controller and also do time critical applications with Linux (with the real-time patch and projects like Yocto) but things get more complex.

One of Linux boards advantages is that they can be programmed with many programming languages whereas a micro-controller most of the time only support one language officially (C and MicroPython are probably the most used ones).

So the idea behind BeagleBone is that what if we combine these two? BeagleBones have a single core 1GHz Cortex A8 ARMv7 CPU capable of running Linux (which in turn means capable of running .NET) and they also have two 200MHz real-time micro-controllers (PRU), which means we get the best of both worlds. Unfortunately those PRUs are only programmable with assembly and C (to my knowledge), so they are useless for a .NET developer.

The BeagleBone is already .NET capable. My suggestion and idea is that it would be great if we could also program those PRUs with C#, and to my knowledge nanoframework and Meadow are our options when it comes to micro-controller, so here I am.

A great project that was ported to BeagleBone Blue is ArduPilot.

Thank you,

[Ellerbach]

I BeagleBone's are already supported by .NET IoT. See https://github.com/dotnet/iot/tree/main/Documentation#beagleboard
All those ARMv7 will nicely work with .NET correctly and with .NET IoT. API between .NET IoT and .NET nanoFramework are aligned, including for the Bindings, so it should make it easy for code reuse.
The PRU part is usefull if you have hard core real time, they're make for that. And I would argue that in this case, it's ok to keep those in C. That what you would anyway have to do with .NET nanoFramework if you would have to use the hard core real time capacity.