Note: There is more than one kit out there, but it is this author’s opinion that the best value for beginners is the one from UCTRONICS. Most of them have similar components, but this one just happens to be my go-to and is the subject of this installment.

*If you have not yet read our previous installments on learning MicroPython for the Raspberry Pi Pico or Thonny, be sure you review those before moving beyond this short tutorial.

Alright, let’s jump in! Here’s what the kit looks like:

First things first, though. We’re going to start with the Pico itself. The main thing you’ll need to know about it (at least for the purposes of doing experiments) is its pins.

Your Pico and Its Pins

Your Pico talks to hardware through a series of pins along both its edges. Most of these pins work as a general-purpose input/output (GPIO) pin, meaning they can be programmed to act as either an input or an output and have no fixed purpose of their own.

• Some pins have extra features and alternative modes for communicating with more complicated hardware;
• Others have a fixed purpose, providing connections for things like power.

Raspberry Pi Pico’s 40 pins are labeled on the underside of the board, with three also labeled with their numbers on the top of the board: Pin 1, Pin 2, and Pin 39.

These top labels help you remember how the numbering works: Pin 1 is at the top left as you look at the board from above with the micro USB port to the upper side, Pin 20 is the bottom left, Pin 21 the bottom right, and Pin 39 one below the top right with the unlabeled Pin 40 above it.

While you will generally use actual pin numbers when writing your code, we may reference some of them by their functions, as well.

As you can see, there are several different kinds of pins with different functions. Here’s a quick reference guide to help you remember:

You’ll learn more about these functions in later tutorials as we get into projects. For now, all you need to focus on is the basics. This is not meant to be an exhaustive electronics course.

Other Electronic Components

Obviously, your Pico isn’t the only thing you’re going to need if you’re going to be conducting any experiments.

The other things are the components that your Pico’s pins will be controlling. There are tons of components out there, but the cool thing about this kit is that these are useful regardless of how complicated your projects ultimately get – and if you have fun with these, I guarantee you’ll start coming up with your own.

Breadboard

Anyway, let’s start with the second most important component (well, besides the micro USB cord that connects the Pico to your computer) – your breadboard. 

This little beauty makes life a WHOLE lot easier. This unit eliminates the need for a circuit board and soldering. Instead, you can just shove – ok, maybe not shove, but insert – wires and pins into the right spots and remove them as needed to do new projects. Hard to beat that!

Jumper Wires

Next are your jumper wires, which connect components to circuits on your breadboard and take the place of those little “wire trails” you see on circuit boards.

That way, they aren’t permanent and can be moved as you see fit. They can also be used to lengthen wires or pins as needed.

To accomplish this, they come in 3 types – male-to-male (M2M), male-to-female (M2F), and of course F2F (can you guess?).

Momentary Switch

Next up, we have a push-button switch, or momentary switch. This doodad is exactly what it looks like – a button.

However, in this case, it’s not the same as a latching switch, which stays depressed once you click it. This one only has to be held down to make it keep working.

Now this one’s going to shock you. It’s called… a light-emitting diode, or LED! I know, I know, you’ve never heard of it, right?

I don’t think I have to say much of anything about these, but I will make two points.

• First, not all LEDs are going to work with your Pico. 5V and 12V aren’t good, so if you decide to buy more, make sure you keep that in mind.
• Second, the two legs are different lengths. The long one is positive, and the short is negative.

When we’re running a current through stuff, we can sometimes run the risk of blowing them out, especially the LEDs. So how do we prevent that from happening?

Resistor

With resistors, of course! Now, there are a lot of resistors out there with different stripes on them to tell you the level of resistance they provide in a unit called ohms(𝞨). I’m not going to get into that kind of detail here because it isn’t necessary for Pico jobs.

Suffice it to say that if you run out of resistors and want more, you’ll be using little 330𝞨 guys.

Just one little note – yours might not be the same color, but the stripes will be. The ones I got in my kit are blue, but that doesn’t matter; 330𝞨 is 330𝞨.

Piezoelectric Buzzer

Everyone’s favorite component to play with – well, as long as you have people in your place to annoy – is the piezoelectric buzzer. Oh, boy, this one’s fun! It does exactly what its name indicates, and it does it by vibrating two metal plates together when a current is run through it. Heh, heh.

I’m an avid guitar player, and I LOVE the electric guitar the most. I’m the heaviest of metal heads! Ok, maybe not that heavy. I only clock in at 5’7” and 140lb. Sorry – if you’re not an American reader, that ain’t big. Martial arts has done me a lot of good in life.

