- Welcome to The Bootloader.
I'm Paul Cutler.
- And I'm Tod Kurt.
The show works like this.
In each episode, we bring about six things
that we're excited to share,
chatting about each for about five minutes.
For detailed show notes and transcripts,
visit thebootloader.net.
- We now have stickers.
If you're interested in getting a two inch
by two inch sticker, visit thebootloader.net
and click news and the link to the form is there.
fill it out and I'll send you a free sticker.
With that out of the way,
Liz Clark has joined us today for a second time.
Liz, there used to be a podcast I listened to
and whenever a guest would come on
for the second or third time,
they officially become a friend of the show.
So you're our first official friend of the show.
- I'm honored, thank you so much.
Thanks for having me again.
- Thank you, Liz.
- What's the first one that you brought for us?
- So my first pick is something I've been using a lot lately
from my work of Adafruit, and it's Raspberry Pi Connect.
And what it is is it's a new service,
or at least it was new to me,
that comes with the new distributions of Raspberry Pi OS.
So if you've been using the newest Trixie
or even Bookworm before that,
and you saw this little circle icon up at the top
next to the status, that's what that is.
And what it lets you do is when you log in,
you're able to manage all of your Raspberry Pi devices.
And it's not software dependent,
it's actually hardware tied.
So even if you do a new install of the OS,
your devices still appear registered, which is nice.
And what you can do then is, in a browser,
you can log into your Raspberry Pi
either with a remote shell session or a windowed session.
So that means you can have it just powered on headless,
but have a full browser view with your keyboard, your mouse,
and you can use it right at your computer, which for me,
I don't have a lot of space in my desk, so that just
is wonderful.
I don't have to have another keyboard and mouse.
I don't have to capture it with my capture card.
Don't do any of that.
But the best part, I think, is you can also
copy and paste to the Pi.
So if you're doing development and you're
trying to do, oh, I don't know, E Ink in its, for example,
and you're trying to find different things on a data
sheet, you can copy and paste really easily.
and it makes it really nice.
And then also it means I don't have to log into GitHub on a Pi.
I can copy it out and do a PR on my home machine.
That has been a lifesaver recently.
And even recently, I did a project for Halloween
for Adafruit, which used a Raspberry Pi.
And it used a camera.
And for the demo, I wanted to do a screen recording to show it
happening in real time.
And in the past, it would have been
like a mess of cables all over my apartment
trying to get the capture card and everything.
But for this, I was able to just set up the Pi
in my usual filming spot, film,
and then I was just doing a regular screen grab
of my computer of the Raspberry Pi Connect window,
and it was just beautiful.
So if you're doing a lot of Raspberry Pi stuff,
highly recommend setting up Raspberry Pi Connect.
Really easy, and it just makes the workflow a lot simpler.
- How is performance, especially in a windowed mode,
when you're connecting remotely?
Is it jerky at all?
Is it smooth?
- No, it's super smooth.
'Cause sometimes I've even forgotten
that I'm in Raspberry Pi Connect
if I maybe started with OBS
and I grab the keyboard and mouse
that's actually connected to it,
and I'm using it in the browser window now,
so then I remember, oh wait,
I can just use my regular keyboard and mouse,
I don't have to use the thing in my lab.
So it's really smooth, which is surprising.
- So for Raspberry Pi Connect,
I've got some Raspberry Pi servers
that I connect to via usually SSH,
but sometimes VNC, but the VNC stuff's a little janky,
and so this is kind of interesting,
but does the Raspberry Pi Connect stuff work
for non-GUI mode, do you know?
It seems like it's a GUI mode thing.
- That I haven't checked.
It might be GUI only.
I haven't checked that.
- Yeah.
- So that would be something I keep in mind.
- Yeah, this is definitely cool if you don't have,
like my servers are right over here,
I can touch them with my hand,
but if you're in a different state, perhaps,
different country, you can still have access
to your computers.
That's pretty cool.
So Paul, what's your first one this time?
- My first one is the OpenBook Touch.
Joey Castillo has announced the OpenBook Touch,
an open source e-reader coming soon on CrowdSupply.
I interviewed Joey back about three years ago
in episode 22 of the CircuitPython show.
Joey's the creator of the SensorWatch
and the SensorWatch Pro among other things.
And these were PCBs that allowed you to upgrade
Casio's iconic F91W watch by swapping it out
with a new PCB that adds an LED and infrared light sensor
and more.
He ran two successful crowd supply campaigns
for the SensorWatch and the SensorWatch Pro.
So I have a lot of confidence in his latest campaign
for the OpenBook Touch.
He's been working on it for a while
and it's exciting to see it coming soon on crowd supply
where it's described as a long standing effort
to build an affordable, open source, hackable,
DIYable ebook reader.
It features everything you would expect in an e-reader
And here's just a few of the stats.
It's got an ESP32 S3 microcontroller
with support for Wi-Fi and Bluetooth,
a 60 megs of program memory, eight megs of RAM,
a 4.26 inch 480 by 800 display
with warm and cool front lights.
The touchscreen is capacitive and it's got a micro SD card
so you can store all your eBooks on it.
And the battery, it's got a LiPo battery with 1800 milliamps
with integrated charging and monitoring
USB-C Type-C connection, all in about a package that's 77 by 118 by less than 10 millimeters thick
and only weighs three ounces. Everything will be open source, including the software, documentation,
KiCad schematics, board files, and the enclosure. By using the ESP32-S3 processor, it's got plenty
of horsepower for EPUB documents, and with the S3's low-power RISC-V coprocessor, it should
achieve days to weeks of reading time and months of standby time with its user-replaceable
LiPo battery.
Under the hood, it's using the ESP-IDF framework and FreeRTOS, so no more Arduino workflows
like earlier prototypes had, though it has been tested with both Arduino and CircuitPython.
The project is coming soon on crowd supply, and I'm excited to see an open-source e-reader
that's not tied to an online bookstore full of DRO.
Yeah, I was just looking at like I've been trying to get back into to reading more more frequently and e-readers are the obvious solution
Doing it on the phone or the tablet seems very distracting. But like the big
Behemoth out there is the Kindle which is amazing, but it's tied into the whole Amazon thing
hasn't Joey been working on the open book project for like years like it seems like I've seen like
Yes, every time I see like he posts on socials. There's like a new better version that's come out
This looks like the best one but so far
I love Joey's work. I'm sure I'd be curious to chat with him about it. I'm curious if he had
situ issues with sourcing the actual E Ink display because often the
Manufacturers like they'll stop with no warning with the chip set. So I'm curious if that's what's part of the delay, but
It's really cool. That's a 800 by 480. Like those are really nice and I just his work is great. His documentation is great
So really cool. See you come out
Yeah, and he he knows low power design like all that work. He did on his watch
Replacement where you saw him sweating the micro amps to get it down because it's a watch it has to last for a long time
So I'm sure he's do been doing the same thing for this this e-reader
Which you don't really think of as being the thing you have to plug in very often
We're recording this on Thursday, October 30th and Tod. Are you going to?
Supercon this weekend because if you are Joey, you'll be there and you might be able to see it in person. Oh
And on Halloween and I'm going and it'd be wonderful if I see him
He's he's always he's always very very pleasant whenever I run into him. So yeah, it'll be nice
Check it out and give us a book report when it won't for the next episode
book report
I saw he also has simple add-ons. He's doing two that are like an homage to the open book. It's like these little mini illuminated
That's cool. Yeah, did their screens with the book covers? So you might have some of those
(laughing)
- All right, Tod, what's your first one for us?
- All right, so you can now design circuit boards
with code, well, sort of.
So let's say you want to design a circuit board.
This is a little bit of a refresher
on how circuit board design works.
As you are both aware, but maybe not some in our audience,
usually that begins with a schematic,
a flowchart-like drawing that describes
the logical connections between the parts of your circuit.
From the schematic, you then create the PC board layout.
This is the physical layout of exactly which components
you'll be using and exactly where they'll be on the circuit board.
In your schematic, you might just have noted a 500-ohm resistor,
but it's during the PCB layout where you choose exactly which of the thousands of 500-ohm resistors that your circuit needs.
At the end of this design process, you'll have two drawings,
the schematic for logical design and the PCB for the physical layout.
But what if instead of starting with the schematic drawing, you started with code,
and that code then gets turned into the PCB layout?
This is what the Atopile project is attempting to do.
That's A-T-O-P-I-L-E. Atopile is a few things.
First, it's a Python-inspired domain-specific language
for specifying components and connectivity between them.
Like the way you would assign variables
and properties to variables and stuff,
you do the same thing, but now you're assigning
properties and connectivity to components.
Like code, you design little sub chunks of functionality
like LED status light, keyboard matrix,
voltage regulator, or even RP2040 microcontroller.
And each of these subcircuits
then become a reusable function in AdaPile.
And so AdaPile is also a package repository,
sort of like NPMJS or PyPI,
but the modules it knows about are these subcircuits.
And like in other languages, you can install them
and then import them into the top of your code
and use them in your code, I mean, circuit.
(laughs)
More importantly, these Adapah modules
contain KiCad PCB layout chunks.
So when you import the RP2040 package,
it contains the entire KiCad PCB layout
for an RP2040 microcontroller circuit
like what's on the Raspberry Pi Pico.
So the somewhat tricky power trace routing,
the correct crystal oscillator and capacitors
critical for the chip's function
are all specified here and laid out properly
according to the guidelines in the data sheet.
having those tiny but important details bundled up
is really nice.
Like normally you'll be copying and pasting those
from previous known working circuits.
And so now you just say, import RP2040
at the top of your out of file file and you get all that.
And so out of pile is also a compiler.
Once you have your out of pile code written
using these modules and some of your own,
the out of pile compiler generates the PCB.
When you open the board in KiCad,
you'll see the sub modules that are fully routed,
but the connections between them are not.
so you maybe just move them around
and then quickly hand route the connections between
and you're bored to be finished.
From code to finished PCB, how amazing is that?
Well, that's the dream. (laughs)
And it's not even the end goal for the devs.
By moving the logical design,
the schematic side of things,
into this hierarchical code-like way of specifying it,
the AdaPile devs are hoping to leverage LLMs
to help design circuits.
To do this, they have a first-party VS Code extension
and uses cursor AI to help with writing the Adopile code.
Apparently it's pretty good at writing Adopile code.
I mean, you know,
me as someone who's only been playing with it
for about a week,
it writes a better Adopile code than me.
I've been playing with it, it's interesting.
I'm a bit skeptical.
There's a bunch of gaps in the package manager,
sort of like, you know,
how useful is Python without all the cool libraries
that exist out there?
It's hard, if you're having to reinvent everything,
it's kind of tough.
It's the same thing in KiCad.
It's like, KiCad is much easier
because of all the available components already there.
You don't have to draw every component.
You can import the libraries and stuff.
Also in regular circuit design,
there is this back and forth that usually happens
between the schematic design and the PCB design.
It's called forward and backward annotation.
You know, you'll be laying out the PCB
and you'll wanna make some small changes.
And so you make those changes
and then you have that update the schematic.
And this sort of back and forth happens a lot.
AutoPilot doesn't support this concept.
its flow is very much one way from code to PCB layout.
It breaks the way that you think of your design
if you're used to that way of thinking,
but it's very similar to how code works.
You don't take your machine code and make changes
and then push that back up to your source code.
Related to me, this got me looking into KiCad
and KiCad supports design blocks in a schematic view.
These are reusable schematic functional modules
that you can just plop down,
sort of similar to the reusable module of Adopile,
but KiCad doesn't yet have
the corresponding PCB layout side of that,
which is the part that for Adopile
is really attractive to me.
'Cause layout of this is really kind,
like layout of some of these subcircuits,
these complex subcircuits that are high frequency
or have weird capacitance, like RF circuits
is a real tricky thing.
So having that already done for you and done once is nice.
And also I miss schematics.
The code view of AdaPal is nice,
but like well-structured code,
a lot of the implementation of a circuit
is hidden behind the sub-modules,
but these sub-circuits.
And when you're trying to figure out a problem
with your circuit, it's often useful
to get a holistic view of how the whole thing works,
which you can get with one schematic page,
but it's hard to do that with these sort of
well-structured code that AdaPal encourages.
So I'm gonna keep playing with AdaPal.
Seems really interesting.
We used to design FPGAs and ASIC chips all with schematics,
now they're almost always done in the VHDL or VLog languages.
So there's precedent for moving circuits from a schematic to a full code-based workflow.
But yeah, and I'm not even touching the LLM side of things, because that's like a whole
other can of worms I don't want to look into yet.
But yeah, it's interesting.
And I think if you're more a code-thinking person, Adapile might be an interesting way
for you to get into circuit design.
So is Adapile to PCBs like OpenSCAD is to CAD design?
I think a little bit, yeah.
Yeah, yeah.
That's a good way to think about it.
Also similarly one way, where it's like your source code and it gets compiled down into
the solid model.
I did think it was interesting.
I was flipping through some of their documentation and you're right, they recommend using cursor
as your IDE.
And in the docs, they specifically call out that LLMs have gotten good at writing ATO
code, which is what Adapile uses.
I kind of did a double take when I read that because new to me, but it's great that it had something to train on.
Yeah, it's kind of, it's an interesting, it seems like their thought process was,
"Hey, we want to use chat.gpt to write KiCad boards.
Oh, well, the file format that KiCad uses isn't really usable by LLMs.
Well, what if we had a language?"
[laughter]
And here we are.
I'd be curious if it could be leveraged with GitHub CI,
so that if you needed to maybe swap a part,
and it could maybe do a check to see if it's still meeting
the parameters set in the code.
Yeah, that's interesting, because they do have a whole
test framework that I've not looked into at all.
But you can specify various attributes of components.
and I wonder if you specify then attributes
on the sub-circuits that use those components,
if then you're testing, you can do like,
oh wait, you're blowing your power budget
or something, right?
You know? (laughs)
- Yeah.
- Like, I'd be interested to see what kind of tests
they have, because they do have some sort of a CI
set up as well, so as you check in, it'll do some tests.
- Yeah, that would be really cool.
- Yeah.
Okay, so Liz, what's your next one for this time?
My next one is the MIDI Baby Gen 4, and it's this utility pedal made by Disaster Area Designs.
They make a lot of music utility pedals aimed at guitarists, and it's operated by Matthew
Farrow, who also runs Alexander Pedals.
The MIDI Baby has been around for a bit.
I actually did a teardown of the original one when it came out on my, let's say, YouTube
channel.
That's how I met Matthew.
that. He's a really nice guy. He then offered to do a teardown of one of his Alexander pedals
with me on the channel where he actually walked through the circuit. And the original Mini Baby
used a SAMD21, but this new one uses an RP2040. And the reason why I bring it to the show today
is that it also can run CircuitPython. And he has ported it to CircuitPython. It does have a USB
MIDI host port, it has a NeoPixel. So there's definitely, I think, some interesting community
hacking that could happen with it. And I think he's also hoping for that. There's so much awesome
MIDI support in CircuitPython that I think with this little tiny little square pedal,
there could be some cool stuff there. Yeah, that's pretty cool. It's like, I love the
proliferation of these "guitar pedals" that have no like guitar-ness inherent to them.
This is just a MIDI controller, you know, and a MIDI router that is in guitar pedal
format.
It's the only way I think that guitarists can really understand MIDI is if you give
it to them as a pedal, then they're like, "Oh, okay, I get it now."
Yeah, so this is pretty great.
And I love how you can configure it all via the little WebUSB webpage thing, so you can
do all these crazy stuff.
Like, like one jack can be transmit or receive of MIDI, or it can be other stuff.
It's just like, what?
- Yeah, it's really wild how it all works.
And then if they do a new firmware release
that isn't CircuitPython that's written in the Pico tool,
then you can also do it via the web GUI,
which is really nice.
- Oh, that's nice, yeah.
All right, Paul, what's your next one for this time?
- Next up is an open source gaming console
called the Game Tank,
which you can learn more at gametank.zone.
It's marketed as an open source 8-bit retro console
that you can build and build games for.
It compares itself to fantasy consoles
like Pico 8 or TIC-80,
but sets itself apart
because it's a physical hardware device first,
followed by an emulator second.
And yes, there's an emulator also to make development easier.
The emulator runs on Linux, Mac OS, and Windows.
And when they say it's open source,
everything is open source.
You can get the PCB schematics in Eagle or KiCad
right from their GitHub repository,
so you can order your own.
It also includes the files for 3D printing, so you can print your own shell or even print
your own controller.
For the hardware, it features a 3.5 MHz CPU with a double 128x128 framebuffer with 200
colors.
It also features a dedicated audio coprocessor.
The homepage at gametake.zone features a one-minute teaser YouTube video that you have to see
the motherboard with all the chips built in.
It looks like it's right out of the 80s.
One of the things that sets it apart, though, is that it's an actual hardware console that
uses actual cartridges to load the games.
For developers, there's a GameTake cartridge programmer that connects via USB-C to flash
ROM files onto compatible cartridges.
For creating the games themselves, there's a C SDK and a Rust SDK.
Say that three times fast.
On the CrowdSupply page, it mentions because it's open source, that's how the Rust SDK,
the Rust emulator and the Rust Cartridge Flasher program,
which has overtaken the C++ version and features,
all came to be.
The Game Take originally sold for $300 in their store,
so we'll have to see how much it will be
once the crowd supply campaign kicks off.
It's a pretty neat project in that everything
from the console to the software SDKs to the emulator
are all open source.
- That's really cool.
And I must say, the fact that it has those DB9 connectors
for the joysticks is a super, super retro triggering for me.
- Yeah.
- Yeah, and when you actually open the shell
and look at the motherboard, for lack of a better word,
it takes me right back to looking at like an Apple II
with all the different chips laid out in order.
- Totally, yeah, this looks, it's got a very retro look.
Like a lot of these modern console retro game platforms
are basically like, here's the one big FPGA
or the one big microcontroller that does everything.
But this one looks like it's from the 80s or 90s on the inside.
I love that there's this renaissance happening right now,
like kind of retro computing,
but rethought with a modern spin on it.
It's really cool to see all these different projects coming out.
Yep. There's some Pico 8 games that you can play right now in a browser.
And I think even their emulator works in a browser.
So it just makes it so much more accessible.
Yeah. I like that the emulator they've got on Linux, Mac OS and Windows.
That's cool.
Confidence usually one or one, yeah.
- All right, Tod, why don't you wrap it up for us?
- Okay, so you know, Quick StemmaQT,
the cabling standard by SparkFun and Adafruit?
It enables hundreds of different I2C devices
to connect in a consistent way,
make it easier for new people to get going,
and generally making prototyping ideas a lot faster.
But using that makes your project bulky fast
if you get a couple of different StemmaQT modules.
What if there was a micro-sized similar standard?
There may be, it's called Tiles from BergZone Labs,
and tiles are only four millimeters on a side.
While tiles are sort of like a micro version
of StemmaQT or Qwiic,
they're targeting a more production level market.
As mentioned, each tile is only four millimeters on a side,
and it has 10 connections that consist of power,
I2C, and SPI.
And so these little four millimeter things
are meant to be soldered down on easily fabbed carrier boards.
You can even have the carrier board be a flex circuit.
So four millimeters, how big is that?
So if you look on your various circuit boards,
you might see a NeoPixel LED.
The standard ones of those are five millimeters.
So each of these tiles is smaller than that.
And a tile module can be a full BLE microcontroller
or a six axis IMU or a LiPo battery management circuit
or a haptic driver, a heart rate sensor.
There's 26 tiles under active development.
And they all connect together sort of like the way
a StemmaQT sort of bundle of things would.
The carrier PCB can be small enough to be production ready
'cause it's, you know, the four millimeters, right?
It's taking the design blocks approach I mentioned before
with like KiCad or Autopile and making them physical.
And the nice thing about the tiles
is that the modules will be pre-verified and certified.
So you can just use them as if you use a component
and all the drivers are open source,
just kind of the same way that Adafruit open sources
all their drivers for all their StemmaQT boards.
It looks really interesting.
As someone who has pretenses of making production-level things,
this is a really cool way of almost going to production
with things that are kind of like StemmaQT.
The tiles were created by a friend, an associate,
Jonathan Fine, from the Max Planck Institute
for Intelligent Systems.
He created the BergZone Labs in Germany
to encourage the use of tiles.
BergZone is also working on an online design studio app
to help with the creation of project using tiles.
And they've also created some carrier boards
with ZIF sockets,
so that you try out different tile modules without soldering.
I got to play with tiles a little bit a few weeks ago,
and it's really hard to describe how small they are.
They're smaller than your fingernail, you know,
and each one is like a full computer
or a full sensor or something.
It's still very early days,
but I love this modular approach of tried and true circuits.
I love not having to reinvent the wheels.
one of these I really love about systemic UT boards.
And I can see new products,
like Kickstarter type products,
being composed entirely from tiles
for an initial production run.
And there'll be links to this in the show notes
so you can see kind of like what they look like.
There's a few reference designs that he has created.
Like there's a ring, a smart ring,
and there's I think a stylus,
some other ones he's working on.
But I hope this goes somewhere.
I hope this gets picked up by a big manufacturer
like, like earlier, a distributor, like a DigiKey or something, because it'd be
kind of cool to order a whole bunch of these and build a thing.
Yeah, definitely.
Small enough where you could just order a whole reel for all practical purposes.
I know, right?
I like that.
It seems like it's, like you said, it's like you have your kind of STEMMAQT
kind of family of sensors, but then like this would be almost kind of
like the next step if you were kind of doing more of a bigger production run.
And yeah, I like that.
Well, that's our show.
Big thanks to Liz for joining us this episode.
For detailed show notes and transcripts, visit thebootloader.net and click on
news if you want to get a free sticker.
Until next time, stay positive.
(chiming)