Built from the ground up

(upbeat music)

- Welcome to The Bootloader, I'm Paul Cutler.

- And I'm Tod Kurt.

Each podcast will be bringing you news, project updates,

product talk from the tech and maker scenes.

And for each episode, we'll be talking about it

around three, no more than five things

and chat about them for a few minutes each.

Paul, what do you have for us this week for your first one?

- First up, I've got a segment that I like to call

Meet the Maker.

And first up is Carrie Sundra of Alpenglow.

Now I've never met Carrie.

I just follow her on Mastodon and the socials.

And shame on me, but I've never took a good look

at the products and services offered by Alpenglow.

I visited their website and if you visit the about page,

I wanted to share Alpenglow's mission statement,

which is to teach you about electronics

without gatekeeping.

It goes on to say,

we are passionate about representation in electronics.

The field is still overwhelmingly white and male

with only 10% of electrical engineers identifying as women.

Having worked in the field for over 20 years,

we know how much gatekeeping and hostility there can be.

We aim to provide a welcoming space

where adults can learn about electronics

without judgment or any previous experience.

So right there, you know it's a business

that you want to support and do business with.

That is just such a cool mission statement

to share with the world.

And it's something that I'm passionate about too,

that whole women in tech and under-representation in tech.

And it's great to see her trying to bring people

into electronics and soldering.

What sparked my interest was on Mastodon a couple weekends ago

they shared a learn to solder surface mount kit.

And that got me to visit the shop

and I saw the various learn to solder through hole kits

as well as surface mount.

Now I'm terrible at soldering.

I just started soldering within the last couple of years.

And if I had known about this a couple of years ago,

I probably would have picked one out.

I still don't know how to do surface mount soldering.

So I'm tempted to buy one of those.

And the kit, which is called the SMT Garden,

it's only 20 bucks and it includes

over a hundred different pieces from practice capacitors

to different colors of LEDs, as well as resistors

and a battery holder.

So there's tons of stuff that you can practice soldering on.

There's so many cool things in the shop

that I encourage you to go spend a few minutes browsing,

pick up something if you're looking to learn to solder

or improve your soldering skills.

And that's not all she does.

She also runs a learn electronics workshop

and a learn to solder workshop

and encourages those underrepresented in tech to attend.

Be sure to check it out.

I've included a number of links in the show notes.

- I follow her on Acidon too.

And like, I'm always seeing these great soldering classes

and electronics classes that she gives.

And like most soldering kits are kind of boring.

They're like little square things that have like, you know,

four little LEDs or something

and they just blink or just go on.

But her PCB designs are beautiful,

like little bits of art that light up.

And it's, especially for SMD, it's a really great intro

because like SMD seems kind of scary, but like,

oh, this is just LEDs.

You know, if you mess one up,

you still have three or four others

that are gonna light up for just this one part.

And there's like four different parts of the whole PCB.

And so, yeah, just even if it's not turned on,

it looks cool.

- Yes.

- And then if you add to it, then it'll look even better.

- Her products do look cool.

I mean, there's holiday themed one.

There's a light up Krampus.

There's some no soldering ones that are available.

So depending on what your skill set,

there's a little bit of everything for everyone, I think.

- Yeah.

Yeah, it's really cool 'cause electronics is not that scary.

It just kind of looks scary.

- It does.

And I would say that's my experience in the last few years

is I really came into this

thinking it was a lot scarier than it is.

And it's just amazing how much you pick up

just doing it over and over again in the practice,

which is perfect for something like this.

- Yeah, like so much of things.

If you don't keep using it, you kind of lose it.

- Absolutely.

What did you have up for us next?

- From like intro to electronics

to like some of the most complicated electronics

that I know of is how to make a synthesizer.

And so from previous shows and just if you follow me,

you've probably seen that I've made little toy,

kind of toy synthesizers using either Arduino

with this library called Mozi or in circuit Python

with the new synth IO functionality

that's built in a circuit Python.

But they're kind of toys.

Like there are a lot of real synthesis platforms out there

that let you do like professional quality synthesizers.

And I've never really gotten into them until recently.

There's one module, it looks kind of like an Arduino

called Daisy Seed from this company called Electrosmith.

We'll have a link to it in the show notes.