Aaaaaaaanyway, there are at least two knobs on an electric guitar – one for volume, and one for tone.

Potentiometer

These both use potentiometers that can be used either as a variable resistor (with two legs connected) or a voltage divider (with all three wired up). In other words, one hookup controls ohms and the other controls volts. I’ll let you guess which version controls which function on the guitar.

Motion Detector

Ever tried to break into somebody’s house, but they had one of those pesky motion detectors that lit up the whole property and nearly got you busted? No? I guess that’s just… a friend…

Well, you get one of those pesky… I mean… cool motion detectors, too. It’s actually called a passive infrared sensor (PIR), and it makes things happen when you wave your hand in front of it. Better than a button? You be the judge.

Screen and Display

Last but not least (I love overused, trite cliches, don’t you?), we have a screen. It’s actually called an inter-integrated circuit or I2C display. It can show all kinds of nifty stuff from text to pictures. There are some fun things to do with this baby!

Obviously, there are other components you can get like motors, current sensors, reverse-LEDs, and a whole host of things. Some of them require special drivers and such, though, so they wouldn’t be considered basic. For the purposes of this series, we will be focusing on more basic components and projects before graduating to higher-level (and more expensive) experiments.

Keep Learning!

Next time, we’ll get into our first project. It’s pretty easy, but it’s fun and totally worth it. I can’t wait to get started, so I’ll talk to you soon. Until then, try some more of the MicroPython I taught you before. Happy coding!

The post Getting To Know Your Basic UCTRONICS Raspberry Pi Pico Kit appeared first on Be on the Right Side of Change.

In the last tutorial, we covered some very important topics to get you started with learning MicroPython so you can begin working with your Raspberry Pi Pico. There are still a few things to cover, but soon we will dive into the microcontroller itself and try out some fun projects!

Before we get started, recall the last lesson, where we covered some basic syntax, including how to print to the shell, how to group instructions through indentation, and how to write a for loop.

This time, we’re going to go over what’s known as a “while loop”, as well as conditionals and comparative operators. Woohoo! Let’s get started! 

Preparation

If your file “Indentation.py” is not currently open, go to Thonny, and open it from your Raspberry Pi Pico so that we can write in the editor.

Recommended Tutorial: Getting Started With Thonny – The Optimal IDE for the Raspberry Pi Pico

You can erase the current for loop and start fresh, but first, let’s try something.

A Note on Code Commenting

Make the current loop inoperable by highlighting the entire code and pressing Command+3 on Mac or Control+3 on a PC. 

This is what we call “commenting out” your code, which basically turns the code off, so it doesn’t work without having to delete it altogether. Toggling code from being commented to uncommented will come in handy later when you start testing which lines of code do and don’t work.

Comments are also important to keep track of your thoughts and instructions so you can go back and refer to what you were trying to do with specific code as your projects become more complex.

A comment is preceded with a #, which will render anything you write to just be static text.

Ok, now that you understand commenting, let’s go ahead and delete the existing code since we know we aren’t going to need it again.

While Loops

While loops differ from for loops in that they are designed not to perform instructions a set number of times, but rather while certain conditions are met.

As such, while loops can sometimes result in what we call “infinite loops”. If the only condition we want to specify is that our program is to run, then we are creating an infinite loop.

In this case, we will want to make use of the Stop icon on the toolbar in Thonny.

The way we tell the program to run is simply by stating

while True:

So let’s try an infinite loop that will print "Loop running!" that we will have to use the Stop icon to, well, stop!

It should look like this:

while True:
    print("Loop running!")

Pretty simple, right?

Well, there is one tiny issue. A loop this simple can run too fast and chew up your computer’s resources, so we need to slow it down a bit so as not to overload our processor.

We do this by importing a library called Utime. We will get into more detail about libraries as we start programming the Pico in another installment, but for now, let’s just focus on the task at hand.

Go to the very top of your editor (line 1) and type:

import utime

Then we will add the while loop and include a delay plus another print function to show the loop ending:

while True:
    print("Loop running!")
    utime.sleep(1)
print("Loop finished!")

Click the Run icon to start the program again, and you’ll see "Loop running!" continuously printing in the shell with a 1 second delay between each print (that’s what’s happening when you use utime to sleep for (1)).

When you click the Stop icon, you’re actually interrupting the program, and the MicroPython interpreter will restart.

As a result, you’ll notice that the words "Loop finished!" never end up printing since the loop never ends until you interrupt the program, which stops it from ever getting to the final print instructions.

Womp, womp!

Inputs, Comparison Operators, and Conditionals

Cool! So now that you’ve written an infinite loop, let’s try another kind of while loop that checks for a certain condition.

