I tend to have a lot of hobby projects on the go at any particular time. Occasionally, I even manage to finish one. More rarely, one actually works.
I also have a soft spot for 8-bit microprocessors and microcontrollers. Thus, many of my hobby projects are based on the Arduino Nano, Uno, or Mega platforms.
Take my Awesome Audio Reactive Artifact, for example. This little rascal is currently powered using an Arduino Uno, which is driving 145 tricolor NeoPixels. In turn, these NeoPixels are mounted under 31 defunct vacuum tubes (see also Awesome Audio-Reactive Artifact meets BirmingHAMfest).
The Awesome Audio Reactive Artifact also includes an ADMP401-based MEMS Microphone breakout board (BOB), which costs $10.95 from the guys and gals at SparkFun. In turn, this feeds a cheap-and-cheerful MSGEQ7 audio spectrum analyzer chip, which relieves the Arduino of a lot of processing pain (see also Using MSGEQ7s In Audio-Reactive Projects).
Sad to relate, 8-bit Arduinos sometimes run out of steam. Consider my Countdown Timer, for example, whose task it is to display the years (YY), months (MM), days (DD), hours (HH), minutes (MM), and seconds (SS) to my 100th birthday (see also Yes! My Countdown Timer is Alive!).
This little scamp employs 12 Lixie displays, each of which contains 20 NeoPixels, which gives us 240 NeoPixels in all. As the sophistication of the effects I was trying to implement increased, so did my processing requirements. Thus, I decided to use a Teensy 3.6, which features a 32-bit 180 MHz ARM Cortex-M4 processor with a floating-point unit. Furthermore, the Teensy 3.6 boasts 1 Mbyte of Flash memory for code, along with 256 Kbytes of RAM for dynamic data and variables.
All of which brings us to the pièce de résistance in the form of my Pedagogical and Phantasmagorical Prognostication Engine (see also The Color of Prognostication). This bodacious beauty sports two knife switches, eight toggle switches, ten pushbutton switches, five motorized potentiometers, six analog meters, and a variety of sensors (temperature, barometric pressure, humidity, proximity). All of this requires a bunch of analog and digital general-purpose input/output (GPIO) pins.
Furthermore, in addition to a wealth of weird, wonderful, and wide-ranging sound effects, the engine is equipped with 354 NeoPixels. These could potentially be daisy-chained from a single pin, although I ended up partitioning them into five strands. More importantly, the various effects require a lot of processing and memory.
When things finally started to come together on this project, I was initially thinking of using an Arduino Mega to power the beast, mainly because it has 54 digital pins and 16 analog inputs. On the downside, we have to remember that this is only an 8-bit processor gamely running at 16 MHz with a scant 256 Kbytes of Flash memory and 8 Kbytes of RAM. Furthermore, the Mega doesn’t have a floating-point unit (FPU), which means that if you need to use floating-point operations, this will really impact the performance of your programs.
But turn that frown upside down into a smile, because the boffins at Hitex (hitex.com) have taken the Arduino Mega form factor and slapped an awesome Infineon Aurix TC275 processor down on it.
These processors are typically found only in state-of-the-art embedded systems. they rarely make it into the maker world (like the somewhat disheveled scientist who is desperately in need of a haircut says in the movie Independence: “They don’t let us out very often”).
The result is called the ShieldBuddy. As you can see in this video, I just took delivery of my first ShieldBuddy, and I’m really rather excited (I say “first” because I have no doubt this is going to be one of many).
So, what makes the ShieldBuddy so special? Well, how about the fact that the TC275 boasts three independent 32-bit cores, all running at 200 MHz, each with its own FPU, and all sharing 4 Mbytes of Flash and 500 Kbytes of RAM (actually, this is a bit of a simplification, but it will suffice for now).
There’s no need for you to be embarrassed — I’m squealing in excitement alongside you. Now, if you are a professional programmer, you’ll be delighted to hear that the main ShieldBuddy toolchain is the Eclipse-based “FreeEntryToolchain” from HighTec/PLS/ Infineon. This is a full-on C/C++ development environment with source-level debugger and suchlike.
But how about if — like me — you aren’t used to awesomely powerful (and correspondingly complicated) Eclipse-based toolchains? Well, there’s no need to worry, because the guys and gals at Hitex also have a solution for the Arduino’s integrated development environment (IDE).
Sit up straight and pay attention, because this is where things start to get really clever. In addition to any functions you create yourself, an Arduino sketch (program) always contains two functions: setup(), which runs only one time, and loop(), which runs over and over again.
Now, remember that the ShieldBuddy has three processor cores, which we might call Core 0, Core 1, and Core 2. Well, you can take your existing sketches and compile/upload them for the ShieldBuddy, and — by default — they will run on Core 0.
You could achieve the same effect by renaming your setup() function to be setup0(), and renaming your loop() function to be loop0(), which explicitly tells the compiler to target these functions at Core 0.
The point is that you can also create setup1() and loop1() functions, which will automatically be compiled to run on Core 1, and you can create setup2() and loop2() functions, which will automatically be compiled to run on Core 2. Any of your remaining functions will be compiled in such a way as to run on whichever of the cores need to use them.
Although each core runs independently, they can communicate between themselves using techniques like shared memory. Also, you can use interrupts to coordinate and communicate between cores.
And things just keep on getting better and better, because it turns out that a NeoPixel library is already available for the ShieldBuddy.
I’m just about to start experimenting with this little beauty. All I can say is that everybody needs a ShieldBuddy and my ShieldBuddy is my new best friend (sorry Little Steve). How about you? Could any of your projects benefit from the awesome processing power provided by the ShieldBuddy?
Sounds like a great product. Can the cores intercommunicate and if so, is this feature implementable in the sketches? How about allocating resources between the cores?
I’m still trying to wrap my brain around this — but my understanding at the moment is that the RAM is divided into three blocks — one block for each core — I’m not sure if each core has 500KB or if that’s divided between them. What I do know is that each block of memory appears in the memory map two times (well, seemingly at two different start addresses) — my understanding is that one of these addresses/pointers is for the core itself, and the other is so the other cores can see this core’s memory.
Also, if you just declare your global variables as usual, they go into some sort of general pool where they can be accesses by all the cores but a bit slower — or you can declare them in such a way that they are assigned to the memory associated with a particular core.
One way the cores can communicate is via shared memory. Another way is that each core can initiate interrupts to the other cores. There may be other ways, but it’s a big manual LOL
As far as I know, all the cores share all of the peripherals — but take a UART, for example, there’s a way for one core to say “are you busy? If not, I want to reserve you” (all in one instruction so another core can;t sneak in between the query and the request).
Aah,.but is this implementable in a sketch?
I believe so — my understanding is that they’ve augmented the Arduino functions like digitalRead() and digitalWrite() with some additional functions relevant to their processor — so you can run existing Arduino code as-is — but if you want to write for this specific processor, you can also use the extra functions they’ve provided
On the other hand if you want something really fast, look at the Teensy 4.0 which runs at 600 MHz. It only has one core and not nearly as many I/O pins though.
Only one core? “That’s so 20th Century, my dear” LOL
I support Elizabeth, Teensy cost $19.90, ESP32, dual core @240MHz with WiFi cost below $5. And they ask for $140??? You can buy raspberry PI or Beaglebone X15 for this sort of money. It is an absurdity.
My understanding is that the way the ShieldBuddy came about was as a project by a Student Intern. Quite apart from anything else, this is a great way to become introduced to the tri-core TC275 and to the whole idea of having three processors running independently but with the ability to communicate with each other. All I know is that I’m having a lot of fun — and, after all, isn’t that the important thing LOL
The Onion Omega2 with expansion shield is less than $30 for 580 MHz with WiFi and Linux. Still not as many I/O pins as the ShieldBuddy but I can have a lot of fun once I have time to play with it.
Ah, there’s the rub — time is the most precious commodity — when I was young, I would have loved to have access to the boards we have today, but I couldn’t afford them. Now companies offer me development boards all the time, but I have to say “Nay” because I don’t have the time to learn about them — that’s the big advantage to me of the ShieldBuddy — since it’s the same form factor as the Arduino Mega, I can just drop it into the existing slot in the Prognostication Engine — and, since it can use the Arduino IDE (along with its Eclipse framework for more experienced programmers), I was up-and-running almost immediately.
It’s not just having the three separate cores (although having three programs running independently has a lot of attraction) — as you say, it’s the awesome number of pins that gives the ShieldBuddy a real edge 🙂
Infneon’s Tri_core has always been a little confusing. From their literature “The TriCore™ Instruction Set Architecture (ISA) combines the real-time capability of a microcontroller, the computational power of a DSP plus the high performance and price features of an RISC load/store architecture in a compact reprogrammable core.”
We have used their Tri-Core in our products since they first came out. Initially they were single Tri-Cores (TC1xxx) and the newer ones now have dual Tri-Cores (TC2xxx). So I assumed that the TC275 was a dual Tri-Core also. But, from the datasheet, apparently it does have 3 cores, described as :
Two 32-bit super-scalar TriCore CPUs
Power Efficient scalar TriCore CPU
I don’t think the three cores are the same, and the “TriCore” reference does not refer to the fact that the TC275 has three cores (as noted above). I’m not sure exactly what all that means (I’m definitely not an expert on their chips) but nonetheless it does have one WHOPPING pile of horsepower.
I’m JEALOUS!!!
Enjoy!
I was enjoying myself until you made my head hurt LOL
Your Prognostication Engine could certainly use both the three cores (assuming that you can get them to play nicely together) and the large number of pins that this provides.
Never in the field of human endeavor will a Prognostication have Prognosticated so fast and so furiously 🙂
Wait until that hitex license times out ? . “free entry” is entry .. you get one year and that’s it.
Try to get a schematic ? … crickets. Since the olden days, all dev boards I have ever owned have had a schematic – except for this one.
No thanks.
There are better supported devices (and boards) than this setup. Especially the Teensy as someone else has previously pointed out
I love the Teensy — and I’m currently having a lot of fun with the Seeeduino XIAO (https://www.clivemaxfield.com/say-hello-to-the-seeeduino-xiao/) but the ShieldBuddy is awesome for what I want to do with my Prognostication Engine — re the license — I’ll cross that bridge when I get to it (I may have to rely on my winsome smile 🙂
Perhaps too tangential to be worth posting, but your mention of NeoPixel reminded me of Nixies, which in turn fired my Dalibor Farny neurons. I am certain you’re aware of his incredible operation, but anyone who is not is in for a treat ( https://www.daliborfarny.com/ ) Enjoy that rabbithole!
Again, may not be relevant for this Maxpost, or any post, but wanted to share.