[TriEmbed] Community board "front ends" and "back ends"

Pete Soper pete at apexprotofactory.com
Tue Nov 30 14:04:07 CST 2021


The community board project will have an ESP32 single board computer 
plugged or soldered onto it as a "daughter board" to use common 
engineering terminology. The ESP32 boards of the type the working group 
has in mind are under $10 from Amazon or cheaper direct from China 
(anybody want to make a cheat sheet/advice column for buying from China 
and/or point to resources? Just do it, as Nike is wont to say. If you 
want a Wordpress user account on the TriEmbed web site, just ask). Note 
that these are "vanilla" ESP32 types as previously mentioned by Josh 
Wyatt, NOT the special types that don't have bluetooth.

The ESP32 is extremely versatile, having two "cores" and this means the 
same thing as when your PC comes with a "two core processor". Sometimes 
the board's memory is empty, sometimes it comes with "MicroPython", a 
stand alone interpreted language system named "Lua", a web-oriented 
system called "node.js" (but in a special, tiny version  cleverly named 
"try.js"), or a "real time operating system" (RTOS) supporting low level 
languages like C++ and C, and _many_ other choices findable via web 
searches. The working group thinks of these as the "front" or 
user-facing end choices of the community development board. One last 
front end on the list is an education-oriented language dreamed up at 
MIT named Scratch. This may not run on the ESP32 yet but Mike Monaghan 
has started scoping out the task of rehosting it to ESP32 and we'll 
figure out the retargeting further down the road.

The "back end" is another techie term but refers to the hardware-facing 
end. This will come in a familiar and unfamiliar flavor. The flavor 
familiar to the hard core sort of techie is called "machine language". 
This language is uttered in words made of strings of ones and zeroes 
called "machine instructions" that the ESP32's two cores "understand" 
and sequences of instructions make up "computer programs" using that 
term in the lowest-level back end context. Virtually nobody has to think 
for one second about machine language instructions: that's the job of 
the people writing or improving one of the front end choices mentioned 
above or a sub-class of those folks called "compiler people", 
"interpreter people", "virtual machine people", but mostly "people 
speaking weird languages sometimes mistaken for English" (there are very 
few left and hopefully all have a sense of humor).

But the community board will also contain one or more wildly cool chips 
called "field programmable gate arrays" or FPGAs. These are strange 
chips that will be made available on daughter boards because soldering 
them ranges from "VERY difficult" to "surely you're joking, mister 
soldering design man".

The front end of the FPGA will be one of a number of computer languages 
much like with the ESP32. But these are not familiar to the vast 
majority of people likely to read these words. Instead these range from 
esoteric to "you want HOW MANY DOLLARS per programmer to use this 
language?!?".

A major goal of the community board project is to hide these unspeakably 
difficult languages so only a fraction of the community has to see or 
think about them (those with very strange definitions of "fun"), but 
with two exceptions. First, for Nick Edgington, hereafter named 
"community board user one", there will have to be some simple C or C++ 
"library functions" that can be thought of as reusable pieces of 
programs that plug into a user's application program on an as-needed 
basis (sort of: experts, don't hate on me). The functions correspond to 
a set of common operations Nick will want doing in the FPGA. If Nick 
wants to get crazy with C++ he might want to play with "overloaded 
operators" but methinks he'd rather discover high voltage in a 
surprising place.

The working group will dream up additional Scratch features that will 
play with the FPGA(s) using mechanisms too weird to mention except to 
say ideally the back end will use a "register transfer language" or RTL 
if you want to say it fast. The RTL will be turned into a flavor of 
magic smoke called a "bit stream" and that is what makes the FPGA mimic 
any imaginable chip that fits with the number of pieces and parts in the 
specific digital or "mixed signal" (both digital and analog) FPGA chip 
package. Ideally once the smoke is in place then when that chip is 
powered up, whether in its daughter board position on the community main 
board (aka "motherboard") or in situ in somebody's Cool Device[tm] then 
the personality of that chip can be in evidence with its operation. That 
is, there will be some means of arranging for the FPGA chip and a few 
other parts to "stand alone" for certain applications.

If you didn't follow any of this please ask questions. The people on 
this list are exceptionally polite and helpful.

More on the ESP32:

https://en.wikipedia.org/wiki/ESP32?wprov=sfla1
<https://en.wikipedia.org/wiki/ESP32?wprov=sfla1>
More on Scratch:

https://en.wikipedia.org/wiki/Scratch_%28programming_language%29?wprov=sfla1 
<https://en.wikipedia.org/wiki/Scratch_%28programming_language%29?wprov=sfla1> 


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.triembed.org/pipermail/triembed_triembed.org/attachments/20211130/628e7271/attachment.htm>


More information about the TriEmbed mailing list