But first, let’s create an input so that we can experiment with making the condition we’re going to use either true or false.

In order to do that, we are going to define a new variable that will be checked for the trueness (or lack thereof) of the condition. For this new experiment, open a new file and save it as “Name_Test.py” then on line 1, type:

user_name = input("What is your name? ")

Notice there is a space after the question mark and before the closing quotes.

This is simply so that there will be a space between the question and your answer and is a common convention in Python.

Click the Run icon, and you’ll see the question appear in the shell, where you can type your answer right next to it. My name is Steve, so I’ll type that and hit Enter or Return. 

Notice nothing happens except you get a new command line in the shell.

That’s because you haven’t told MicroPython what to do with your name input. That’s what the next while loop is going to do. In this loop, we’re going to have a message that will print only if you have a certain name.

If not, then a different message will print and you’ll be re-prompted to input another name.

So how do we denote whether a name is equal to or different from the name checked for in the loop?

By using what we call comparison operators. The primary comparison operators we can use are:

• == – equal to
• != – not equal to
• >= – greater than or equal to
• <= – less than or equal to
• > – greater than
• < – less than

Got it?

So that means that if we want to compare a name to our input, we need to write our loop using either the == or != operator.

And since we want to print a message and generate a new prompt any time the name doesn’t match, we want our loop to run whenever there is not a match.

But what if there is a match?

Well, we’ll give instructions for that outside of the loop with just a simple print command like before. Let’s use the name Bruce Wayne.

So under your user_name input in the editor write:

while user_name != "Bruce Wayne":
    print("You’re not Batman! Try again!")
    user_name = input("What is your name? ")
print("You’re Batman!")

Nice! That’s pretty much all you need to know about loops for now, but there is one other neat thing we can do with this comparison that will have a similar effect but doesn’t use a loop to check a condition’s trueness.

Conditional Statements

It’s called… yep, you guessed it – a conditional statement! 

These are used all over the place and use the terms “if” and “else“, returning a result if a condition is met or else returns something different.

In this case, it’s simpler than using the while loop, but the major difference here is that since we are not running a loop, you would have to click the Run icon again in order for another input to be considered.

For this example, we will simply write:

if user_name == "Bruce Wayne":
    print("You’re Batman!")
else:
    print("You’re not Batman!")

How cool! Try some different loops and conditionals on your own.

In the following tutorial, we’ll start looking at a basic Raspberry Pi Pico kit and its components. Until then, happy coding!

Keep Learning: Getting To Know Your Basic UCTRONICS Raspberry Pi Pico Kit

The post MicroPython Basics – While Loop, Operators, and User Input appeared first on Be on the Right Side of Change.

When learning how to program your Raspberry Pi Pico, you need to learn basic concepts of a limited version of the Python programming language known as MicroPython.

It’s a great way to learn Python, as it is much simpler than Python, which can be very complicated and take a long time to master.

For the purposes of using a microcontroller, you only need to know some basics to get started.

Before we jump in, let’s take a quick moment to familiarize you with your Python IDE, Thonny.

Using Thonny

To get started, there are three parts of the interface that you should be aware of — the toolbar, the editor, and the shell.

(1) Toolbar

The toolbar has icons that will help you do a few things, such as creating new files, opening existing ones, and saving, just like you see with most programs.

The other things you’ll want to notice are the green button, which will run your programs that you write in the editor and the stop button which will end programs that run forever.

We’ll get into that in the next tutorial.

(2) Editor

The editor is where you will write your programs that you will save and run by using the run button in the toolbar. You may also see or hear this referred to as the script area, as this is where you write your scripts.

(3) Shell

The Python shell has two purposes.

You can run individual instructions by hitting the Enter key without having to write them in the editor and run them, but this only really is good for simple instructions. You won’t use it to write complex code.

The second purpose is to provide information about scripts that you have written, including where errors might be in your code.

This is sometimes referred to as REPL, which stands for

• Read,
• Evaluate,
• Print, and
• Loop.

In the following tutorial and video, I’ll show you how to get started with the Thonny IDE—feel free to check it out!

Recommended Tutorial: Getting Started With Thonny – The Optimal IDE for the Raspberry Pi Pico

Writing Your First Code

Ok, so now that you know the parts of the interface, let’s try some code to get started.

We’ll begin with the universal first program, “Hello, World”. First, we’re going to try it in the shell since it’s only a one-line command.

Type the following command like so:

print("Hello, World!")

The results should be that the words "Hello, World!" print in the shell, but without quotation marks.

