Turning off the Circuit Python storage device

When you connect a CircuitPython powered device to a desktop PC the device appears on the PC as a usb storage device onto which you can write your program and data files. If you don't want this to happen you can put a **boot.py** file on the device. When a CircuitPython powered device wakes up it runs the program in this file.

import storage
import usb_cdc

# Disable USB mass storage
storage.disable_usb_drive()

# Keep USB REPL enabled to allow deploying files via REPL tools
usb_cdc.enable(console=True, data=True)

# Remount the filesystem so CircuitPython code can write to it
storage.remount("/", readonly=False)

This program disables the usb storage, ensures that we can still deploy files using the REPL commands and then remounts the Circuit Python file system so that it can be written to.

Note: If you don't enable the REPL console you will have a slightly more secure device (it will not be possible to easily fiddle with the filestore via a serial connection). However, you will have to erase the current program in the device if you want to make any changes to it.

Using CircuitPython’s Two USB Serial Ports

If you want to find more Python Shorts you can find them here.

Making a CircuitPython program talk to a usb serial device is quite easy to do:

import usb_cdc

# Send a line of text to the host
usb_cdc.data.write(b"Hello!\n")

# Wait for a line of text from the host
while True:
    if usb_cdc.data.connected:
        try:
            line = usb_cdc.data.readline()
            if line:
                print("Received:", line.decode("utf-8").strip())
        except Exception as e:
            print("Error reading:", e)

Howwever, when using CircuitPython on boards like the Raspberry Pi Pico, it exposes two USB serial ports over USB:

• usb_cdc.console → used for the REPL (interactive shell)
• usb_cdc.data → intended for raw programmatic communication

When you use a browser that supports Web Serial (like Chrome or Edge), it might show both ports as separate choices. It's easy to accidentally connect to the console port instead of the data port. Your CircuitPython code ends up listening on usb_cdc.data, but the browser is sending to usb_cdc.console.

There are two ways you can fix this:

• Try both ports while connecting
• Or disable the REPL/console port in production using:

# boot.py
import usb_cdc
usb_cdc.disable(console=True)

Note that if you disable the console port you will not be able to interact with the device using tools such as Thonny. You will have to erase the EEPROM in the PICO and the re-flash it to get back control of the device.

Python Shorts 12: Fun with string formatting

We can use Python formatted string literals to easily drop values into strings of text. But we can also have even more fun with them when we add extra information to control the formatting process. This is particularly useful when we are creating messages to be displayed on devices with particular dimensions.

For example. perhaps I want to display the time on an LCD panel. I want the hour and the minute to have leading zeroes (so that they look like a digital clock). I could write some cunning code to add the zeroes if the values are less than 10, or I could use a formatted string:

hour=5
minute=6

These are our time values. If we want to make a digital clock out of them we just need to do this:

time = f"{hour:02}:{minute:02}"

Note that each expression to be output is now followed by a colon and a couple of digits. The first digit means "Pad the number with zeroes". The second digit means "display the value in two spaces". So the time string is set to:

05:06

If we don't want to pad the number with zeros, but use spaces instead, we just omit the leading zero.

f"{0:10}"

This string literal ends up being 9 spaces followed by a single zero.

We can add a decimal point to our formatting values to control the number of decimal places displayed when using floating point values:

x=f"{3.141592653:10.3f}"

This would create a 10 character long string with a three decimal place value of the high-precision value of Pi:

'     3.142'

Note that the f after the 3 in the fornmat (the number of decimal places) tells Python that you are outputting a floating point number and it must have three decimal places. If you leave out the f Python assumes you are outputting a general value and will just display three digits (3.14).

Things get even better when we start using control characters to select the text alignment:

f"{'Menu':^10}"

This would centre the word Menu in a 10 character string. Jolly useful if you want to line things up for a particular sized LCD panel. You can use < and > to left or right justify the string inside the field. And it gets even funner (if that is a word). You can even use variables to control this formatting behaviour:

display_width=16
banner=f"{'Menu':^{display_width}}"