And it's 25 bucks and it's a Cortex-M7 chip,

which is one of the most powerful microcontrollers

you can get on a tiny board.

And it has 65 megabytes of RAM.

So like, you know, RAM is important

in when you're making synthesizers or digital effects,

like pedals, like guitar pedals and stuff,

because you need that memory to act as the buffer

for like the delay effect or something

or the reverb effect.

You kind of need to store copies of the sound.

With this chip, sorry, this board,

this Daisy Seed board also has a professional quality

24-bit 96 kilohertz audio input and output and stereo.

And then for like knobs and stuff,

it's got 16 ADC, sorry, 12 16-bit ADC pins

and two 12-bit DACs to control stuff.

31 GPIO pins to like let you control LEDs

or like drive a display or something

or like read from an SD card.

And it fits on a breadboard.

So it's kind of like, you know,

if someone made an Arduino and it grew up

and wanted to make music,

it's kind of what the Daisy Seed is.

And Electrosmith provides all these

really great libraries for it,

but they're pretty complicated C++ libraries.

They've got a Arduino library that wraps the C++ stuff,

but it's still, you need to kind of know how to C++.

So it's pretty daunting if you just like go and look at it

and go through their tutorials, it's like, whoa,

that's a lot.

But thankfully there's this nonprofit in the UK

called Synth UX Academy, sorry, not in UK,

in the Netherlands.

And they've been doing these online classes and, sorry,

in-person and online classes

that they've been streaming for free on YouTube

and putting their code up on GitHub

so that you can follow along.

And they're only using the Daisy Seed

and they have this really great little PCB set they sell

that's like a little tiny synthesizer like platform.

Their whole idea was that like,

hey, here's a big gridded PCB with a lot of holes in it

where you can put the knobs kind of wherever you want

to design what interface you want your synthesizer to have

and just quickly wire them up to the Daisy Seed

and like wire up an output jack

and boom, you've got a synthesizer.

And so it's been a really nice sort of intro level

getting you slightly involved in the whole Daisy Seed

way of thinking about how to deal with audio

and how to generate audio

or how to generate like a guitar pedal effects and stuff.

So it's been really cool.

I've been wanting to play with the Daisy Seed for years.

I supported their Kickstarter back in like 2020

and it's been sitting in a box since then. (laughs)

But I finally, like just like in the last two weeks

I've like gotten out of the box, started playing with it.

And it's all because of this,

the Synth UX Academy YouTube videos and their GitHub stuff.

So if you're into this sort of thing, check it out.

It's really cool.

- It looks just like, it's just a microcontroller.

It looks a little bigger than a Pico.

And it was only $21 when I looked at the website.

I was kind of taken aback by how cheap it is

for that much RAM and M7, like you said.

- Yeah, and it's used in like real products.

Like there's some guitar pedals that use it.

There's some like official,

you can go and buy them at like Guitar Center, I think.

There's some synthesizers,

like the thing called the Chompy.

That's like this cute little synthesizer

that has like uses computer key switch keys

for its keyboard.

It uses a Daisy Seed inside of it.

And then there's a bunch of Eurek modules

that use the Daisy Seed internally.

And you wouldn't know it.

They're just like, they're hidden and they just,

oh, here's this platform to do cool audio stuff.

- That's pretty neat.

- So what's your second one for this week?

- My next one is the Microdot web framework.

I've shared before that I enjoy programming

for the web and Python.

I've used both Pyramid and FastAPI web frameworks,

but I recently came across the Microdot web framework

for CPython and MicroPython,

which I thought was interesting.

- Interesting, yeah.

- It was created by Miguel Grinberg,

who wrote the Flask mega tutorial,

Flask being a popular Python web framework as well.

Microdot's homepage describes it as

the impossibly small web framework

for Python and MicroPython.

And it's inspired by Flask.

What is interesting is that you'll be able to prototype

and write all your code and have it run on desktop Python,

on CPython before you bring it over

to a microcontroller running MicroPython.

Virgin 2 was released this past December,

and it looks like there may even be CircuitPython support.

I saw Miguel had filed a few bugs with CircuitPython,

so the Microdot test suite would pass,

which is how I first came across Microdot

was seeing the bug reports.

So I haven't looked to see if it actually runs

