Welcome to The Bootloader. I'm Paul Cutler.
And I'm Tod Kurt. We have a special episode for you today with an interview with Justin
Myers, the author of the CircuitPython Library Connection Manager. Before we get to that,
though, Paul and I each have a couple of things to share with you, each not more than a few
minutes long. What's your first one, Paul?
My first one is how to level up at CircuitPython. Professor John Gallaugher of Boston College
recently released two videos I wanted to share, one for how to migrate from using Mu and
CircuitPython to using PyCharm with Teal and a video on using Circup to install and update
CircuitPython libraries. If you're not familiar with Professor Gallaugher, I talked to him
way back in episode 3 of the CircuitPython Show, which I'll link to in the show notes.
He teaches a class called Introduction to Physical Computing, which uses CircuitPython
along with microcontrollers to teach students computing concepts. He has other YouTube playlists
worth checking out on his YouTube channel, especially if you're newer to CircuitPython.
I'll link to those as well.
But back to his new videos. The first one is how to correctly set up PyCharm on MacOS
to use with CircuitPython. Most of this is applicable to Linux, too, and I learned a
few new things. It's a longer video at about half an hour, but the professor walks you
through how to correctly configure PyCharm, and he's using the free community edition
in the video. Next, he covers using the new and updated CircuitPython setboard so you
have code completion for your microcontroller in PyCharm. That might be brand new to a lot
of people and is definitely worth watching. From there, he covers using Teal, an open
source serial program that is way better than using Screen. It's got auto-reconnect as
its killer feature, and I think it's pretty cool that he included Teal as the serial monitor
in Mu is one of its key features.
Next up is a 15-minute video on using CircUp to install CircuitPython libraries. If you've
used CircuitPython, chances are you've downloaded the Adafruit library or the community library
bundle, and then you have to find the right library out of hundreds. But what if you could
easily use the command line? He walks you through how to use CircUp from the command
line, and then for Mac OS users or for Linux users using the ZSH shell, he shows you how
to add tab completion by updating your ZSH configuration file.
CircUp has also been getting some love over the last few months. Shout out to Tim, aka
Foamy Guy in the Adafruit community. He's been doing some refactoring and adding new
features as well. I know I learned a few things, and if you use CircuitPython and you're looking
to level up your CircuitPython workflow, I highly recommend checking out these videos
from Professor Gallaugher.
I love CircUp. It's sort of like, if you've never heard of it, it's sort of like Pip,
the Python package manager, but for CircuitPython. And it hooks into the two big package repositories
that exist for CircuitPython, the Adafruit one and the community one. It's so good, but
it's a little bit hard to set up if you've never done any sort of Python setup before.
So this video is like super handy because I get people asking me all the time, "How
do you install a CircuitPython library?"
Right.
And I'm like, "The answer is just use CircUp." But then the question becomes, "Well, how
do you install CircUp?"
And I think it's really cool that he actually walks you through on how to update your ZSH
shell for the tab autocompletes, because there's hundreds of libraries, and it makes it just
that much easier to find the library you're looking for.
I really want to follow his steps on how to set up that PyCharm IDE, because I don't really
use IDEs in the normal sense. I just use a text editor with code syntax highlighting.
But there's so many people that have been trying to use the VS Code CircuitPython extension,
and it's been sort of perennially broken.
The people are so frustrated using it. And it looks like PyCharm is really well done.
And there's this nice now intro video on how to actually meld it with CircuitPython, which
is a little weird because most of the times when you're editing Python with an IDE, you're
editing the files sort of in a project, say.
And CircuitPython is a little bit different in that the code lives on a device, and you
edit the device.
And so maybe your actual project is in a GitHub repo that lives on your computer somewhere.
So how do you deal with those two separate views of your code?
And I think PyCharm can help you with that.
It can, but you're still writing directly to the microcontroller in the way that it's
set up in this example.
Because I know I use PyCharm, and I did learn a couple of things, but there's still a lot
of copy-paste.
Yeah, yeah.
Because I commit everything to my GitHub repo, so I'm writing locally, saving it there, and
then copying it over to the drive as soon as I hit save, running the code.
Yeah, that's usually how I work as well.
But I see all these people that try to use Mu, because it's easy to use, but Mu's getting
kind of crusty.
And Thonny, I don't know, Thonny just always seems like it breaks my CircuitPython install
whenever I try to use it.
Sure.
Yeah, it's too bad that Mu's getting a little long in the tooth.
It's an open source project, it needs a little love, but it's nice to see other alternatives
out there that are well documented.
Yeah, no doubt.
Yeah, I mean, the cool thing is that because it's all just a text file, you can use anything
that can edit text files to edit your CircuitPython code.
But it'd be nice to have a really good IDE for those people who need IDEs.
What's your first one?
All right, so kind of related, Professor Gallaugher also does a lot of how to program iOS apps
for Apple devices.
And so those are written in Swift.
Swift is a programming language that Apple has been developing for the last 10 years.
They use it on all their platforms.
It's the officially recommended way for writing apps for iPhones, iPads, Apple Watch, things
like that.
And Swift is a really interesting language.
It's heavily influenced by Haskell and Rust, these sort of academic languages that emphasize
type safety and functional programming, where the compiler itself can catch a lot of bugs
as it compiles your code down, which is kind of foreign to how Python and JavaScript work,
where you just kind of run your code and see if it crashes or not.
And so there's this whole academic effort in computer science that we should be able
to make provably correct programs, or programs that we can prove will not crash for certain
classes of crashes.
That's what Haskell and Rust kind of comes from.
That's where Swift came from as well.
And it's a really interesting language.
It looks a little bit like C, but with all these sort of extra neat things on top of
it.
If you look at Chris Lattner, who developed LLVM and the Clang compiler, which you've
probably seen in various places when you've installed things, it's been the sort of revolution
how to compile C-based or C-like languages.
And so you'll see, I think you'll see LLVM and Clang a lot more going forward.
But Swift uses those two things underneath to do its magic as well.
And the reason why I'm bringing all this up is because Apple just released something they
call Embedded Swift, which is a version of Swift that runs on microcontrollers, which
is amazing.
This is a super high-level language, in many ways higher level than Python or JavaScript.
And we can run it on a microcontroller on things that are even some ways smaller than
what CircuitPython type controllers can do.
And not only did they release here's Embedded Swift, but they also released working demos
for the Raspberry Pi Pico, the ESP32C6, the InterF52-840, which is a Beely chip, and the
STM32 chips.
And they've also released a bunch of examples on how to participate in Matter, a Matter
network, which is the new standard for home automation that Apple's HomeKit API does.
And I think Google's Echo platform also does now.
And so there's a, and it's all on GitHub, you can just go to their Swift Matter examples,
see the smart light example that you can run and control.
You can make a controllable smart light with Siri and about 60 lines of Swift code.
And it's all, it has a lot of the same features of real Swift of the type safety, the functional
programming, that kind of stuff.
And it's just sort of amazing that we're getting this super high-level language running on
tiny chips.
And I've not looked at it too much yet, but in the show notes, there'll be some links
to some other articles describing it and links to the GitHub that has some examples.
So you can actually try some of this stuff out on your Pico or ESP32.
I only know Python, and this has me really intrigued, especially the Matter integration,
right?
We don't have that in CircuitPython yet.
I don't think Arduino has Matter integration that I've seen.
So actually being able to write my own smart home apps on microcontrollers would be a really
cool use case and actually has me thinking of learning a second language.
Yeah, it's like, supposedly there's Matter APIs in the latest ESP IDF, the SDK that you
use when you're writing C code for the ESP32 chips.
And I think that's what these Swift Matter examples are using under the hood.
But do you really want to be mucking around with C code when you could use a high-level
language like Swift?
Yeah.
And so, you know, it'd be nice if we get Matter support in CircuitPython someday.
There's no reason why we can't.
And I think Jeffler might actually be working on that really, really early stages.
Nice.
Yeah, yeah.
I would love to see that.
All right, Paul, what's your number two?
My number two is accessibility matters.
When I first started contributing to open source about 20 years ago, one of the first
projects I contributed to was the GNOME project, the Linux desktop environment.
One of the core pieces of GNOME's culture is accessibility, which includes everything
from the Orca screen reader to how we wrote documentation back then.
You know, the worst disability that I have personally is being extremely colorblind,
but that focus on accessibility has always stuck with me, which is why I'm excited to
see a project like this.
The first is the AccessBit from Dr. John Vidler in the UK.
The Micro:bit Educational Foundation commissioned a report on accessibility, which included
a speculative section on how to improve the Micro:bit platform for those with limited or
different mobility.
If you're not familiar with the Micro:bit, it's a microcontroller primarily made for
education, popular in the UK and Australia, that features two buttons, a 5x5 LED grid,
and connections for alligator clips.
It can run MicroPython, CircuitPython, and MakeCode.
The report included a few sketches and possible solutions for potential 3.5 millimeter audio
jacks, which are the industry de facto standard for accessibility, like what are found on
Microsoft's Xbox Adaptive Controller.
Dr. Vidler decided to design a PCB as a minimum viable product to add five adaptive switches.
He walks through various iterations of his design, landing on a final design that includes
an edge connector to connect to the Micro:bit and room for five 3.5 millimeter jacks.
It's pretty cool the thought that he put into the design, from how the add-on board connects
using the 40 pin Micro:bit controller to the curved design of the board.
He had JLCPCB make a handful of boards and sent them off, and they were shown at the
Blockly Summit in Cambridge earlier in June.
Check out the show notes to the link to his blog post detailing the process, including
photos.
The second product is a new Adafruit product, the TRRS Trinkey.
Adafruit's Trinkey line includes a USB-A port to plug it into a host computer, and a small
board maybe the size of a flash drive, so it's pretty small.
The TRRS Trinkey has a SAMD21 chip, has one 3.5 millimeter jack, and can run CircuitPython
or Arduino.
I think it's great that those who might need it have more options for accessibility, especially
using microcontrollers, which they can program to their needs.
I'm excited to see what people can think up using tech like this, especially if it makes
their lives easier.
These are a great sort of combo, because the Adafruit TRRS Trinkey is purely just a USB device.
It looks like a little USB thumb drive almost, it just has a 3.5 millimeter jack on the back.
But the Micro:bit, it has Bluetooth.
It has USB as well, but it has Bluetooth.
And so you can now make a Bluetooth accessible controller with this little add-on board by
just snicking the Micro:bit into it, and then plugging in some of these accessibility controllers
into that, and then pairing it with your phone with a little bit of code, with make code
or something.
That's incredible.
I think there'll be a lot of fun things being created with this.
I agree.
What's your next one?
So my next one is about CAD query.
So I've been on a journey to move to open source tools for my engineering work.
I've mentioned before I've gone from using Eagle to KiCAD.
I use Fusion 360 for my 3D CAD modeling, and it's pretty good, but I'm always irritated
after using it for a lot of different reasons.
What are the open source alternatives?
If you're going for a gooey 3D experience, there's things like Blender, but I like parametric
modeling.
One of the nice things that Fusion 360 does is you can make everything parametric, where
you just define a set of constraints, and then you create solid bodies from those constraints.
Blender's not really that.
Blender's more of like an artist's tool.
It can do a little bit of it.
So for the longest time, there's been this thing called OpenSCAD, which is a textual
3D parametric modeler.
And it's a gooey app where you've got two panes.
One pane is the text of the OpenSCAD language you write to create cubes and pyramids and
cones and ways to combine them in different ways to make your 3D object.
And then on the right is a render of what that thing looks like.
And so from that, you can, and people have done this to great effect, make enclosures
and other 3D things that can be 3D printed.
Like I think all of the Prusa components in the Prusa 3D printers are all actual SCAD
models that somebody has designed as text files.
And so if you need to make the screw holes a little bigger because you're building it
by hand and you're 3D printing the pieces and you only have M5 screws instead of M3
screws, you can maybe just go into the OpenSCAD file and change one little parameter and change
all the screw hole sizes.
But I've always bristled at OpenSCAD because it's got its own special language.
And I've been looking at other things.
And I just discovered recently this thing that's been around for a long time called
CAD Query, which is like OpenSCAD, but it's all in Python.
It uses standard Python syntax, and it is mostly a library that you can then express
via various ways.
You can just run a main.py and have that output a file, but you can also run this thing called
CQ Editor, which is a GUI editor, kind of like the OpenSCAD editor where you have multiple
windows and you can edit text in one and see a render in the other window.
And I've been using that and it's kind of working.
I don't know, even though I've been using CircuitPython for so many years, I'm still
not a very good Python person.
So this is like kind of diving into more Python.
The reason why I discovered this is Luke Wren, who is one of the ASIC designers, sorry, at
Raspberry Pi.
He's one who has helped us do some of the clever PIO things that we've done with the
Raspberry Pi RP2040 chip, like the cool SynthIO and PWM and touch sensors and stuff is all
kind of because, oh, and most especially the HDMI output from a little $4 microcontroller
is because of some of his hints that he's given us.
But he has a GitHub repo of a bunch of CAD query files.
So if you want to see how CAD query things look, what the Python looks like, you can
just go to his repository and go, oh, look, there's a little vacuum adapter and here's
an air duct plate or whatever.
So there's a nice little library of things for you to kind of browse through and see
what CAD query feels like from a language point of view.
But one of the best things about CAD query is that unlike OpenSCAD and unlike the similar
OpenJS CAD, which is the same thing as OpenSCAD in some ways, but with JavaScript, CAD query
outputs step files, which are object files, not STLs, which are like tessellated, triangulated
shapes.
And I was really frustrated that like OpenSCAD doesn't have a step export feature because
if you have a step file, you can now import that into another CAD program like Fusion
360 and then do additional edits on it.
Whereas it's really hard to do edits on meshes.
The STL format is made for just output, for 3D printing.
It's like the bitmap version of your vector file.
And so having a step is really important to me.
And so, yeah, so I'm going to be playing with CAD query over the next whatever months or
so and see if I do anything with it.
I share your excitement for that.
As I mentioned earlier, Python is the only language I know.
So looking through some of those examples, it's started to click for me.
I've tried to use OpenSCAD and never could figure it out.
I can't use FreeCAD because they don't have a colorblind mode and Fusion 360, I've never
really gotten the hang of.
I've had some luck with Onshape, but actually having the ability to actually program it
is and with the examples that they've got, looks really cool.
Thanks, Tod.
And now we have a special guest, Justin Myers.
Back in episode seven for the CircuitPython 9 release show we did, I mentioned Connection
Manager, but kind of guessed how it worked.
Well, I reached out to the author of the new library, Justin Myers, and asked him about
it.
Here's the interview.
Justin, welcome to the show.
Thanks, Paul.
I'm excited to be here.
To be honest, it's my first time I've been on a podcast, so I'm really excited about
it.
It's great that you're here.
What is the new CircuitPython library Connection Manager and what was your inspiration in creating
it?
Yeah, so basically late 2023, I had decided to spend some of my, let's call it extra time
working on CircuitPython and trying to see how I could help project.
I love the open source community.
And as I was kind of watching the threads, I just saw kind of user after user on Discord
having different connection issues, running out of sockets, different things like that,
memories issues and everything.
And I was like, "Hmm, seems strange.
Should be a better way."
And so as I kind of started digging in, saw like each library kind of managed sockets
differently and really think about and look at the differences between like a microcontroller
and CPython running on a PC is like on CPython, you can open sockets all day long, nothing
really happens.
But then once you get to a microcontroller, it's different.
And kind of once I started digging into that, I was like, "Oh, well, you've got the native
Wi-Fi that does it one way.
You've got like the ESP32 SPI that does it one way.
You've got the WISNET 5K that does it a different way."
And just kind of all this boilerplate and different ways to get the SSL connection and
different things.
And I was like, "This is weird.
Like there should be an easier way to do this."
And so it's kind of what started me going down this road of trying to find out like,
"Is there a better way to do this?"
And what was the better way?
So basically kind of the flow went, I asked the comment on the CircuitPython dev channel
and Discord.
I said, "Hey, I've got this idea."
Basically the requests library had this built-in session manager that kind of managed a bunch
of the sockets.
But oftentimes what users would do is they would just re-init that thing and lose all
the sockets.
And so they were still technically open, just sitting there.
And so kind of that first pass was I basically kind of separated some of that out to a separate
class and kind of shared that with the devs.
And they were like, "Nope, let's create a new library.
Like that's not a good way to do it."
Kind of break up dependencies and everything like that.
And kind of from that, there's literally days spent kind of back and forth on like, "What
should we name this?"
And so ConnectionManager was kind of where that was born and basically just started separating
a bunch of the stuff out of what was in the request library and put it into this new one.
And then building handlers that would take in whatever radio object you passed in and
try to determine, "Oh, what's the right SSL method for this one?"
Reducing imports from five or six all the way down to just the one or two that were
needed.
And that's really the key, isn't it?
If you have a PicoW, it was doing it different than an ESP32 S3.
And now for the user, that setup instantiation is almost the same across the different microcontrollers.
Is that right?
Yeah.
And that was kind of the goal, right?
Because if you think through how CircuitPython started and once connection happened, so the
ESP32 Spy was one of the first ones, developers wrote that library and then they kind of mimicked
it a little bit for the Wiznet 5K.
And then when the new ones came out, like ESP32 S2 and S3 and things, and they started
having this onboard wifi, they changed how they did it again.
And with anything that's open source, they're running forward as fast as they can.
And sometimes it's hard to go backwards to go update everything.
There were depreciation flags and comments, not flags in the code.
And all of these places were like, "Oh, we should get rid of this at some point," but
it was still there like years or months later.
And so a lot of it was like trying to trim some of that down.
What was it like to partner with the core developers on Connection Manager?
I really enjoyed it.
It was really interesting.
It's been a really interesting progress for me.
So a lot of my development started in C, 20 plus years ago when I started doing dev.
And a lot of it was for smaller systems.
And it was at a time where you had to do memory management and really think of your code for
what's going to be the fastest and most efficient ways.
And last 20 years, I've switched over to things like Python and things where...
And JavaScript and everything, where a lot of that stuff's just handled for you and you
forget about it.
And so it's actually been really fun because they'll make comments on PRs and they're like,
"Oh yeah, that's a wasteful way to do something," because there's not a lot of space.
So it's really small and trying to think through it.
But they've been great.
There's been times where a handful of them, we've jumped on calls together to work through
some things and figure it out.
They've been great on the comments and asking questions and whatnot.
And so I think the CircuitPython devs, it's a great team to work with.
Well, that's great to hear.
What's next for you and Connection Manager?
Kind of where I've been going next, I've been opening a handful of PRs to make the radios
again more similar.
So for example, they all had different ways to find out what AP am I connected to?
What's my Mac address?
And different methods of returning everything.
So I've been continuously working to try to get the different radios as close to the same
as possible.
And so really for an idea of...
A typical user probably goes out and they buy a microcontroller that's got whatever
Wi-Fi has on it, and they go run with that project and go.
But oftentimes they see a lot of the questions are someone sees a learn guide and they're
like, "Well, I don't have that stuff that's in the learn guide.
I have this."
But then they really struggle to try to figure out how to get it all to work because these
different methods are different.
So it's really been working to get all those core methods the same.
So you can, for the most part, copy paste other than initializing the radio itself.
And the work I'm doing currently now is I'm actually building out some network test code
that we can run.
And so every time a new version of requests comes out or 9.1 for CircuitPython or 9.2
or 10 or whatnot, we can actually run the same test code across the same different microcontrollers
and actually figure out like, "Oh, is SSL still working?
Can I still connect to MQTT?
Can I run a server?
Can I do requests?"
And ideally with a goal of having a kind of similar to CSS is that this like, "Can I use?"
Like so you could go look and be like, "I have this microcontroller.
I'm using this radio and I want to do this.
Can I do that?"
Well, that's great.
It's been fun and exciting to watch you partner with the core devs as you've built this over
the last few months.
Thank you so much for being on the show.
Thank you very much.
I really appreciate it.
And that's our show.
A special thanks to Justin Myers.
If you enjoy listening to the show, tell a friend or write a review.
It really does help.
For detailed show notes and transcripts, visit thebootloader.net.
Until next time, stay positive.
[Music]