The above statements make a banner which is 16 characters long and contains the word Menu centred in it. If you want to change the size of the display you are using, just modify display_width

It is worth getting good with format strings, they can save an awful lot of work.

Python Shorts 11: Formatted string literals

Formatted string literals are amazingly useful. You can make your Python output look really good, whether you are printing on the terminal or assembling a message to be displayed on an embedded display.

There are several ways to create formatted literals. I like the “f-string” approach which works in later versions of the language, including MicroPython and CircuitPython.

Let’s start with some values we might want to output:

name="Rob"
age=21

We can create a formatted string to display this values as follows:

message = f"Name:{name} Age:{age}"

The f in front of the string tells Python to scan the string and look for braces (curly brackets) that identify expression values to be included in the string. The values of name and age are inserted into the string in the specified positions. If you actually want to put braces into your text you have to enter two of them:

age_braces = f"{{{age}}}"

This would create a string containing the value of age enclosed in braces.

Python Shorts 10: Going Global

A variable is a box you can name to put something in. In Python you can just make one:

 age=21

Python decides it needs to make a variable (age is not a word Python knows), looks at 21, decides that it needs an integer shaped box, makes one,  puts 21 in it and then paints the word age on the box so it can find age later. So far, so normal. Let’s make a function:

 def brokenFunc():
    print(age)

There’s a clue here that bad things are about to happen. If you run this you get: 

UnboundLocalError: cannot access local variable 'age' where it is not associated with a value

This is because the body of a function (the indented bit after def) is a separate variable scope. The scope of a variable is those areas of your code where statements can work with it. Any variables created in a function body are local to the function and disappear when the function completes. Variables are either global (declared outside all functions) or local (declared inside the body of a function). If you want to be able to access global variables inside a function body you need to tell Python

 def mendedFunc():
global age
    print(age)

Code in the body of mendedFunc function can now access age (and also change it). Forcing programmers to explicitly state when they are using global resources in their code helps prevent errors which would be caused if the same variable name is used in more then one context. If one part of the program is manipulating the age of a person, and another part of the program is manipulating the age of the house they want to buy, we don’t want these getting mixed up when the program runs.

Python Shorts: 09 Dictionary madness

You can have all kinds of fun with dictionaries.

First off, you can add things to a dictionary any time you like:

z={"name":"Anne","age":21}

This makes a dictionary called z

z["address"]="18 Pussycat Mews"

This adds an address item to the dictionary. But for super fun you can use any kind of value as a key for an item:

z[1.5]="This is crazy"

This uses the value 1.5 as a key. What with computer floating point maths not being as accurate as you might like, using floating point values as keys to dictionary entries is not advisable, but using integers can be very sensible. And if you are doing things like counting the number of letters in text, or putting ranges of values into buckets you can use dictionaries to very good effect.

Python Shorts: 08 Dictionary Fun

Dictionaries are fun. As we saw last time we can use them to create lumps of data with named contents:

z={"name":"Anne","age":21}

This makes a dictionary called z with two things inside it, name and age. We can get these out by name (as it were):

n = z["name"]

One thing to watch out for is that you need to get the search item (or key as it is called) exactly right:

n = z["Name"]

This would end badly, with an exception which will stop your program:

KeyError: name

If you are worried about your program crashing when you try to get something out of a dictionary, you can use the in operator to check:

if "name" in z:
print("we have a name")

As a side note, I’m using square brackets to enclose the key we want to find. You can use the get function instead:

n = z.get("name")

This would set n to the name in z.

More on dictionaries later, as we explore dictionary madness.

Python Shorts: 07 Dictionaries

You may have spotted a problem with lists and tuples. When we talked about functions we worried about the situation where we use the wrong order of parameters to a call. We can get the same problem with lists and tuples:

The statement above would set the age of person y to “James”, which would not be a good thing if the age value was stored in location 1. It would be lovely if we had a data structure that let us explicitly name the data elements in it. It turns out that we do, and it is called a dictionary:

z={"name":"Anne",
"age":21}