on CircuitPython, but it does run on MicroPython,

and I was surprised to learn that there's over

a dozen different web frameworks for MicroPython,

including Microdot.

So if you're coming from the world of CPython

and you've used Flask and you're coming to the world

of microcontrollers, it really looks like Microdot

might be the perfect web framework

to bridge both of those worlds.

- That's really amazing.

I'm really impressed.

Like I did some networking,

some UDP networking stuff a couple months ago.

That was mostly for CircuitPython,

but because the API, the network API is a CircuitPython

and normal Python, or CPython, are so close,

I was able to have my library support both.

And that was really cool because yeah,

I could do all my development on the desktop

and then try it in CircuitPython and it would just work.

I'm just like, this is kind of the promise

of why MicroPython and CircuitPython exists

is that you can take your learning from DesktopPython

and apply it to embedded microcontrollers,

which is amazing.

- Exactly, or even the other way around as well.

- Yeah, yeah, that's very much true for me

'cause I actually don't know DesktopPython too much.

I have heard of Flask though,

so I'm gonna look at this Microdot thing.

- There you go.

What do you have for us next?

- To go even deeper.

So like what's lower level than CircuitPython?

- C.

- C, right, yeah, exactly.

I was gonna say the next step down might be Arduino.

Lower than that would be C with like say a vendor SDK.

Like you see you need to have some way of knowing

some functions you can call to do like,

make the pin go high, make the pin go low.

But what's even lower than that,

you could write C code that manipulates

a chip's registers directly

because that's really all this vendor SDK does

is you can just know what memory locations,

where the pin register lives and modify that with C.

Or you go even lower, you could do assembly language,

which I don't know if you ever heard of assembly language,

but it's pretty much the lowest level.

It is these tiny instructions that represent

the actual bits that are sent to the CPU

and the CPU decodes those bits.

And then that's an instruction

and it does one of the instructions,

which could be load something by memory

or add two registers together or something like that.

And so Carlynorama, disclosure, she's my wife,

has been doing a deep dive on ARM assembly language.

And I've been finding this really fascinating.

See, she started out, she knows Arduino

and low level Arduino and AVR stuff very well for me.

Original Arduino back in 2006 or so,

she wrote some of the original documentation

for the Arduino website back in 2006.

She knows all about like low level, bare bones, AVR stuff.

And so she decided to kind of get back into it

by writing some bare metal C code to drive an AC tiny 45,

and which is a little eight pin AVR,

unlike the larger like 28 pin AVR that's in an Arduino.

And she got that to work and it was like,

that was a cool couple of days of work.

But now, 'cause like her real target is to learn,

not necessarily to learn ARM assembly,

but to learn how ARM chips work.

Because she has some like,

she has some plans down the road.

And so she went to a Trinket M0,

which is a SAMD21 ARM chip and started,

instead of just programming an Arduino or programming C,

she's like, nope, I'm gonna go with the bottom level.

I'm gonna figure out how this chip starts up

when you apply power, what does the chip start to do?

Okay, I'm gonna feed it code to know how to do that.

And then within about a week or so,

she got it to blink an LED.

And then a couple of days later,

she got it to read a button using the lowest level code

as the ARM assembly.

And it's really cool because like,

ARM chips are what are in all of our devices now,

like our phones, our computers,

they all use the ARM processor, the ARM instruction set.

And so, unfortunately, the instruction set

on these little chips,

like the little ones that run Arduino and CircuitPython,

they're a kind of ARM called the Cortex-M series.

And it's the lowest level of the Cortex-M, the Cortex-M0.

And so each one of those,

each one of those sort of subsets

are a smaller and smaller number of instructions

that are available to you

from what the big ARM instruction set has.

So the big ARM instruction set has like

really big, cool instructions for doing DSP functions

and stuff like that.

But when you're on the little microcontroller,

you get like the bare minimum.

So trying to figure out when you just type in

ARM assembly on Google,

gives you this wide range of information

and you have to figure out what part of this

is applicable to these tiny chips.

And so that was like coming into one of the first hurdles

that I was watching her get over.

Like, I don't know any of this.

I know assembly a little bit from like Apple II,

you know, way back a long time ago.

- Sure.

- But my current assembly language knowledge

is pretty, pretty scant.