This is the syntax we use when we want to print something – print(), with whatever you want printed put inside the parentheses. If it’s words, we put them inside quotes.

Now, we’re going to run the program from the editor.

If you want to clear out anything you’ve done in the shell or just start fresh, then click in the shell and press either Command+k on a Mac or Control+k on a PC.

Personally, I like to keep my shell clean and clear when I’m doing something new.

Ok, so now that you’ve cleared the shell (if that’s what you chose to do), type the same command as before into the editor, then click the Save icon.

When prompted to decide where to save the file, choose the Raspberry Pi Pico and title your file "Hello_World.py". Don’t forget to add the ".py" to the end, as this is the file extension that denotes a Python file.

We’ll do that with every file we create with Thonny.

Once you’ve saved, click the green Run button in the toolbar, and you’ll see Hello, World! print in the shell as you did before.

There are two things going on here.

First, you are telling Thonny to print something out in the shell, and second, by using quotation marks, you are telling Thonny that what is to be printed is a string of text.

In programming languages like Python, there are what are known as “primitives”, which are basic data types to work with in your programming.

Those data types are:

• Strings – just plain ol’ text, like "Hello World"
• Integers – whole numbers, like 42
• Floats – numbers with decimals, like 3.14
• Booleans – choices between two options, like True or False

Loops and Indentation

Now you’re going to write your first loop, which is simply a term that refers to a set of instructions to be repeated.

You will be writing those instructions in a specific type of way. The reason for this is that Python programs run from top to bottom, but your interpreter is dumb.

It only knows what you tell it, so the way we give instructions to the Python interpreter is by grouping those instructions with indentations.

What we’re going to do is tell Thonny to print some text, run a loop, then print more text. When we give the instructions that are to be repeated by the loop, we will indent those instructions so that Thonny will “understand”.

There are two primary loop types, but today, we are only going to focus on what is called a “for loop”, which runs a defined number of times.

First, let’s start a new program by clicking the new file icon (the white piece of paper ) then writing some code in the editor like so:

print("Loop starting!")
for i in range(10):

Then hit the Enter (PC) or Return (Mac) key. 

What you’re doing is assigning a variable, i, for the loop to use as a counter and telling it that i will be every number in the range of 10 as the loop is performed.

In other words, the instructions will be repeated 10 times, as defined by the range.

Info: Python is known as a 0-indexed language, which means the default start of the range is 0 rather than 1, so 10 is not included in the range. Therefore, numbers starting with 0 is the range 0-9, so i will be the numbers 0-9 in this example.

The other thing to notice here is the colon : at the end of the line.

That tells Thonny that you are about to give it instructions for the loop you just told it will be performed. When you hit the Enter or Return key, not only will a new line be created, but it will also automatically start at an indented 4 spaces in.

This is where you’re going to tell Thonny what instructions to repeat. For the sake of this exercise, we’re simply going to print to the shell.

However, this time, we’re going to print both a string and whatever number i happens to be for each repetition of the loop.

So to do that, type 

print("Loop number", i)

We need to separate multiple data types being printed on the same line with a comma so that Thonny “knows” that there are separate things to interpret because again, your interpreter only knows what you tell it.

After that, hit Enter or Return for a new line, but this time, hit the backspace key.

We don’t want Thonny to repeat the next instructions, so we need to make sure they are outside of the loop.

Then type 

print("Loop ended!")

Your whole program will look like this:

Here for copy&paste:

print("Loop starting!")
for i in range(10):
    print("Loop number", i)
print("Loop ended!")

Now go to the toolbar and click the save button. We’re going to call this “Indentation.py”. Once saved, click the green Run button, and you’ll see the results:

Ok, I think that’s enough for today. Try changing the range from 10 by adding a start and stop number like this:

for i in range(x, y):

With x and y being whatever numbers you choose.

For example, if you use range(3, 14), i will print as the numbers 3-13, since the last number is never included in the loop. If you want to print 1-10 instead of 0-9, you should use range(1, 11) and so on.

Thanks for Reading!

Next time, we will try a different kind of loop and explore what are known as “conditionals” that perform actions based on whether certain criteria are met. Until then, happy coding!

Next Tutorial: Learn Basics of MicroPython – Part 2

The post Learn the Basics of MicroPython for Absolute Python Beginners appeared first on Be on the Right Side of Change.

So you’ve decided to learn about microcontrollers and programming electronics. That’s great! There is a whole world of fun and exciting things to do in this realm, but for some, it can be a bit overwhelming when first getting started.

Fear not – the newest iteration of microcontrollers from the Raspberry Pi institute is here, and it’s about the size of a stick of gum. Welcome to the Raspberry Pi Pico. 

