Super Smooth - with Liz Clark

- 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.

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)