So it's really fun to like just kind of sit back

and see her figure out this stuff

and then kind of draft off her

and kind of do it off to the side myself

to see if I can make stuff work.

And sometimes I can't.

But it's these instruction sets,

the really cool thing about the ARM instruction set

is it's really regular.

Like the old instruction sets of like the Apple II

and the x86 chips,

they were what's called the complex,

CISC, complex instruction set.

What does the C stand for?

The complex CISC, complex instruction set, something.

And then RISC, which is what ARM is,

is the reduced instruction set, something.

And so the cool thing about RISC

is that you have a fewer number of instructions overall,

but the instructions are very regular.

And so you don't have all these different ways

of loading from a memory location.

You just have one.

And then you do have to do everything in the register.

It's hard to explain,

but without going into a hour long description

of like instruction sets.

But I know a little bit about this now.

(laughs)

- That's pretty cool.

You've got to be pretty curious

to go all the way down to that low level

and start building back up.

- Yeah, no, she's very much like a documentarian

approaching it.

She's been blogging about all of this

in this little blog she has off to the side

of her main sort of blog of like,

let's see what are all the different possible ways

this can be done and then figuring out the way

that actually is the right way.

'Cause not only is there this subsetting

of the ARM instruction set,

but there's also all these different chips

that implement the Cortex-M0 instruction set.

There's the SAMD21, which is what we're familiar with,

like the original QTPI.

There's the STM32 chips,

which are really, really popular and really common,

but neither of us have any experience with STM32,

but yet there's a lot of documentation

on the STM32 assembly language for some reason.

And then there's like people talking about

these more complicated STM32 ARM chips for audio stuff,

which is what I was running into.

'Cause I was seeing that like,

oh, some of these synthesizer people

implement large chunks of their very complicated

DSP code as really tight assembly language loops

inside of a much larger C program that does the synthesizer.

And so it's like, well, that's not applicable

to this problem of like programming a QTPI,

(laughs)

but it's interesting.

- Right.

- But like along the way, she also learned

that there's a really great ARM simulator,

online ARM simulator you can go to

and you can like just type in some language instructions

into it and compile it in the browser.

And you can kind of step through it

with a little built-in debugger

and it's like cycle accurate emulation apparently

for a bunch of different types of chip architectures.

And that was really, really fascinating to see that.

She also learned how to actually run and use GDB,

which I don't know if you ever had to use GDB before,

I've used it once, you know, 20 years ago,

but it's a way of hooking into your program

and telling it to stop and telling it to step, step, step,

one instruction at a time and setting break points

at certain parts in your code

so you can kind of inspect the state of the program

without having to use print statements.

So it's really powerful way of debugging your program.

Usually pretty hard to do on an embedded system,

but these ARM chips have a built-in debugging system

called SWD, software debugging I think is what it stands for.

And so you can use these little $10 programmers

that just hook into a couple of pins on the chip

and then you can just use GDB to it

and tell it to stop and inspect registers

and inspect memory locations and see, okay, yes,

my code did accurately twiddle this one little memory

location that represents the pin register

to cause it to be like turn the LED on or off or whatever.

- Very cool.

- Yeah, so it's incredibly fascinating.

It makes me appreciate all the work that goes into

when you write in Arduino, say pin mode and input pull-up,

or when you say in Circuit Python,

button equals digital in out and your pin number.

There's a lot of stuff, like you just look at the C code

that it goes, that goes and does that,

maybe it's only one or two lines,

but then you see all the assembly language instructions

that have to happen to make that work and it's pretty cool.

And then her next steps are, I think,

going to move to the Clang compiler system.

So there's this kind of two different ways

of compiling for chips.

There's the older and more sort of established GCC

toolset and then there's this new thing called Clang

and LLVM, Clang is kind of the front end,

LLVM is kind of the back end, I think.

And that's, I think the future maybe.

So that's where she's heading next, I think.

And I'm fascinated to see that

'cause I know nothing about Clang.

- Yeah, it'll be fun to watch.

- It's all right.

So what's your third one today?

- Mine is a callback to way back in episode one

in September of 2022.

I had talked briefly about the bamboo X1 carbon 3D printer,

which had just hit the market at the time.

I had mentioned a good friend of mine had bought one