Basic Pi Knowledge

Before we get started working with the Pico, there are a few things to know. This tutorial is not meant to be an exhaustive lesson on the Pico itself, but there are some different variations that will come in handy to understand as you are getting things set up.

There are two primary variations of the Pico, and there are two ways you can receive the processor. The two versions are wired and wireless, and the two ways they ship are with and without headers pre-soldered onto the board. 

The traditional formats are Pico with no headers and Pico H with the headers pre-soldered. The wireless versions are the Pico W and Pico WH.

This is important when we get to selecting and installing the proper Python interpreter for Thonny, the Integrated Development Environment (IDE) used to write the Python code that will control the devices used in your Pico projects.

With that out of the way, let’s jump into Thonny, where you will make all the magic happen!

Downloading and Installation on Mac and Windows

Once you have connected your Pico to your computer, you will need to download the Thonny installer from their website at https://thonny.org/.

From there, you will see a box on the main page where you can download the package for Windows, Mac, or Linux here:

Linux: While there is a download link for Linux, we will focus on Mac and Windows, as the typical beginner is not likely to be on a Linux platform, and there’s no need to add any complexity in this tutorial.

Another thing we will assume here is that you do not currently have Python installed on your computer and that you will use the full installation package with Python included.

Recommended Tutorial: How to Install Python?

MacOS: First, let’s start with Mac since the process is about as straightforward as it gets. For Mac users, it’s simply a matter of clicking the link to download and then clicking on the downloaded file to initiate the installation. That’s it. Easy-peasy.

Windows: With Windows, the process depends partly on what browser you typically use. If you’re using Firefox, Chrome, or some clone thereof, again, it’s generally a simple process. However, if you use Microsoft Internet Explorer, get a new browser (ha!). All kidding aside, if you use IE or Microsoft Edge, you may run into a SmartScreen Filter issue.

SmartScreen Filter was introduced with Windows 8 in order to make it more difficult to download and install malware onto your system, and it is known to flag Thonny as “unsafe”. If this happens, there are two ways to move forward.

First, if you see this:

Click “View Downloads”, where you should see a window that looks something like this:

Simply click on the option that says “Run anyway”, and the installation will proceed.

The other option is to open your Downloads folder and just run the program from there.

If you’re prompted with the question “Do you want to run this file?” or “Are you sure you want to run this file?”, click run, and you’re good to go. This is not an unsafe file, but sometimes, unfamiliar .exe files trigger this response so it’s good to know about it beforehand.

Installation of Python Interpreter

Now that you have installed Thonny along with Python, you will need to make sure that you are using the correct Python interpreter for your Pico.

Once you have downloaded and installed Thonny, you should be prompted to run the program. If not, simply open it just like any other program or app, and take a look at the bottom right-hand corner.

It should say something like “Local Python 3 ^●  Thonny’s Python” like so:

You’ll notice that my Thonny has already been configured, but yours will not be yet. You will not have dark mode enabled, and you will not have other Python interpreters installed. First, let’s choose a Python interpreter. 

Since the Pico is a simple microcontroller, we will be using Micropython, and the version you choose will depend on which kind of Pico you have. If you have a standard Pico or Pico H, select the corresponding interpreter, and if you have a wireless Pico W or Pico WH, select that interpreter and install.

NB: If you have the Pico plugged in, but it doesn’t seem to be recognized by your system, you may need to reconnect it while holding the “BOOTSEL” button next to your micro USB port. Once you release the BOOTSEL button, you should see the Pico connected.

Recommended Tutorial: Learn the Basics of MicroPython for Absolute Python Beginners

Customization of Settings

Alright, now let’s configure the settings as we like them. I happen to be a big fan of dark mode for most things, as it is easier on the eyes for me. First, you’ll need to select “Tools” in order to get to the options dialog:

Here, you will have several configuration options.

For most intents and purposes, Thonny’s default configurations will get the job done for programming your Pico. That said, you may not like the theme and font options (I wasn’t a big fan), so you can change them as you see fit.

There are a few different light and dark modes, as well as font options for both your editor and your shell (IO). You can see how I have set mine up for my own tastes.

That’s really it for getting started. You may need to restart Thonny for the changes to take effect. Now that you have installed and configured your Thonny, you are ready to start programming your Raspberry Pi Pico and dreaming up your own projects. Have fun!

Recommended Tutorial: Top 5 Hardware Developer Job Roles

The post Getting Started With Thonny – The Optimal IDE for the Raspberry Pi Pico appeared first on Be on the Right Side of Change.