When you make a dictionary you give it a set of key – value pairs. This means that everything that is stored has a name – the key which is used to access it. The dictionary referred to by z has two keys, name and age. You can use these to get hold of the values:

n = z["name"]

The above statement gets the value of the name item in z. In this case the value of n would be “Anne”. Dictionaries are fun. We’ll have more about them in the next short.

Python Shorts 06: List Fun

Python lists are nice. We can make them very easily:

x = [1,2,3]

The order of the list is preserved. If we work our way through the elements they will always come out in the same order. We can use the len function to find out how many things are in a list:

l = len(x)

If we want to add something to a list we can use the append behaviour provided by lists:

x.append(5)

This will pop 5 on the end of the list. There’s no “prepend” function for putting something at the start of a list. Instead there’s an insert function that can be used to insert something at a particular position:

x.insert(0,0)

This statement would put the value 0 at the start of list x. You can use the remove behaviour to get rid of an element at a particular position in the list and pop, which removes an item and returns it.

Python Shorts 05: Lists

Making a list looks very like making a tuple:

y = ["Jim",25]

The statement above makes a list called y. Note the use of square brackets, which is different from how we make a tuple (which uses round brackets). Lists are a lot more flexible than tuples. For one thing we can change the content of their elements:

y[0]="James"

This statement changes the item at the start of y to “James”.

Python Shorts 04: Tuple of One

We’ve seen that we can create a tuple by using brackets to “squish” things together:

x = (“Rob”,21)

Tuples are very useful if you want to return multiple values from a function:

return (“Rob”,21)

This lets me return name and age values. However, sometimes you might want to return just one item in a tuple. You might think you do this:

x = (1)

However, this doesn’t work. Python thinks that the brackets are part of an expression, gets rid of them and puts the value 1 in x. If you want to make it clear to Python that you are making a tuple, put a “spare” comma on the end:

x = (1,)

This would “tupleise” the value.

Python Shorts 03: Tuples

Tuples should be called “lumps”. You can squish things together to make a lump. Tuples let you squish data together.

x = ("Jim",25)

The statement above creates a tuple called x which contains name and age information. Tuples can contain lots of data. The best way to unpick them is to use a cunning assignment:

(name,age)=x

This creates variables called name and age which hold “Jim” and 25 respectively.  Another way to get values out of a tuple is to index it:

name=x[0]

age=x[1]

The item at the start of the tuple has index value 0. Tuples are read only:

x[0]="James"

The statement above tries to change the in the x tuple. This will not work. Tuples are great for passing lumps of data around a program but no good for things you might want to modify. If you want to be able to change things in a lump of data you need use a list.

I find tuples very useful, but I do worry that the thing making the tuple and the thing using the tuple have to agree on the order of the elements. As we saw with name and age in function parameters this might lead to confusion. If you want both ends of a conversation to be absolutely clear about which data means what, you can use dictionaries to do that, but they are coming later.

Python Shorts 02: Default parameter values in functions and methods

We’ve seen how to make parameters clearer in calls, now let’s add some magic to the function itself. Sometimes we might only have the name of the person, can we make an add_person which will handle only one input? Yes, we can.

def add_person(name, age=3):
   print("Adding a person")

The code above creates an add_person function which has name and age parameters. The age parameter is set to 3 if it is missed out. Programmers call the value 3 the “default” value.

add_person(name="Simon")

This would add a person with the name Simon with age 3. You may be wondering why I picked 3 as the default. If we were writing a system to control access to fairground rides, we want to make it as safe as possible. Simon would only be able to go on rides which are suitable for 3-year-olds. If they want to go on the bigger rides, they must give their age.

add_person(name="Rob")

Note that if you want to use default values like these you must put the parameters with the default values at the end of the parameter list when the function is defined.

Python Shorts

I’m trying something new for April. I’ve got a whole bunch of tiny posts about Python which I’m going to be releasing over the next couple of weeks. Each one of them reveals a facet of the language that you might or might not know. If you know it, never mind - there’ll be another one along the next day. They start on Friday.

If there are any specific Python topics you’d like to know more about, post in the comments and I’ll see what I can do.