and I questioned how long it would last.

Well, after watching him have his

for about six months later, I bought one.

So I've just passed the one year mark of having one

and I have the P1P model.

I know it's not an open source printer

and I'll take some flack from it,

but I gotta say a year later, it still just works.

- Oh, wow.

- I don't have to fiddle with the bed.

I don't get clogged nozzles.

Now I know that I went from an Ender 3 to a bamboo,

which is kind of like going from a really cheap car

to a really nice car.

But the worst thing I can say about it

is that I have to keep my greasy fingers clean

when I'm taking things off the bed.

Just trying to keep the bed clean

is probably the worst problem I have.

And if that's the worst problem you have

when you come to 3D printing,

then you're doing something right.

- Yeah, I've heard so many good things about it.

People are claiming it's like a toaster

where you just go to it and you just push the button

and it works and it seems so fast to print

from what I've heard.

It's like, man, that's amazing.

- Well, that's been my experience.

And bamboo was actually in the news this week.

It looks like they tried to slip something by their users

and it didn't get through,

which was claiming that their software

would only be updated through 2025.

Well, there was a big brouhaha about it

and they came out today actually and said,

"Nope, they're gonna support the printer's firmware

through 2027 and security fixes through 2029."

So that's pretty interesting when you think 2027,

that'll give the printer four years of life,

which in this industry is probably not too bad.

- Yeah, totally.

But yeah, that's always the danger

with any of these complicated computing-based devices

is how long does their support last

because things seems to always decay.

Like the software-based things always decay

unless you keep updating them nowadays.

- Right, and you could argue

that their firmware is exactly that.

People either love it or hate it

every time an update comes out, it seems.

But they've done a good job with documentation.

They've got a Wiki which includes maintenance tips

and when to perform them.

I know the bamboo costs more than your average 3D printer,

but for me, it's been worth every penny

'cause as I said, it just works.

- Yeah, yeah, I've been involved

trying to play 3D printer for jeez, forever,

like since kind of the first MakerBots.

And I got so sick of having them be a hobby

rather than a tool.

And so at one point, I bought like a really expensive one

just to like get, just to get out of the morass

of like always tuning the printer

to get it to work properly.

And then just like pay too much money

and get a printer that works.

And thankfully now, getting a printer that works

is really low cost comparatively.

Used to be like $20,000.

- Right.

Now anywhere from 300 to call it $1,600

if you get like a fully loaded bamboo with the AMS

and all that kind of stuff.

- The AMF, that's the one where it can like

change the filament color

or change which filament you're printing with.

- Yep, up to four filaments you can have loaded at any time

and it can auto switch them out.

- That's crazy.

It's like, yeah.

- I did not shell out for that.

The printing I do is still pretty basic.

It's prototypes and that kind of stuff.

I don't need, you know, I'm kind of,

I've been through the phase where I printed the pretty toys

that was already behind me by the time I got this.

So I didn't need an AMS to do the multicolor printing.

- Totally.

- What's your last one for us this week?

- All right, so let's talk about capacitive touch sensors

and sliders.

So if you haven't followed me again,

you've probably been seeing that I've been playing with,

I've been exploring capacitive touch sensors

and they're a really great way of adding buttons

to your project without actually having to have

any extra hardware,

except for like one little resistor per button.

And so if you can make a PCB, you can have 10, 20 buttons.

Like I've got a little a MIDI keyboard

that's got I think 25, it's a 25 key keyboard I think,

you know, just with cap touch pads and an Arduino,

sorry, a Raspberry Pi Pico.

One of the things I've been wanting to play with is the

little sliders, like you've seen, like the most famous

is like the second version of the iPod touch wheel

or scrolly wheel.

And the first one was a mechanical little thing that moved,

but the second version and kind of all the way up

to I think till the end,

was this non-moving capacitive touch surface

that you just kind of scrolled your finger around on.

I've seen in some of the capacitive touch design guidelines,

how to make one of these types of little wheels

and the wheels are actually just a special case

of a linear slider uses the same technique.

And so I'm like, let me try to build something like this.

And so first, how do these capacitive sensors work?

The way that the technique that I use,

that is one of the really common ones is,

so all wires, all traces on a PCB

are actually little capacitors.

