The STM32 line is a whole family 32 bit ARM microcontrollers from ST micro electronics.
They've been out since 2007 and seem to be gaining a lot of popularity in the last few years
From what I can tell this is because 32 bit microcontrollers are just about as cheap as
8-bit microcontrollers, but offer a lot more power.
Understanding the naming convention can be quite confusing.
The best place to start is probably on ST's site at microcontrollers and microprocessors.
We want to look at MCUs, the microcontroller units.
MPUs are microprocessors.
Those are good if you want something that will run Linux.
ST has broken down the chips into four categories, high performance, mainstream, low power and wireless.
If you are unsure of what to use, the mainstream list is usually a good start.
They'll likely have all the pins and peripherals you're used to from a microcontroller and
they're usually the cheapest of the bunch.
If you're just starting out, the F0 series is usually a good bet.
They're based on the ARM Cortex M0 architecture so they can act as a replacement for many,
8 and 16 bit microcontrollers.
This is where things get confusing.
F1 is based on cortex M3 and F3 is based on cortex M4, make sure you carefully read the
series description to know what architecture you're getting to make learning easier, ST
has created a series of development boards known as Nucleo boards.
These things are great, lots of features, and they cost between $10 and $20.
Once again, the naming can be odd on ST's Nucleo board page, we get a nice chart showing
us which STM32 parts have accompanying Nucleo boards.
Take a look at the family names for the boards.
Notice that the Nucleo 32 family are small breadboard compatible boards with 32 pins.
32 has nothing to do with the number of bits here.
The Nucleo 64 are your Arduino sized boards with more pins available.
Finally, the Nucleo 144 are reserved for the really powerful STM32 parts with even more pins.
Personally, I'm a big fan of the Nucleo F02K6, as it's super low power, cheap fits on a breadboard,
and has built in USB.
For the first few episodes in this series, you can use any of these boards.
However, I'm going to use the Nucleo L476RG that's because in later episodes, I'm going
to show you how to use Digi-Key's, IOT studio with STM32, which only supports the L476RG.
When I made this video, one of the reasons I really liked the Nucleo boards is because
you can program them with straight C or C++.
You can also use ARM's Mbed platform.
Some of the boards even have Arduino support.
So you have lots of options.
The next part is probably my favorite feature of the STM32 line. 0:02:58.110,1193:02:47.295 Let's say you're working with F042 part.
I mentioned earlier, and you've already created a board for this 32 pin LQFP package shown here.
It's a cortex M0 part, and we think it's good enough.
However, we quickly run into limits with our code.
We've got a maximum of 48 megahertz, 32 kilobytes of flash and 6 kilobytes of Ram, but take
a look at the LQFP 32 pin out.
Let's go back to Digi-Key site and search for STM32.
We narrow our search to 32 LQFP parts.
Then we narrow it again to just cortex M4, since we know we need more power and something
with USB, aha, let's try this L422 part.
This microcontroller can go up to 80 megahertz with 4x the flash and over 6x the Ram.
Scroll down to find the pin out for the LQFP32 part, compare this to the F042 pin out and
we see that they're just about pin for pin compatible.
There's a few extra features on some of the L422's pins, but you should be able to just
drop this beefier, part right into your board design and have it work with the same part
shape and pin number.
Most of the STM32 chips are pin for pin compatible.
That can save you lots of effort if you're running into limits with speed or memory,
I hope this gives you an idea of how to navigate the STM32 lineup, but enough talk.
Let's see how to actually program a Nucleo board.
To begin, we'll need to install the development environment.
The easiest way to find it, I found, is to search for STM32 cube IDE.
The first hit should be ST's page, click on it and scroll down to download the package
for your operating system.
Accept the user agreement.
Do note that you'll need to sign up with an email and password.
Don't worry, it's free.
Unzip and run the installer or whatever installation steps your particular operating system has you do.
Accept all the defaults.
This is a good time to plug in the Nucleo board to your computer.
When you start the IDE, you should get a, pop-up asking you where you want your workspace.
STM32 cube IDE is based on the eclipse development environment, which uses the concept of a workspace,
which is just a directory on your computer.
Somewhere that houses all your project files for this particular IDE, feel free to change
it, but I'll leave mine as default click launch and the IDE should open giving you a welcome screen.
Since you might not always see the screen on future visits, click file, new, STM32 project
to start a new project you'll then be presented with a target selection window.
Here you can pick the STM32 part that you want to develop for.
You can also use the parametric search to narrow down your part.
This can be sometimes more helpful than the website.
We're using an official ST board, so click on the board selector tab.
Type Nucleo in the search bar to get a list of the available Nucleo boards.
Find and click on our Nucleo L476RG.
You should see our board in the list below, click on it and click next.
Give your project a name.
I like to keep the board or chip name in my project.
So I'll call this one Nucleo-L476RG-Blinky.
We can use either C or C++.
I find C a little easier when starting out.
So let's stick with that.
Click finish and you'll be asked to initialize all peripherals in default mode.
If you're working with a bare chip, I recommend saying "no" here and only turning on the peripherals
as needed.
However, since this is a demo board click, "yes" it'll initialize all the functions of
the Nucleo board by default, such UART, which can help with debugging.
You'll then be asked about switching perspectives.
A perspective is a collection of windows, panes and views in eclipse.
We want to open this initial perspective.
So click "yes".
Note that STM32 cube IDE does not come with board definitions and individual part libraries
by default, as a result, whenever you create your first project for a particular chip or
board, the IDE will download all the associated files for that chip or board.
This can take some time. So be patient.
It does mean you need an internet connection for the first time you initialize a project
for a chip or board.
However, once you've downloaded these files, once you shouldn't need to do it again, if
you start a project for the same chipper board, once it's done, you should see a graphical
representation of your microcontroller.
STS STM32 cube Amex tool was a graphical tool that helped you initialize peripherals for
your STM, 32 part and generated code for you.
That tool has now been integrated into this new IDE, which makes life a lot easier.
You can find all the available peripherals for your part on the left side, pane under categories.
Alternatively, you can click on a pin to see its available peripherals.
For example, we can make PC eight into a digital output pin by selecting GPIO underscore output.
Simply select that option again, to revert the pin to its default, unused state.
As another example, we can set PA 10 as the receive pin for you. Start one.
If we wanted note that many of the pins are already set for us, and that's because we're
using a Nucleo board, which has most of its peripherals already defined for us at the
top, you can see several tabs, which help us initialize our part.
The clock configuration tab gives us a schematic like view showing how all the clocks, dividers
and multipliers are connected.
Once again, this is all set for us because we're using a Nucleo board, but if you're
making your own board, you might have to set these.
The project manager tab lets us change some of the project settings, such as the name
and default allocated memory sizes.
The tools tab has some advanced features such as a calculator for estimating the current
draw of your microcontroller.
Click on file save.
And you'll be asked to generate code click.
Yes, and the IDE will update the code in your project files.
While there are tons of files to look at that makeup, a project, we just care about source
main dot C for now.
You'll notice these begin and end comment guards.
They may make the code look cluttered, but they do serve a purpose that we'll show you
in a minute, scroll down to find main, which is the beginning of our program.
Scroll some more to find the part we care most about the wild one.
Superloop most often you'll want to put your setup code just before the wild loop and your
execute forever stuff inside the loop.
Feel free to look through the rest of the code generated by the graphical tool.
You can see library functions being called to initialize system clocks and various peripherals.
You will rarely have to change any of this, but you might need to say change the URL baud
rate.
We can also see how our GPIO pins are being initialized.
Scroll back up to the wild loop.
I say we write some code between one of the comment guards, and let's say we write some
other code that exists outside a set of begin and end the comment guards I'll then save my work.
Next we go back into the graphical tool and change a hardware configuration I'll switch pin to
output, and then switch it back just to illustrate this point.
The little asterisk next to the file tab shows us that we've made changes.
So we click file save and it asks us to generate code again, click yes, and go back to our
main function.
You can see that the code we wrote between the comment guards persisted after cogeneration,
however, test two, which was outside the guards after an end.
But before I begin was deleted, the first time you start development with an ARM microcontroller,
it can be a little daunting.
You can use assembly C, C++ ARM's cm, SIS library, or the manufacturers specific libraries.
If you take a look in project properties, C, C++ build settings, you can see that we're
using the good new tool chain for STM32.
This is good news for us as this tool chain, along with GCC are free, but that doesn't
answer which libraries we should use.
This diagram on ARM's site has a good overview of how the libraries work together.
Arm created the cortex microcontroller software interface standard or CM says to be a set
of libraries that help you control registers and set up peripherals on any arm cortex controller.
Well, this is great for learning arm development.
In general, it won't necessarily create portable code.
As each microcontroller can have different registers and peripherals as defined by the
Silicon manufacturer, ST's hardware abstraction layer, or how makes controlling some of the
peripherals in the STM. 32 parts, a little easier as it handles much of the setup for us.
In most cases, you'll also find that if you write HAL code for one STM32 microcontroller,
it should be able to run on another STM32 microcontroller.
This helps with code portability, at least within the STM32 family.
Unfortunately, most of the HAL documentation exists within a series of PDFs published by
St which makes things a little hard to navigate.
The best way I've found of finding these docs is to search for the family.
I'm working with say STM32 L4 and how in the of contents, the peripherals are mostly in
alphabetical order.
We want to blink an led.
So look for GPIO in that section, we want to just toggle.
So look for how underscore GPIO underscore Tuggle pin.
It looks like we need to give this function a port letter and a pin number.
The house system driver also contains a useful delay function that we'll use to wait between
toggles back in the IDE click on the dot IOC file in your project.
This corresponds to the graphical setup tool we were using earlier, zoom in, and you can
see that port a pin five is connected to the green led on the Nucleo board.
So back in Maine, under the wild loop, right?
Hal GPIO toggle pin GPIO comma GPIO pin 5 under that, right?
HAL delay 1000, which will delay the microprocessor for 1000 milliseconds click project build
project.
When that's complete click run debug as STM32 application, you'll be asked to create a new
debug configuration, leave everything as default, since it's automatically set up for the Nucleo
board and click OK
When asked click "switch" to open a new eclipse perspective. Here, you'll see that you have
a new toolbar, click the play button to start running your application on the Nucleo board.
At this point, you should see the green led labeled LD two on your Nucleo board.
Blink on for one second and off for one second.
Here comes the fun part.
Step through debugging with our code, still running on the microcontroller.
We can click the pause button to stop it temporarily and see what line it's on.
Open up the main dot see file again, and find our toggle pin line double click the line
number to place a break point, run the code again, and it should stop at the break point.
Now you can click the step into button to execute line by line while delving into individual
functions, press the step return button to exit that function while executing the rest
of the code in it.
And if you want to execute a function without stepping into it, you can press the step over
button, double click on the line number again, to remove the break point.
You can then press the play button again to resume running.
Normally when you're done press the stop button, which will return you to the code editing perspective.
You can do this line by line debugging while the code runs on actual hardware, the STM32
family and Nucleo boards act as a great introduction to 32 bit ARM development.
Next time we'll talk to a sensor using a communication protocol.
Please subscribe.
If you want to keep up with these videos and see you next time.