Like when you set them high,

it actually takes some time to get to that high state

because the capacitance of the metal and the fiberglass

and the ground plane on the bottom,

that forms a little capacitor

and it has to take time to charge up that wire

that is your signal trace or your capacitive touch pad

takes some amount of time.

And then when you make it go low again, it takes some time.

It's not instantaneous.

Nothing in electronics is instantaneous,

even though you said, go low now.

It's like, well, it takes a little bit of time.

And that time is driven by that capacitance

of the physical copper on the PCB.

And so you can use that effect

if you make that piece of copper bigger, like finger sized.

And then if you tell your microcontroller

to raise that pad to the high state

and then time how long it takes to go low,

you are now able to detect,

is there a person touching the pad or not?

Because what happens is if you put your finger

next to a copper trace, you add your body's capacitance

to the capacitance that's inherently on the PCB.

And it like, I think it's like maybe two or three times.

It's almost like you're adding another capacitor's worth

of charge when you put your finger next to it.

So it's kind of cool.

It's like this like really ambient physical effect.

You can, there was normally like a bad thing in electronics

that like, oh, your finger's affecting the circuit,

but we're using it to actually affect a usable,

useful technique, which is like, oh,

and I have a little fake button

by having just a piece of copper on a PCB.

And so that's how just on/off buttons work.

Well, the sliders work by just having three or more

of these copper surfaces and they interleave them.

Kind of like if you take your two fingers

and sort of like, sorry, take your two hands

and sort of splay your fingers and put them together.

When you interleave the copper traces like that,

and if you then put your finger somewhere on that gradient

of like the two copper pieces,

if you're like, if you're to touch,

say on your left side of your hand,

when your fingers are kind of connected like that,

then you'll get just the left hand.

And as you move your finger across to the right hand,

you'll get less and less of the left hand

and more and more of the right hand

as you move your finger across.

And so that's kind of how these things work is you,

instead of reading like just an on/off value,

you kind of read a analog value

of what that capacitance changes in the pads.

And you can have not just two pads that are interleaved,

you can have say three or four or five, six, seven pads,

and that will give you more resolution in a way,

because you're using more little individual pads

to indicate where things are.

I'm not sure how many of the original iPod slide,

the touch wheel had,

but the minimum that I've seen is about three.

You need three pads.

And my little Pico slider toy,

that little PCB that I came out with,

uses this three pad technique for doing two rotary dials

and three vertical sliders.

It actually kind of works.

It's using a Raspberry Pi Pico,

and the code for it is pretty simple code.

It's like just simple sort of algebra,

sort of linear sliding two values next to each other.

And I don't know, I'm pretty excited on like,

what other dumb things I can do with it.

Like the real downside of the capacitive touch

is that there's no feedback.

You know, with a button, when you push the button,

you hear a click.

- Right.

- Some people pay a lot of money

on the mechanical keyboards

to get even a louder click than normal.

And, but you get some sort of pushback,

and there's no pushback with these capacitive touch things.

It's one of the downsides.

It's one of the things that people levied against our phones

compared to the phones that preceded it,

because the big black screen of a iPhone

doesn't have any ridges to tell you where the buttons are,

because you know, every interface

has a different layout of buttons.

But we're getting used to it.

So I feel like, you know, the capacitive touch

is sort of like due for a comeback

in terms of microcontroller interfaces,

because we're so used to the non-tactility of a phone surface

that, you know, these flat capacitive touch surfaces

of a microcontroller touch interface would be okay.

- Right.

So you link to the code for both the touch wheels

and the Pico Slider toy.

Is the Pico Slider toy available on your Tindy store as well?

- Oh yes, by the way, I have a Tindy store.

And I have both the larger Pico Slider toy,

which has something like 16 different controls

and two rotary sliders, three linear sliders,

and a bunch of buttons.

And then also the prototype, my little touch wheel zero,

that's just one of those little rotary controls,

like an iPod slide wheel.

And those are both in the Tindy store

if you want to try them out.

And the code for it is like, yeah,

like 10 lines of circuit Python.

- That's all we have for you this episode.

For detailed show notes and for transcripts,

visit thebootloader.net.

I'm Paul Cutler.

- And I'm Tod Kurt.

- Until next time, stay positive.

You