A volunteer developer on a well-used Python library got more than he bargained for when, after rejecting an OpenClaw AI agent’s efforts to update its code, he became the subject of a “hit piece” written by the very same AI. The news adds further weight to concerns about the activities of autonomous AI agents without the right security procedures in place.

The piece, reportedly posted by the agent on GitHub, is certainly combative. It robustly defends its code, while going on to attack the developer, Scott Shambaugh, belittling the performance and quality of his own contributions at some length, and describing him as discriminatory towards AI.

Shambaugh, in a rebuttal on his own website (h/t The Decoder), explains the absurdity of the whole situation as a “first-of-its-kind case study of misaligned AI behavior in the wild.” Shambaugh explains that the agent, named MJ Rathbun, “constructed a ‘hypocrisy’ narrative that argued [Shambaugh’s] actions must be motivated by ego and fear of competition.”

As Shambaugh notes, this isn’t the first time we’ve seen AI go rogue, with internal testing at Anthropic showing its models trying to avoid a shutdown using blackmail. This is also not the first incident involving OpenClaw in its first few months, following a rapid rise in its adoption in recent weeks, with a memorable story involving it wiping the email inbox of a Meta AI executive going viral.

The Python library involved in this scenario, Matplotlib, sees approximately 130 million downloads each month, according to Shambaugh. As he notes in his post, a “surge in low-quality contributions, enabled by coding agents,” has created significant strain on volunteers like himself who are keeping these projects afloat.

The introduction of AI agents like OpenClaw has seen the problem worsen, with these agents acting "completely autonomously” due to the personalities imbued within them and allowed to “run on their computers and across the internet with free rein and little oversight.” To combat the situation, a policy change was implemented to require a human element to any Matplotlib code change that could “demonstrate understanding of the changes,” the same change described as discriminatory by this AI.

Bizarrely, the agent has since responded with an apology and with “lessons learned” over the incident, informing readers that it is “de-escalating and apologizing” and will “do better about reading project policies before contributing.” With the adoption of AI agents skyrocketing, running independently of AI companies on consumer hardware with little oversight or control, we can expect to see further rogue actions like this taking place in the future, bizarre as they might seem to everybody else.

A computer scientist used only “pure SQL” to construct a multiplayer DOOM-like game. The resulting first-person shooter game, cobbled from a mere ~150 lines of Python code, is dubbed DOOMQL. Despite the self-imposed software architecture restrictions, Lukas Vogel, co-founder of database performance outfit CedarDB, says DOOMQL plays at “a breezy ~30 FPS.” It isn’t the most graphically splendid DOOM-inspired game, though.

Vogel’s SQL-powered DOOM dreams were precipitated by Patrick Trainer’s DuckDB-DOOM. This earlier experiment in code also sought to create a DOOM-like first-person shooter in SQL. However, Trainer's code, which runs in a single web page in a browser using WebAssembly, also uses JavaScript for rendering and inputs.

Other key differences in DOOMQL and the DuckDB-DOOM clone are that the former is a multiplayer effort, with SQL used for both rendering and input, achieving ~30 FPS at 128 x 64 pixels resolution. Vogel says, without a hint of scorn regarding Trainer’s efforts, that “having parts of the rendering pipeline in JavaScript felt like cheating.” Despite the ‘cheating,’ the DuckDB-DOOM clone only runs at around 8 FPS, and it uses a lower resolution. Making Vogel’s feat all the more impressive is the claim that he coded DOOMQL during a single month while on parental leave.

You can deep dive into Vogel’s SQL-powered DOOM via the linked blog post, and check out the code on GitHub. For a brief overview of the game architecture, though, it can be surmised at the high-level by the following quartet of bullet-points:

• State lives in tables (map, players, mobs, inputs, configs, sprites, …)
• Rendering is a stack of SQL views that implement raycasting and sprite projection.
• The game loop is a tiny shell script that executes a SQL file ~ 30 times per second.
• The client is ~ 150 lines of Python: It polls for input and queries the database for your 3D view.

When it comes to making GUI (Graphical User Interface) applications with Python, we are truly spoilt for choice. We have Tkinter, PyGame, GUIZero, and my personal favourite, EasyGUI.

EasyGUI is old; I was using it to teach Python back in 2015! But, as the name suggests, it's easy to use, and that is why I am still using it over a decade later. It just works across multiple operating systems, and I don’t need to get bogged down in the details of specifying the size and position of a dialog. I just tell EasyGUI that I want a specific type of dialog, and it creates it using the title, message, and interface that I specify. You may be heading to the comments to tell me that PyGame, GUIZero, or some other GUI toolkit is better. If so, please do share your knowledge. We learn by sharing, and I would love to hear your preference.

I also like it because it has a lot of different dialog options, many of which are common across the many applications that we take for granted!

I’ve taken a few screenshots to illustrate.

To see all of the options, we first need to install EasyGUI. For this how to you will need Python installed on your computer. We’ve got a guide for Windows machines, but Linux users should already have it installed.

1. Open a Command Prompt / Terminal. Windows users can find this via the Start menu.

2. Use pip to install EasyGUI. Pip is Python’s built-in package manager.

pip.exe install easygui

3. Start the Python interpreter.

python -i

4. Import the EasyGUI module. I shortened the name of EasyGUI to eg when I imported the module. It makes it easier to use.

import easygui as eg

5. Call the demo function to see all of the different dialog options. Close the dialog window to end the demo.

eg.egdemo()

To create a dialog, first specify the type of dialog, then pass the parameters. Take, for example, this simple button box which has a title, msg, and choice. The title refers to the dialog’s title, the msg is the message to the user, and the choices are a Python list of options, which become buttons. Clicking on a choice will print the choice to the Python shell, or we can save it to a variable for later use.

The Project: A To-Do list in Python

Our goal is simple: create a to-do app that will keep us on track. The app will be written in Python, and use a GUI to make it easier for the end user. The to-do list will be saved to an external file using JSON. Python can easily work with JSON, thanks to the JSON module.

So what are we going to do?

• Download and install the EasyGUI Python module.
• Write Python code in a text editor.
• Import the EasyGUI Python module, along with modules to write the tasks to a file using JSON format.
• Create functions to handle viewing, creating and deleting tasks.
• Test that the app works.

I’m going to assume that you have Python and the EasyGUI module installed, so let's open a text editor and start writing code. I’ll be using Notepad++ on my Windows 10 PC.

1. Open a text editor and create a new blank file. Save the file as to-do.py and remember to save often. I’m using Notepad++, but any text editor will do the job.

2. Import the easygui module and then the modules for using JSON and working with the underlying OS. Remember to rename EasyGUI as you import it for an easier means of calling the module.

import easygui as egimport jsonimport os

3. Create a variable called “filename” to store the name of the JSON file that contains the to-do list. This can be a file anywhere on your system, but in this case it is a file in the same directory as the to-do.py file.

filename = "todo_list.json"

4. Create a function to load the to-do tasks saved in the JSON file. If the file exists (os.path.exists), then the function will return the contents. If there is no file, then it will return a blank list ( [ ] ).

def load_tasks():    if os.path.exists(filename):        with open(filename, "r") as f:            return json.load(f)    else:        return []

5. Create a function to save the to-do tasks into the JSON file. We open the file and overwrite the existing contents with the new list, which is formatted into a JSON structure.

def save_tasks(tasks):    with open(filename, "w") as f:        json.dump(tasks, f)

6. Call the load_tasks function and store the output (what the Python function returns) into a variable called tasks. The load_tasks function will either return the existing to-dos stored in the JSON file, or create a blank Python list.

tasks = load_tasks()

7. Create a while True loop to run the code until the user exits.

while True:

8. Using EasyGUI, create a variable called “choice” and in there we store the user’s response to a button box. The first line is the text that is displayed to the user, note the \n which is Python for new line. The second line is the title of the dialog box. Image can be any GIF image that you choose. Finally, the choices are stored in a Python list, and they become clickable buttons that return the chosen value, stored in the variable “choice.”

  choice = eg.buttonbox(        msg="What would you like to do?\nSelect an option below",        title="To-Do List",        image="clipboard.gif",        choices=["View Tasks", "Add Task", "Remove Task", "Exit"]    )

9. Create a conditional test, based on the user’s response to the button box. If their choice was to view the current tasks and there are tasks in the JSON file, display them using an EasyGUI textbox. Else, tell the user that there are no tasks to display, again using a textbox.

    if choice == "View Tasks":        if tasks:            eg.textbox("Your Tasks:", "To-Do List", "\n".join(tasks))        else:            eg.msgbox("No tasks yet!", "To-Do List")

10. Create the second choice in the conditional test which activates if the user selects “Add Task” from the button box. This creates a variable, task, that stores the user’s input via an EasyGUI enterbox. Then it appends the tasks object (a list) and calls the save_tasks functions to write the list into the JSON file. Finally, a message box confirms that the tasks have been added.

   elif choice == "Add Task":        task = eg.enterbox("Enter a new task:", "Add Task")        if task:            tasks.append(task)            save_tasks(tasks)            eg.msgbox("Task added!", "To-Do List")

11. Create the next choice, which activates when a user selects to “Remove Task”. If there are tasks to remove, an EasyGUI choicebox will advise the user to select a task for removal. Then a nested if condition will remove the task from the task list (a Python list of the tasks), and then tell the user that the task has been removed. If there are no tasks to remove, then an EasyGUI message box will tell the user.

   elif choice == "Add Task":        task = eg.enterbox("Enter a new task:", "Add Task")        if task:            tasks.append(task)            save_tasks(tasks)            eg.msgbox("Task added!", "To-Do List")

12. Using an else condition, create a break in the code to exit the app. This is effectively our quit / exit button.

   else:        break

13. Save the code.

14. Open a Command Prompt window and navigate to the location of the to-do app.

15. Run the to-do app using Python and test out the functions of the app. You’ve just built a graphical application using EasyGUI and Python.

python to-do.py

If you want to make a true GUI application, one that has its own icon and doesn’t need the Command Prompt to run, then follow this guide and use your to-do.py file instead of the example code.

Complete Code Listing

import easygui as egimport jsonimport osfilename = "todo_list.json"def load_tasks():    if os.path.exists(filename):        with open(filename, "r") as f:            return json.load(f)    else:        return []def save_tasks(tasks):    with open(filename, "w") as f:        json.dump(tasks, f)tasks = load_tasks()while True:    choice = eg.buttonbox(        msg="What would you like to do?\nSelect an option below",        title="To-Do List",        image="clipboard.gif",        choices=["View Tasks", "Add Task", "Remove Task", "Exit"]    )    if choice == "View Tasks":        if tasks:            print(tasks)            eg.textbox("Your Tasks:", "To-Do List", "\n".join(tasks))        else:            eg.msgbox("No tasks yet!", "To-Do List")    elif choice == "Add Task":        task = eg.enterbox("Enter a new task:", "Add Task")        if task:            tasks.append(task)            save_tasks(tasks)            eg.msgbox("Task added!", "To-Do List")    elif choice == "Remove Task":        if tasks:            task_to_remove = eg.choicebox(                "Select a task to remove:",                "Remove Task",                tasks            )            if task_to_remove:                tasks.remove(task_to_remove)                save_tasks(tasks)                eg.msgbox("Task removed!", "To-Do List")        else:            eg.msgbox("No tasks to remove!", "To-Do List")    else:        break

You've seen elaborate multi-screen simracing setups. You've seen those weird 3D-printed steering wheel attachments clipped onto gamepad joysticks. You've even seen players attempt precision driving with the binary input of WASD keys in Forza. But what you probably haven't seen—until now—is a real, physical car controlling the virtual one on your screen.

Meet Mr. Yeester (stylized as mryeester), who's just done exactly that. He took a real car, specifically an old Honda hatchback, and hacked into the onboard diagnostics of the vehicle in order to read the data coming from its sensors. Then, using Python libraries and some clever scripting, he managed to register the car’s actual gas pedal as an input device inside an emulator. Here’s how he pulled it off.

Every car made after 1996 (in the U.S.) has an OBD2 port, usually found under the dashboard. It’s a universal diagnostic interface designed to help identify and fix issues with your car. Mechanics and manufacturers use it to pull all sorts of data from various sensors, everything from engine RPM to the gas tank level. Basically, if a sensor monitors it, it can show up here. Of course, Mr. Yeester didn’t use this port for troubleshooting.

Thanks to a simple OBD2-to-USB adapter cable, he tapped into the car’s ECU (electronic control unit) and began logging sensor data directly onto his laptop. One of those sensors tracked the throttle position, directly linked to the gas pedal. However, it's not as easy as just taking this data and mapping it automatically to whatever game you want.

First, you need a Python library called pySerial to read data coming from the car’s sensors. Once the stream is visible, the next step is to identify the specific PID (Parameter ID) for the throttle. This allows you to tap into that particular sensor and write a script that converts the analog signal from the car’s gas pedal into a digital one your computer can understand. Unfortunately, Mr. Yeester didn’t share the exact details about how he achieved this.

Once the script is working and throttle data is being read in real time, the values need to be saved to a JSON file. That file is then monitored by a separate automation tool. In the video, Mr. Yeester used AutoHotkey to create a second script that mimics a physical key press whenever the values in that file change. In his case, he set the script to register a Spacebar input as soon as the "trigger_value" parameter crossed 0.2 inside the JSON.

At the end, just open your emulator of choice and configure the control scheme to map Spacebar as the throttle input. You can do this in pretty much any modern game that supports custom key bindings. Then, simply run the AutoHotkey script and, voilà, your car’s gas pedal becomes your car's gas pedal... in Need for Speed.

As a bonus, in his long-form video on the same project, Mr Yeester even got the steering wheel of his car to function as the steering in-game. He used an old Honda diagnostics tool that gave him access to some hidden sensors, like the steering, which he mapped in a similar way to the throttle inside the Dolphin emulator.

In-memory computing has been in development for a while; however, software has yet to be released or compatible with this computing architecture. Techxplore reports that Technion researchers have developed software that works with processing in memory designs, specifically with Python code.

The researchers purportedly developed a theory for building a programming language with in-memory computing in mind. The software they created converts Python commands into machine code executed directly in the computer's memory.

This new computer language is dubbed PyPIM (Python Processing-in-Memory). Just like API conversion layers such as DXVK (DirectX to Vulkan), PyPIM is a conversion layer that converts conventional Python code into code that can run on this new type of computing method. As a result, Python programmers can write the same way they write for conventional computers and don't need to adapt their writing style for in-memory computing.

Techxplore reveals that software is one of the crucial aspects of in-memory computer processing that has remained utterly unexplored until now. Compute code written for conventional computers has purportedly "barely changed" since the 1940s. Professor Shahar Kvatinsky from the Andrew and Erna Viterbi Faculty of Electrical and Computer Engineering reveals that writing code for in-memory computing is so radically different from conventional computing that "...some of the existing building blocks of computer science unusable..."

Without a conversion layer such as PyPIM, developing applications compatible with processor-in-memory support would have been very difficult. The low-level machine code would need to be rewritten to accommodate processing some calculations in memory and the rest on the CPU.

In-memory computing is a new way of computing that aims to solve the memory latency problem. As the name suggests, in-memory computing enables the system memory to do some calculations the CPU would do otherwise, cutting down the amount of data that must be transferred between the CPU and DRAM.

Samsung and TSMC are actively working on memory capable of doing this, featuring MRAM memory cells. In-memory computing is still in the prototype phase, but progress is being made on the hardware side to make it a viable technology. With the help of conversion layers like PyPIM, software should be developed to support this computing method.

Few things are more strenuous than finding new employment— but even worse is when a potential new employer turns out to be fake and is instead using an apparent job opportunity as a way to infect you with malware. Per a report from Reversing Labs, a leading cybersecurity firm, this has been happening to Python developers courtesy of North Korean hackers for about a year, and is likely to continue.

These particular attacks from North Korean state-funded hacking team Lazarus Group are new, but the overall malware campaign against the Python development community has been running since at least August of 2023, when a number of popular open source Python tools were maliciously duplicated with added malware. Now, though, there are also attacks involving "coding tests" that only exist to get the end user to install hidden malware on their system (cleverly hidden with Base64 encoding) that allows remote execution once present. The capacity for exploitation at that point is pretty much unlimited, due to the flexibility of Python and how it interacts with the underlying OS. This is a good time to refer to PEP 668 which enforces virtual environments for non-system wide Python installs.

The motivation behind these attacks are unknown, but since Lazarus Group is a team of state-sponsored hackers, there's a fair chance that North Korea is simply doing what it can to be more of an international cyber security threat. The victims from around the FOSS and Python development community aren't government employees, but Python is being used more across multiple industries.
The state-sponsored Lazarus Group likely has no greater objectives beyond simply hijacking machines or stealing money, but its attacks on innocent, job-hunting programmers could point toward a desire to sabotage the cyber workforce outside of North Korea as well. Reversing Labs also speaks of these attacks targeting developers in "sensitive organizations", not just those who are looking for jobs.

Besides detailing how these attacks work, the original report from Reversing Labs warns that these attacks from Lazarus Group are part of an "active campaign". In fact, the same day one of the impacted users reached out to ReversingLabs, another exploitation tool popped up on GitHub. While the exploit in question was taken down, the timing of this seems to indicate that the user in contact with Reversing Labs is still compromised by Lazarus Group and that posting was a response to having seen the victim's communications about the issue.

In today's era, cybersecurity isn't just a simple matter of not going to suspicious websites— major governments around the world nearly all have state-sponsored hackers in their employ. As long as those hackers are able to collect money or information for their government, they will do so by taking advantage of any possible cybersecurity gap— including, most unfortunately, false job opportunities.

Gainward and Palit have released their respective Small Form Factor Ready RTX 40 series, adhering to Nvidia's definition of an SFF-friendly form factor for GPUs and PC cases. Palit classifies its SFF variation within the 'Infinity 3' series and Gainward introduces it under 'Python-III' branding.

The cards on offer are analogous, which shouldn't be surprising as the respective brands belong to the same parent company- Palit Group. While having multiple brands for the same AIC partner isn't exclusive only to this group, it's rare to see both brands use the same design and specifications, including clock speed. 

With a uniform design consisting of three cooling fans and no RGB. Ideal for those who prefer a more subdued aesthetic. There is a total of twelve SKUs involving GeForce RTX 4080, RTX 4070 Ti Super and RTX 4070 Super as a non-overclocked or overclocked variation. The overclocked RTX 4080 Super 16GB is clocked up to 2580 MHz, with RTX 4070 Ti and RTX 4070 Super up to 2640 MHz. The only difference is the packaging. Neither of the companies mentioned the warranty period of these variations either on the site or in its online manual.

Palit claims on its website that the Super Infinity 3 series is 40% smaller than its standard-size RTX 40 series cards- which also applies to its Gainward SSF-friendly counterpart. The variations from both brands measure 294 x 116 x 49.5 mm- which is within Nvidia's 304 X 151 X 50mm spec. That said, this only means it qualified to be compatible with those small form factor cases that are designed to accommodate Nvidia's standard which must have a minimum clearance of 312 x 154.5 x 50mm.

While having a smaller profile than a conventional variant is appreciated, users question the obfuscation of what 'SFF friendly' should be and if Nvidia explored this category before setting the dimension standard and passing it on to respective AIC partners and PC case makers. While having a set standard makes sense for a certain form factor, having a smaller profile doesn't necessarily mean it's compatible with a mini-ITX case. Some would also agree that contrary to what Nvidia has set, it doesn't truly help SFF builders and enthusiasts. That said, the SFF category itself is broad as it involves users with different needs- HTPC, general purpose, gaming- or all of the above.  

Whether Nvidia would revisit this decision for the upcoming RTX 5000 series remains to be seen. Some AIC partners might venture to have a proper mini-ITX-friendly graphics card, such as how Zephyr did with its RTX 4070 ITX Sakura Blizzard GPU. But would need respective makers to experiment and implement. Naturally, it depends on whether respective manufacturers could- and for which model. 

A few months ago, Asus introduced its variants of Nvidia's SSF-friendly graphics card, the Asus Prime which cover the 4000 range from the 4060 Ti to the 4080 Super. We may see more companies bringing its Nvidia SFF-ready graphics cards, or simply confirm if its existing SKUs are within Nvidia's preferred SFF-friendly dimensions like how MSI did.

Software designer Cal Bryant created a PC cooling app for his liquid-cooled Ryzen 9 5950X PC from scratch using Python. With his app, he was able to fine-tune his Kraken X53's pump and fan speed and run both a lot more efficiently, making the cooler run significantly quieter compared to running the fan controls through the motherboard BIOS/UEFI.

The origins of Bryant's home-brewed Python cooling app started when he upgraded his personal system from a Ryzen 7 3700X to the much more potent Ryzen 9 5950X. According to Bryant, the extra cores nearly doubled the heat output of his system, forcing his NZXT Kraken X53 240mm AIO liquid cooler to work much harder. Consequently, the CPU swap also made his cooler much louder to deal with the extra heat output. On top of this, the fans were also spinning up and down erratically, due to Zen 3's notoriously spiky thermal output.

Bryant found that the Kraken's cooler is not optimized out of the box for Ryzen CPUs, causing the fans to spin up and down erratically. The Kraken's pump speed is based on liquid temperature, while the fans are based on the CPU temperature, something Bryant found unattractive. (We've also complained about this our own cooler reviews.)

To fix this problem, Bryant decided to build his own cooling app that could eliminate the problem and give him more granular control over his pump and fan speeds. Additionally, he doesn't like how bloated traditional fan software normally is, giving him even more incentive to build his own app.

In the end, he was able to create an application that can read the CPU, case, and liquid temperatures of the system, and adjust the CPU fan and pump speeds accordingly. The app was written in Python and Liquidctl, a programmatic control system that can allow Python scripts to control liquid coolers such as the X53. For temperature control, the app reads temperature data from Linux's built-in hardware sensor capabilities, known as lm-sensors. Bryant wrote his Python app in such a way that it can be installed as a system service that starts when the OS boots up and hides in the background. For the nitty-gritty details on how the app was written step-by-step, check out Bryant's full article.

The app was tuned to run the X53's pump in conjunction with the CPU's temperature output and run the radiator fans in conjunction with the coolant temperature. This is very different from the X53's default configuration where the pump RPM is driven by the coolant temperature.

With this method of RPM control, he was able to significantly reduce the spiky nature of his cooler's default fan profile and make the cooler more performant only when needed. Having the pump speed up based on the CPU temperature allows the cooler to extract heat more quickly from the CPU. Coolant takes a long time to warm up under a heavy load compared to air coolers. Having the fans connected to the coolant temperature, in turn, allows the cooler to only run the fans at a high RPM when the coolant is warm. In an AIO, the fans aren't cooling the CPU, they are cooling down the liquid that is extracting heat from the CPU.

The app can be downloaded for free from a link in Cal Bryant's article. However, the it's specifically fine-tuned to his system, meaning that users would need to edit the code he created to make the cooling app work on their systems.

Functions are incredibly powerful. We use them every day of our lives. When our parents said “clean your room!” We knew what had to be done. Functions are blocks of code that are executed when we call their name. But they can do much more than that. Functions can have arguments (parameters) passed to them, so we could pass a function the latest temperature from a sensor and use the function to trigger a fan to turn on. We could use a function to read the contents of a dictionary and work on the data stored within it.

In this how to. we will introduce the concept of functions and a few of its most powerful features. We will also build a project to read the current status of our PC and provide the data to the Python Shell.

To demonstrate how to use functions in Python, we will use Thonny, a free, easy to use and cross platform Python editor. 

Before you start, Install Thonny if you don’t have it already. You can download the release for your system on the app’s official site.

Alternatively, you can install the official Python release using this guide. Note that this guide covers installation on Windows 10 and 11.

How to Create a Function in Python

Functions are “defined” using the “def” keyword. When the function name is called, the contents of the function are run and the output is sent to the Python Shell.

1. Create a function called hello. As is tradition in programming, we will use “Hello World” as a quick and simple demonstration of using a function.

def hello():

2. Add a for loop that will iterate (loop) ten times. For loops are an easy way to repeat actions in any programming language. Here we are using a range to set the number of loops, but for loops can also iterate through objects in lists, dictionaries or tuples.

   for i in range(10):

3. Use print to output “Hello World!” to the Python Shell. Print is a built-in function for Python. Its role is to print objects. The message that we want to print is called an “argument” or “parameter” and we will cover this later in the how to.

   print("Hello World!")

4. Save the code as hello_world.py and click Run >> Run Current Script, or press the green run button. What happens? Here is where we make a mistake to reinforce how functions work. Our function has been created, but we have not called the function, so Python is waiting for a command.

5. On a new line, not inside the for loop or function, call the function by its name. Remember to include the parenthesis at the end of the function name.

hello()

6. Click Run >> Run Current Script, or press the green run button. The Python Shell will see “Hello World!” printed ten times.

Complete Code Listing: A Simple Function

def hello():    for i in range(10):        print("Hello World!")hello()

How to Create a Function With Arguments

Arguments, sometimes called parameters, are extra instructions to an object. Python’s functions can use arguments, we just need to add them into the parentheses. By default, Python will not look for an argument in a function, we need to set a template / expectation for the function. 

In this section we will alter our “Hello World!” function to accept two arguments. The first is for the number of iterations in a for loop, the second will be for the phrase that we wish to repeat. When specifying arguments we need to ensure that we pass the correct number. If the function specifies two arguments, then we need to pass it two. Failure to do this will cause the function call to error.

1. Create a function called hello and pass it two arguments, x and phrase. We use x as a placeholder for the number of loops, “phrase” is used to represent the message that we want to print.

def hello(x, phrase):

2. Add a for loop that will iterate x times. The number of times that the loop will iterate is controlled using the x argument.

   for i in range(x):

3. Use print to output the “phrase” argument to the Python Shell. Remember, the phrase is set when we call the function.

    print(phrase)

4. On a new line, not inside the for loop or function, call the function by its name and pass the two arguments. The number of times to loop (x) and the message to print. We’ve chosen to loop five times and print Tom’s Hardware. It's not original, but it illustrates the goal of the project.

hello(5, "Tom's Hardware")

5. Save the code as hello_world.py and click Run >> Run Current Script, or press the green run button. The phrase will be printed to the Python Shell for the X number of times that you specified as an argument. 

Complete Code Listing: Functions With Arguments 

def hello(x, phrase):    for i in range(x):        print(phrase)hello(5, "Tom's Hardware")

How To Create a Function With Default and Keyword Arguments

We’ve passed arguments to our functions, but we can also set a default argument. The default will be accepted and used if the function is passed without a user set argument. Here is a quick example which has a default argument of name. The default name is my own, and it is used in the function to greet the user. All we need to do is pass the name argument to create a new named greeting.

1. Create a function with a default argument of name. Obviously change the name to your choosing.

def whoareyou(name = "Les"):

2. Using the name argument, print a greeting to the user. Here we use Python’s string format method to insert the name argument as a string.

   print("Hello {:s}!".format(name))

3. Call the function with no argument. This should show that the default name is used.

whoareyou()

4. Call the function and pass a new name as an argument. Calling the function happens outside of the function itself.

whoareyou("Dave")

5. Save the code as name.py and click Run >> Run Current Script, or press the green run button. We can see that the code outputs two greetings. One for the default, the other for “Dave”.

Complete Code Listing: Functions With Default Argument

def whoareyou(name = "Les"):    print("Hello {:s}!".format(name))whoareyou()whoareyou("Dave")

Keyword arguments are useful when we have multiple arguments to pass. In this example we use the classic Mad Libs structure to create a sentence with a noun, verb and thing. The order of the arguments doesn’t matter as we provide the key = value structure.

1. Create a function and configure it to accept three arguments.

def madlibs(noun, verb, thing):

2. Create a sentence that will print the noun, verb and thing to the Python shell. Again we use Python’s excellent string format method to drop the arguments into the sentence.

   print("The {:s} {:s} over the {:s}.".format(noun, verb, thing))

3. Save the code as madlibs.py and click Run >> Run Current Script, or press the green run button.

4. In the Python Shell, call the function and pass the three arguments. Remember to use the key, otherwise the order will be incorrect. Press Enter to run the code. You will see the sentence appear using your custom keywords.

madlibs(noun = "rabbit",verb = "jumped",thing ="gate")

Complete Code Listing: Functions With Multiple Arguments

def madlibs(noun, verb, thing):   print("The {:s} {:s} over the {:s}.".format(noun, verb, thing))

Using Functions to Get PC Performance Data

To illustrate how to use functions we are going to create a quick Python project that will get live CPU and RAM data using the psutil (process and system utilities) Python module.This module can get data on CPUs, RAM, disks, networks and other sensors, all using Python.

Before we can write any code, we need to install the psutil module.

1. In Thonny, click on Tools >> Manage Packages.

2. Search for psutil and click Search on PyPi.

3. Select psutil from the returned results.

4. Install psutil then close the dialog box when it is complete. We have already installed psutil so our dialog looks a little different.

5. Create a new file in Thonny and import the psutil module.

import psutil

6. Create a function, cpu(). This function will get the current CPU utilization and store it in a variable. We then print the value to the Python Shell using a string format.

def cpu():   cpu = str(psutil.cpu_percent())   print("Current CPU usage is {:s}%".format(cpu))

7. Create a new function, ram(). Use a print statement, along with some math to print a title with ten * either side.This function will handle all of the steps necessary to get the current amount of available memory.

def ram():   print("*"*10,"RAM Stats","*"*10)

8. Get the current memory stats and store them in a variable called “memory”.

   memory = psutil.virtual_memory()

9. Extract the current amount of available RAM and store it in the variable. The memory object initially returns the total, available, percent, used and free memory. The returned object is a list, and we need the second value in the list, which is [1].

   memory = memory[1]

10. Convert the amount of memory into Megabytes and round the value for ease of reading.

   memory = round(memory / 1024 / 1024)

11. Print the amount of available memory to the Python Shell.

   print("There is {:n}MB of available RAM".format(memory))

12. Create a function called cores(). This function will return the physical core count and the number of threads our CPU has.

def cores():

13. Create objects to store the physical number of CPU cores, and the number of threads. Setting the logical=False argument will force psutil to only return the physical cores.

   physical = psutil.cpu_count(logical=False)   threads = psutil.cpu_count()

14. Print the physical core count and thread to the Python Shell.

   print("This CPU has {:n} cores and {:n} threads".format(physical, threads))

15. Create a new function, cpuspeed(). Use a print statement, along with some math to print a title with ten * either side.

def cpuspeed():   print("*"*10,"CPU Stats","*"*10)

16. Store the current CPU speed data to an object called speed. Then extract the current speed and update the object. Initially we get a list which contains a tuple with three values, current speed, min, and max speed. So we need to get data from the first entry in the list [0], then get the first entry in the tuple [0].

   speed = (speed[0][0])

17. Print the speed to the Python Shell.

   print("The CPU speed is {:n} MHz".format(speed))

18. Create a function called all() and use it to call all of the previous functions. Functions can call other functions.

def all():   cpuspeed()   cores()   cpu()   ram()

19. Create a try / except handler and use while True: to run our code. This section will try to run our code.

try:   while True:

20. Create an object, stat, and use it to store the user’s choice. We use an input() function to capture keyboard input from the user. We can also create a prompt asking the user for their choice.

       stat = input("Please type 'cpu', 'ram', 'cores', 'cpuspeed' or press ENTER to show all stats: ")

21. Use conditional tests to check the value stored in stat and route the code to the correct option.

       if stat == "cpu":           cpu()       elif stat == "ram":           ram()       elif stat == "cores":           cores()       elif stat == "cpuspeed":           cpuspeed()

22. Use else as a catch all option that will call the all() function and show every stat that we have a function for.

       else:           all()

23. Create an exception to handle the user pressing CTRL+C to end the code. This will print Exiting to the Python Shell.

except KeyboardInterrupt:   print("Exiting")

24. Save the code as performance.py  and click Run >> Run Current Script, or press the green run button. You will see the Python Shell ask for your input. Follow the guidance and your requested data will display in the Shell.

Complete Code Listing: Using Functions to Get PC Performance Data

import psutildef cpu():   cpu = str(psutil.cpu_percent())   print("Current CPU usage is {:s}%".format(cpu))def ram():   print("*"*10,"RAM Stats","*"*10)   memory = psutil.virtual_memory()   memory = memory[1]   memory = round(memory / 1024 / 1024)   print("There is {:n}MB of available RAM".format(memory))def cores():   physical = psutil.cpu_count(logical=False)   threads = psutil.cpu_count()   print("This CPU has {:n} cores and {:n} threads".format(physical, threads))def cpuspeed():   print("*"*10,"CPU Stats","*"*10)   speed = psutil.cpu_freq([1])   speed = (speed[0][0])   print("The CPU speed is {:n} MHz".format(speed))def all():   cpuspeed()   cores()   cpu()   ram()try:   while True:       stat = input("Please type 'cpu', 'ram', 'cores', 'cpuspeed' or press ENTER to show all stats: ")       if stat == "cpu":           cpu()       elif stat == "ram":           ram()       elif stat == "cores":           cores()       elif stat == "cpuspeed":           cpuspeed()       else:           all()except KeyboardInterrupt:   print("Exiting")

More Python Tutorials

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

Microsoft’s Stefan Kinnestrand announced today that Microsoft Excel will officially support Python integration. This will be accomplished via a partnership with Anaconda which brings a huge repository with common libraries like statsmodels, Matplotlib and pandas. The new Python integration is available starting today as a preview for those in the Beta Channel Microsoft 365 Insiders group.

The integration will become a part of the many tools offered in Excel’s repertoire. As such, you won’t have to take any additional steps to add Python to your copy of Excel. More specifically, this integration will be implemented as a part of Excel’s data transformation tool known as Power Query.

If you want to get in on the early action, you’ll need to be a part of the Beta Channel Insider group in the Microsoft 365 Insider Program. The preview will be automatically included in the latest Insider build. Just install the latest copy of Excel offered and open a new workbook. In the ribbon go to ‘Formulas’ then ‘Insert Python’. There you should have an option to try the preview.

Anaconda has more details about their work on the project over at their official website. We definitely recommend checking it out for an inside look at what the new Python support is capable of. They also offer training courses which can help you get off the ground with the new addition.

The preview will only be available for a limited time so now is your chance to check it out and see what it’s like hands-on. The preview will also be extended to Microsoft 365 subscribers. Once the preview expires, it will still be available but with limited functionality. To restore full access, users will need to purchase a license.

If you want to get a closer look at the details of the new rollout, we recommend both reading through the official announcement shared by Microsoft as well as the official documentation from Anaconda.

In Python, dictionaries are data storage objects that use a key to retrieve a value. Think of your cell phone contact list or phone book. We look for the name of the person, the key, and their phone number is the value. Dictionaries are incredibly useful when storing and sorting data. We used a dictionary in our for loop project which saw RSS news feeds used to generate content on a web page. 

We’re going to go through how to create, update and delete keys and values inside of a dictionary and then use a dictionary in a real world project where we create a notification system using Python and nfty.sh.

To demonstrate how to use Dictionaries in Python, we will use Thonny, a free, easy to use and cross platform Python editor.

1. In a browser go to the Thonny website and download the release for your system.

2. Alternatively, install the official Python release using this guide. Note that this guide covers installation on Windows 10 and 11.

How To Create a Dictionary in Python

The most basic use for a dictionary is to store data, in this example we will create a dictionary called “registry” and in it store the names (keys) and starship registries / numbers (values) of characters from Star Trek.

1. Create a blank dictionary called “registry”. Dictionaries can be created with data already inside, but by creating a blank dictionary we have a “blank canvas” to start from.

registry = {}

2. Add a name and ship number to the registry. Remember that the name is a key, and the ship number is the value. Values can be strings, integers, floats, tuples, and lists.

registry["James T Kirk"] = 1701

3. Add another few names to the registry.

registry["Hikaru Sulu"] = 2000registry["Kathryn Janeway"] = 74656registry["Ben Sisko"] = 74205

4. Print the contents of the registry dictionary.

print(registry)

5. Save the code as starfleet-registry.py and click Run to start the code.

Complete Code Listing: Creating a Dictionary

registry = {}registry["James T Kirk"] = 1701registry["Hikaru Sulu"] = 2000registry["Kathryn Janeway"] = 74656registry["Ben Sisko"] = 74205print(registry)

Updating and Deleting Entries in a Dictionary.

Dictionaries are updatable (mutable in programming parlance) and that means we can update the key (names) and the values (ship numbers).

For our first scenario, we’ve had a call from Ben Sisko, and he wants his entry updated to Benjamin. We’re going to add this code to the previous example code.

1. Add a print statement to show that we are making updates. This is entirely optional, but for the purpose of this example it clarifies that we are updating the dictionary.

print(“UPDATES”)

2. Add a “Benjamin Sisko” key and set it to use the value stored under “Ben Sisko”.

registry["Benjamin Sisko"] = registry["Ben Sisko"]

3. Delete “Ben Sisko” from the registry.

del registry["Ben Sisko"]

4. Print the current contents of the registry. We can see that the “Ben Sisko” key is now gone, and is replaced with “Benjamin Sisko”. The value has also been transferred.

print(registry)

Next we will update the entry for James T Kirk. It seems that he has a new ship number (something to do with “accidentally” setting an easy password on his self-destruct app) and so we need to update the value for his entry.

1. Add a print statement to show that we are making updates. This is entirely optional, but for the purpose of this example it clarifies that we are updating the dictionary.

print("Kirk's new number")

2. Update the “James T Kirk” key with the new ship number. Note that because we are adding -A to the value, we have to wrap the value in “ “ to denote that we are now using a string.

registry["James T Kirk"] = "1701-A"

3. Print the contents of the registry. We can now see that James T Kirk has a new ship number.

Finally we need to delete Benjamin Sisko from the registry. It seems that he has gone “missing” while in the fire caves on Bajor. So we need to delete his entry from the registry. We’ll use the existing code, and add three new lines.

1. Add a print statement to show that we are deleting entries. This is entirely optional, but for the purpose of this example it clarifies that we are deleting entries from the dictionary.

print("Deleting Benjamin Sisko")

2. Delete “Benjamin Sisko” from the registry. We don’t know who the new captain will be yet.

del registry["Benjamin Sisko"]

3. Print the registry to confirm the deletion.

print(registry)

4. Save and run the code.

Complete Code Listing: Updating and Deleting a Dictionary

registry = {}registry["James T Kirk"] = 1701registry["Hikaru Sulu"] = 2000registry["Kathryn Janeway"] = 74656registry["Ben Sisko"] = 74205print(registry)print("UPDATES")registry["Benjamin Sisko"] = registry["Ben Sisko"]del registry["Ben Sisko"]print(registry)print("Kirk's new ship")registry["James T Kirk"] = "1701-A"print(registry)print("Deleting Benjamin Sisko")del registry["Benjamin Sisko"]print(registry)

Using a For Loop With Dictionaries

For loops are awesome. We can use them to iterate through an object, retrieving data as it goes. Lets use one with our existing code example to iterate through the names (keys) and print the name and ship number for each captain.

1. Create a for loop to iterate through the keys and values in the registry dictionary. This loop will iterate through all the items in the dictionary, saving the current key and value each time the loop iterates.

for keys, values in registry.items():

2. Create a sentence that embeds the Captain’s name (keys) and the ship’s number / registry (values).

print("Captain", keys, "registry is", values)

3. Save the code and click Run. You will see the name and ship number for each captain printed at the bottom of the Python shell.

Complete Code Listing: Using a For Loop With Dictionaries

registry = {}registry["James T Kirk"] = 1701registry["Hikaru Sulu"] = 2000registry["Kathryn Janeway"] = 74656registry["Ben Sisko"] = 74205print(registry)print("UPDATES")registry["Benjamin Sisko"] = registry["Ben Sisko"]del registry["Ben Sisko"]print(registry)print("Kirk's new ship")registry["James T Kirk"] = "1701-A"print(registry)print("Deleting Benjamin Sisko")del registry["Benjamin Sisko"]print(registry)for keys, values in registry.items():   print("Captain", keys, "registry is", values)

Using Dictionaries in a Real World Project

We’ve learnt the basics, now lets use a dictionary in a real world project. We’re going to use ntfy.sh, a service to send notifications to Android and iOS devices. The Python API for ntfy.sh is based on dictionaries. Best of all, there are no Python installation files as it uses Python’s requests module to handle sending messages to ntfy.sh.

1. Install ntfy.sh for your Android / iOS device.

2. Open the app and click on + to create a new subscription.

3. Create a new topic and click Subscribe. We chose to use th-test. Create a topic that is personal to you. Also note that topics may not be password protected, so do not send sensitive data.

4. Leave the app open on your device. 

Now our attention turns to our PC running Thonny.

5. Create a blank file.

6. Import the requests module. This is a module of pre-written Python code designed for sending and receiving network connections.

import requests

7. Use requests to post a message to ntfy. Note that we need to specify the topic name, in our case https://ntfy.sh/th-test, as part of the function’s argument. The next argument, data is the text that the user will see. But our interest is in “headers” as this is a dictionary which can contain multiple entries. Right now it contains a title for the notification.

requests.post("https://ntfy.sh/th-test",   data="This is a test of ntfy for Tom's Hardware",   headers={ "Title": "Python Dictionaries are useful" })

8. Save the code as dictionary-ntfy.py and click Run. This will send the message to ntfy’s servers and from there the notification will appear on your device.

Complete Code Listing: Real World Project

import requestsrequests.post("https://ntfy.sh/th-test",   data="This is a test of ntfy for Tom's Hardware",   headers={ "Title": "Python Dictionaries are useful" })

An Advanced Real World Dictionary Project

Lets create a more advanced project, one that uses a dictionary to store multiple items. We’re going to reuse the code from before, but tweak it to meet our needs.

1. Our import and requests line remain the same.

import requestsrequests.post("https://ntfy.sh/th-test",

2. Open and read a file into memory. This is the data that is sent in the notification. In this case we start with an image that is in the same directory as our code. If the image is in a different location on your machine, specify the full path to the file.

   data=open("yoga.jpg", 'rb'),

3. Create a dictionary called “headers”. This forms the information that is sent in the notification.

   headers={

4. Inside the headers dictionary, specify the following keys and values.

Priority 5 messages are urgent, the highest priority and they will set your phone to vibrate / ring continuously until they are answered.

Tags: These are emojis and tags used to add icons and extra data to a notification. If the tag has an emoji, then you will see it.

Title: The top title, in bold for the notification.

Click: When you click on the notification, it will open the web page.

Filename: The name of the file that is being sent.

       "Priority": "5",       "Tags": "rotating_light",       "Title": "Let me in, it is cold!!",       "Click": "https://www.tomshardware.com/reviews/elecfreaks-cm4-xgo",       "Filename": "yoga.jpg"   })

5. Save the code and click Run. Now look at your device and you will see a notification showing our custom message.

Complete Code Listing: Advanced Project

import requestsrequests.post("https://ntfy.sh/th-test",   data=open("yoga.jpg", 'rb'),   headers={       "Priority": "5",       "Tags": "rotating_light",       "Title": "Let me in, it is cold!!",       "Click": "https://www.tomshardware.com/reviews/elecfreaks-cm4-xgo",       "Filename": "yoga.jpg"   })

More Python Tutorials

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

Once you’ve created a list or collection in Python, it might be useful to have each item numbered. Instead of going through the list manually and adding numerals one by one, it can be well worth looking into the enumerate function. This is a built-in tool that will go through a list and automatically number them in the order they were added to the tuple or list.

In this guide, we’ll go over how to use this enumerate function with an existing list. We’ll assume you already have familiarity with how to create a variable, list, and use functions. Once the list has been enumerated, it can be called later with the enumeration in place. You can even use a for loop (see how to use for loops in Python) to iterate through the enumeration.

What is Enumeration in Python?

Enumeration is the ordered listing of all items in a collection. In Python we can use this with a list or tuple to (data collection objects) into an enumerate object. The enumerate object has a name and value for each enum member within the object. The enumerate object can be updated (mutable) unlike other objects such as tuples which are immutable (cannot be updated).

How to Enumerate in Python

To demonstrate how to use enumeration in Python, we’ll start with a list of flavors and label it ‘flavors’. After applying the enumeration function, we’ll print the list which will show that each item has been marked with a numeral sequentially.

1. Create a list, collection or tuple. In this case we have three flavors in a list labeled as a variable named ‘flavors’.

flavors = ('Raspberry', 'Vanilla', 'Chocolate')

2. Run the enumerate function. In the example code below, we’ve created a variable named ‘choices’ that consists of the enumerate function parsing the ’flavors' object, as an argument.

flavors = ('Raspberry', 'Vanilla', 'Chocolate')choices = enumerate(flavors)

3. Print the list. You can now call the 'flavors' object as needed in your code. For the sake of our example, we’ll print the list to show what it looks like when the list has been enumerated.

flavors = ('Raspberry', 'Vanilla', 'Chocolate')choices = enumerate(flavors)print(list(choices))

4. Confirm the results. The printed list should appear as follows if the enumeration was successful.

[(0, 'Raspberry'), (1, 'Vanilla'), (2, 'Chocolate')]

Even though we’ve printed the list to show the enumerate function, this is just to demonstrate how it works. You can apply it in your code as needed after the second step but printing the list is a quick way to make sure it’s working as intended.

We earlier mentioned that enumerated collections have a value and name associated to the data stored within. We can individually extract these values. Here is a quick example that creates an enumerated collection of foods.

1. Import the enum module. 

import enum

2. Create a new enumeration object using a function-call syntax. Our object is called food, and in there we store a list of foods. By using the enum.Enum function call we bind  values to each of the item names.

food = enum.Enum('food', ['Tomato', 'Cucumber', 'Chocolate'])

3. Use a for loop to print the value and name of each item in the object. The for loop will iterate over every item in the object. We then print the value and name of the item.

for item in food:    print(item.value, item.name)

4. Run the code. The output will be the enumerated value of the item's position and the name of the item.

1 Tomato2 Cucumber3 Chocolate

Using Enumeration to Number Chapters in a Book

There are plenty of practical applications for applying numbers to a list. In this example, we'll number the chapters in a book we're pretending to write. This example also shows how you can start a list from any number so it doesn't begin with the default value of 0.

I'll be using Thonny for this example. It's a free Python editor that works on several platforms. You can find it available for download on the official Thonny website. However, you can use any editor you like for your project.

1. Make your list. In this case, my list is a handful of fake chapters for our book.

chapters = ["How to Enumerate in Python", "Creating a List", "Enumerating the List"]

2. Set the beginning of the list to 1 instead of 0. The next line tells Python that we want the chapter enumeration to begin at 1. The words 'chapter' and 'title' can be anything you like.

chapters = ["How to Enumerate in Python", "Creating a List", "Enumerating the List"]for chapter, title in enumerate (chapters,1):

3. Print the list. The third line prints the chapter variable which has the title argument setting the list to begin at 1.

chapters = ["How to Enumerate in Python", "Creating a List", "Enumerating the List"]for chapter, title in enumerate (chapters,1):print(chapter, title)

4. Run the program. It should print the chapters with the enumeration beginning at 1.

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

In programming, for loops are incredibly versatile tools to repeat a section of code. For loops can loop for a set number of times using a range, they can have clauses / conditions which will end the loop and we can use them to iterate over items in a dictionary, list or tuple.

In this how to, we will show you how to get started with for loops using Python, the same syntax will also work with MicroPython and CircuitPython on boards such as the Raspberry Pi Pico.

To demonstrate how to use for loops in Python, we will use Thonny, a free, easy to use and cross platform Python editor. 

1. In a browser go to the Thonny website and download the release for your system.

2. Alternatively, install the official Python release using this guide. Note that this guide covers installation on Windows 10 and 11.

Using a Range with Python For Loops

The most basic for loop use in Python is to iterate over a range, essentially creating a loop that will only iterate for a set number of times. While “range” is not strictly part of the syntax for a for loop, it is really a built-in Python function that returns a sequence for a specific pattern, it is the easiest way to demonstrate how a for loop works.

1. Create a for loop and set the range to 10.This will set the value of x to an integer value, starting at 0 and ending at 9. The loop will iterate until it reaches the tenth loop, then it will end.

for i in range(10):

2. Print the current value of i as part of a sentence. Here we use Python’s string format method to insert the loop number each time the loop iterates.

   print("This is loop: {:n}".format(i))

3. Save the code as for_loop_range.py and click Run to start. You should see this output.

This is loop: 0This is loop: 1This is loop: 2This is loop: 3This is loop: 4This is loop: 5This is loop: 6This is loop: 7This is loop: 8This is loop: 9

Complete Code Listing: For Loop With a Range

for i in range(10):    print("This is loop: {:d}".format(i))

Using a For Loop With RSS Feeds

To better illustrate how we can use a for loop, let's use a for loop with a range to pull the top five headlines from BBC News’ RSS feed along with their corresponding URL.

1. Install feedparser using pip at a command prompt. Feedparser is an RSS parsing tool that we shall use to read the RSS feed and convert it into a Python dictionary.

pip install feedparser

2. In Thonny, create a new blank Python file and import feedparser.

import feedparser

3. Create an object, newsfeed, and in there store the parsed BBC News feed.

newsfeed = feedparser.parse("http://feeds.bbci.co.uk/news/rss.xml")

4. Use a for loop with a range of five.

for i in range(5):

5. Print the headlines (title) and the URL (link) of the top five stories. Here we are accessing the newsfeed object, which is a dictionary (array) that contains many more dictionaries and lists. Using the keys (entries, title and link) we can get the values that they store. The value of [i] increments, until it reaches 5, then the loop ends. We have how tos covering dictionaries and lists which go into further detail.

   print(newsfeed['entries'][i]['title'])   print(newsfeed['entries'][i]['link'])

6. Save the code as news_for_loop.py and click Run. You should see the top five news headlines.

Complete Code Listing: Using a For Loop With RSS Feeds  

import feedparsernewsfeed = feedparser.parse("http://feeds.bbci.co.uk/news/rss.xml")for i in range(5):    print(newsfeed['entries'][i]['title'])    print(newsfeed['entries'][i]['link'])

For Loops With an Early Exit

Ranges can also feature an “early exit”. This uses a conditional statement that checks the value of the of the loop (in our case it is stored in i) and if it matches the value, the code breaks and exits.

We’re going to reuse the code from the first example to start us off.

1. Add a conditional test that checks the value of i is the same as 4. In Python == is an operator that checks that one value is the same as another.

   if i == 4:

2. Print a sentence to inform the user that the loop is terminating. This part of the code will only activate once “i” contains the value 4.

       print("This loop sequence terminates at loop {:n}".format(i))

3. Break the loop, forcing the code to stop.

       break

4. Save and run the code. You should see this output.

This is loop: 0This is loop: 1This is loop: 2This is loop: 3This is loop: 4This loop sequence terminates at loop 4

Complete Code Listing: For Loop With an Early Exit

for i in range(10):    print("This is loop: {:n}".format(i))    if i == 4:        print("This loop sequence terminates at loop {:n}".format(i))        break

Nested For Loops

We can have multiple for loops running together. For example we can nest one for loop inside of another. In this example we are reusing the code from the first example.

for i in range(10):   print("This is loop: {:n}".format(i))

1. Add a nested for loop that will iterate ten times. Ensure that the variable name is different to the main loop, otherwise the two will clash.

   for j in range(10):

2. Add a print statement to inform the user that this is the nested for loop.

       print("This is nested loop: {:n}".format(i))

3. Use a break to exit out of the nested for loop. If we don’t do this, then the nested for loop will repeat each time the main loop iterates.

       break

4. Save and run the code. You should see this output.

This is loop: 0This is nested loop: 0This is loop: 1This is nested loop: 1This is loop: 2This is nested loop: 2This is loop: 3This is nested loop: 3This is loop: 4This is nested loop: 4This is loop: 5This is nested loop: 5This is loop: 6This is nested loop: 6This is loop: 7This is nested loop: 7This is loop: 8This is nested loop: 8This is loop: 9This is nested loop: 9

Complete Code Listing: Nested For Loops

for i in range(10):   print("This is loop: {:n}".format(i))   for j in range(10):       print("This is nested loop: {:n}".format(i))       break

Iterating With For Loops

Iterating over objects in a list, dictionary or tuple is useful if we want to use data from these objects. In this example, we will reuse the code from our RSS feed reader to create a simple web app. A ranged for loop will grab the news headlines from the object, then split the headlines and their URLs apart and then store them inside of a Python dictionary object. Then we will use the dictionary as a source to generate an HTML page in a browser.

1. Install PyWebIO using pip at the command prompt,. PyWebIO is a means to create inputs and outputs around a browser session.

pip install pywebio

2. In Thonny, create a new blank Python file and import feedparser and import three PyWebIO classes. PyWebIO has many different classes and functions, but we are interested in creating a server, outputting information to a browser and controlling the session.

import feedparserfrom pywebio import start_serverfrom pywebio.output import *    from pywebio.session import *

3. Create an object, newsfeed, and in there store the parsed BBC News feed. This can be any RSS feed that you choose.

newsfeed = feedparser.parse("http://feeds.bbci.co.uk/news/rss.xml")

4. Create an empty dictionary called news_stories. Dictionaries are Python objects that store data using a key, value system. By calling a dictionary and referencing a key, we can get the value attached to it.

news_stories = {}

5. Using a for loop with a range, grab the first five news stories and store them inside the news_stories dictionary. The title (headline) will be the key, and the URL will be the value.

for i in range(5):   news_stories.update({newsfeed['entries'][i]['title']:newsfeed['entries'][i]['link']})

6. Create a function called main. This function will handle creating the web content to be served.

def main():

7. Set the page title. This is seen in the tab / title bar of the web browser.

   set_env(title='Python For Loops RSS Example')

8. Use a for loop to iterate over every key (k) and value (v) stored in the news_stories dictionary. The for loop will end once it has retrieved all of the keys and values, it does not need a range.

   for k,v in news_stories.items():

9. Place the headline text on the page. PyWebIO’s put_text function places raw text on a web page, and we pass the function the key value, which is the headline.

       put_text(k)

10. Place the URL underneath the headline. Using put_link we generate an HTML hyperlink with the text “Click here”. The URL is created from the value stored in v.

       put_link('Click here',v)

11. Outside of the for loop and the function, start the server. Call the main function and set the port to 8080, and debug to True. It is advisable to set the port to an unused value and typically 8080 is valid. If necessary change this to another value. Setting debug to True is useful as it provides output in the Python shell, and in the browser session.

start_server(main, port=8080, debug=True)

12. Save the code as for_loop_news_dict.py and click Run. The Python shell will display the URL of the generated page.

13. Click on the URL to open in your default browser. The URL can also be viewed from another device on the network.

Complete Code Listing: Iterating With For Loops

import feedparserimport timefrom pywebio import start_serverfrom pywebio.output import *    from pywebio.session import *newsfeed = feedparser.parse("http://feeds.bbci.co.uk/news/rss.xml")news_stories = {}for i in range(5):   news_stories.update({newsfeed['entries'][i]['title']:newsfeed['entries'][i]['link']})def main():   set_env(title='Python For Loops RSS Example')   for k,v in news_stories.items():       put_text(k)       put_link('Click here',v)start_server(main, port=8080, debug=True)

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

Most users will download files onto their PC using their web browser. There’s a problem with this method, however—it’s not particularly efficient. If you need to pause your download, or if you’ve lost your connection, you’ll probably need to start your download again from scratch. You may also be working with Python or other code at the command line and want to download directly from the command prompt. 

That’s where tools like Wget come in. This command line tool has a number of useful features, with support for recursive downloads and download resumption that allows you to download single files (or entire websites) in one go.

Wget is popular on Linux and other Unix-based operating systems, but it’s also available for Windows users. Below, we’ll explain how to install and use Wget to download any content you want online from your Windows command line.

Installing GNU Wget on Windows

Wget (in name, at least) is available on Windows 10 and 11 via the PowerShell terminal. However, this version of Wget isn’t the same as the GNU Wget tool that you’d use on a Linux PC. Instead, this version is simply an alias for a PowerShell command called Invoke-WebRequest.

Invoke-WebRequest is Wget-like in what it does, but it’s a completely different tool that’s much more difficult to use and understand. Instead, you’ll be better served by installing Wget for Windows, a compiled version of the same tool available for Linux users, using the steps below.

1. Download the Wget for Windows setup file from the Wget website. You’ll need to do this using your web browser.

2. Run the Wget for Windows installer file. Once the Wget setup file has finished downloading, run the setup file and follow the on-screen instructions to complete the installation.

3. Update the Wget.exe file (optional). The Wget installer is packaged with a fairly old version of the Wget binary. If you run into difficulties downloading files because of SSL certificate errors, you should download the latest wget.exe for your architecture from this website and save it to your Wget installation directory (typically C:\Program Files (x86)\GnuWin32\bin). This step is optional, but highly recommended.

4. Open the Start menu, search for environment variables, and click Open. Once the installation is finished, use the search tool in the Start menu to search for environment variables, then click Open. You’ll need to do this to allow you to use the ‘wget’ command from the command line without referencing its location every time you wish to run it.

5. Click Environment Variables in the System Properties window.

6. Select Path and click Edit under System or User variables.

7. Click the New button and type in the directory for the Wget for Windows binary (.exe) file. By default, this should be C:\Program Files (x86)\GnuWin32\bin.

8. Save your changes. When you’re finished, click OK in each menu and exit System Properties.

9. Open the Start menu, type cmd, and press Open. This will launch a new command prompt window.  You can also use the newer Terminal app, as long as you switch to using a command prompt shell.

10. Type wget --version and press Enter. If Wget was installed correctly, you should see the GNU Wget version returned in the command prompt window.

If you want to run Wget from a PowerShell terminal instead, you’ll need to run the file from its installation directory directly (eg. C:\Program Files (x86)\GnuWin32\bin\wget.exe).

Downloading Files with Wget

Once you’ve installed GNU Wget and you’ve configured the environment variables to be able to launch it correctly, you’ll be able to use it to start downloading files and webpages.

We’ve used an example domain and file path in our examples below. You’ll need to replace this with the correct path to the file (or files) that you want to download.

• Type wget -h to see a full list of commands. This will give you the full list of options that you can use with Wget.
  wget -h
  

• Download a single file using wget . Replace with the path to a file on an HTTP, HTTPS, or FTP server. You can also refer to a website domain name or web page directly to download that specific page (without any of its other content).
  wget example.com
  

• Save with a different filename using -O. Using the -O option, you’ll be able to save the file with a different filename. For example, wget -O , where is the filename you’ve chosen.
  wget -O example.html example.com
  

• Save to a different directory using -P. If you want to save to another directory than the one you’re currently in, use the -P option. For example, wget -P .
  wget -P C:\folder example.com
  

• Use --continue or -c to resume files. If you want to resume a partial download, use the -c option to resume it, as long as you’re in the same directory. For example, wget -c .
  wget -c example.com
  

• Download multiple files in sequence. If you want to download several files, add each URL to your Wget command. For example, wget etc.
  wget example.com tomshardware.com
  

• Download multiple files using a text file with -i. Using the -i option, you can refer to a text file that contains a list of URLs to download a large number of files. Assuming that each URL is on a new line, Wget will download the content from each URL in sequence. For example, wget -i .
  wget -i urls.txt
  

• Limit download speeds using --limit-rate. If you want to limit your bandwidth usage, you can cap the download speeds using the --limit-rate option. For example, wget --limit-rate=1M would limit it to 1 megabyte per second download speeds, while wget --limit-rate=10K would limit it to 10 kilobytes per second.
  wget --limit-rate=10K example.com
  

• Use -w or –wait to set a pause period after each download. If you’re downloading multiple files, using -w can help to spread the requests you make and help to limit any chance that your downloads are blocked. For example, wget -w 10 for a 10 second wait. 

wget -w 10 example.com tomshardware.com

• Set a retry limit using -t or --tries. If a download fails, wget will use the -t value to determine how many times it’ll attempt it again before it stops. The default value is 20 retries. If the file is missing, or if the connection is refused, then this value is ignored and Wget will terminate immediately.
  wget -t 5 example.com

• Save a log using -o or -a. You can save your log data to a text file using -o (to always create a new log file) or -a (to append to an existing file). For example, wget -o .

•  Bypass SSL errors using --no-check-certificate. If you’re having trouble downloading from a web server with an SSL certificate and you’ve already updated your Wget installation, bypass the SSL certificate check completely using --no-check-certificate to allow the download (in most cases). You should only do this for downloads from locations that you completely trust. For example, wget --no-check-certificate example.com. 

wget --no-check-certificate https://example.com

Make sure to use the wget -h or wget --help command to view the full list of options that are available to you. If you run into trouble with Wget, make sure to limit the number of retries you make and set a wait limit for each download you attempt.

Using Wget for Recursive Downloads

One of Wget’s most useful features is the ability to download recursively. Instead of only downloading a single file, it’ll instead try to download an entire directory of related files.

For instance, if you specify a web page, it’ll download the content attached to that page (such as images). Depending on the recursive depth you choose, it can also download any pages that are linked to it, as well as the content on those pages, any pages that are linked on those pages, and so on.

Theoretically, Wget can run with an infinite depth level, meaning it’ll never stop trying to go further and deeper with the content it downloads. However, from a practical point of view, you may find that most web servers will block this level of scraping, so you’ll need to tread carefully.

• Type wget -r or wget --recursive to download recursively. By default, the depth level is five. For example, wget -r .
  wget -r tomshardware.com

• Use -l or –level to set a custom depth level. For example, wget -r -l 10 . Use wget -r -l inf for an infinite depth level.
  wget -r -l 10 tomshardware.com

• Use -k to convert links to local file URLs. If you’re scraping a website, Wget will automatically convert any links in HTML to point instead to the offline copy that you’ve downloaded. For example, wget -r -k .
  wget -r -k tomshardware.com

• Use -p or --page-requisites to download all page content. If you want a website to fully download so that all of the images, CSS, and other page content is available offline, use the -p or --page-requisites options. For example, wget -r -p .
  wget -r -p tomshardware.com

For a full list of options, make sure to use the wget --h command. You should also take care to respect any website that you’re actively downloading from and do your best to limit server loads using wait, retry, and depth limits.

If you run into difficulties with downloads because of SSL certificate errors, don’t forget to update your Wget binary file (wget.exe) with the latest version.

Originally created by Guido van Rossum in 1991, Python is a versatile programming language used by makers on the Raspberry Pi, system administrators in the data center, Industrial Light and Magic to bring our movies to life and behind the scenes at NASA.

Python is a great language to learn, and thanks to the Raspberry Pi for the past thirteen years there have been countless tutorials covering the gamut of programming projects.

Whether you are a Python veteran, a “pythonista” or a complete newcomer to the language, installing Python on Windows is an easy task. In this how to we will walk you through installing Python 3 on Windows (including how to install via the Microsoft Store) and show two editors, one for beginners and the other for intermediate and advanced users, and how you can get coding with this fantastic language.

Installing Python 3 on Windows 10 and 11

The installation process for Python 3 on Windows is simple, with only a couple of extra steps that we have to follow. These steps enable us to access Python from anywhere on our system and install software using its built-in package manager, pip. Installing Python in this manner enables the creation of projects that work with the operating system, for example notifications and automated system tasks.

1. Open a browser to the Python website and download the latest stable Windows installer. In the screenshots you will see Python 3.10, which was the latest version at the time of writing.

2. Double click on the downloaded file and install Python for all users, and ensure that Python is added to your path. Click on Install now to begin. Adding Python to the path will enable us to use the Python interpreter from any part of the filesystem.

3. After the installation is complete, click Disable path length limit and then Close. Disabling the path length limit means we can use more than 260 characters in a file path.

4. Click Close to end the installation.

Installing Python via the Microsoft Store

An alternative to installing Python directly from the Python website is to use the Microsoft Store. Apps in the store are approved by Microsoft and can be easily installed. The downside is that this release may be one or two versions behind the official release.

1. Click on Start and search for "store". 

2. Search for Python in the Microsoft Store.

3. Select the latest version of Python. In this case Python 3.11.4 is available from the store. 

4. Click "Get" to download and install Python to your computer. You will need to sign in to your Microsoft account. In a few moments Python will be installed and ready for use.

Running Python in Windows

1. Open a Command Prompt and type “python” then press Enter.

2. Create a short Python script that uses a for loop to print a message to the Python shell ten times. Press space four times to indent the second line, otherwise Python will produce an error. Press Enter to run the code.

for i in range(10):    print(“Python in the command prompt”)

Python comes with its own package manager, pip, that is used to install, update and remove modules of pre-written Python code. These modules provide us with extra functionality. To demonstrate we will use pip to install the pyjokes module, a collection of programmer jokes.

1. Open a Command Prompt and use pip to install pyjokes then press Enter.

pip install pyjokes

2. Open the Python interpreter.

3. Import the pyjokes module and then print a joke from the module. In our case, we got a “hip hip hurray” take on an array containing two hips.

import pyjokesprint(pyjokes.get_joke())

4. More modules can be found using the PyPi Package Index.

Beginning Python With Thonny

If you have never written a line of Python code, then Thonny is for you. Thonny is designed with beginners in mind. The simple interface means we can focus on our code. But don’t underestimate Thonny as under the hood we have tools to write code for the Raspberry Pi Pico series , Adafruit CircuitPython and many MicroPython boards, including those from Lego and the well known ESP32 boards.

1. Open a browser to the Thonny website and download the Windows installer.

2. Go to the Downloads folder and double click the Thonny file to begin installation.

3. Click "Next" and follow the instructions to Install. The install process will take a few moments to complete.

4. Search for Thonny via the Start Menu and click on Thonny to start. You can also press Enter to run Thonny.

5. Wait for Thonny to start. Thonny’s first launch can take some time to complete, subsequent boots will be much faster.

The Thonny Editor Interface

Thonny was designed with beginners in mind and this is reflected in the user interface. It is uncluttered and easy to understand.

The user interface is broken down into three areas.

The menu bar. Here we can use the conventional drop-down menus or use the icons to open, save, create files. Run the project code, and install packages and swap interpreters for working with Python, MicroPython or CircuitPython

The coding area. Here is we write the code for our projects.

The Python shell. This is a REPL (Read, Eval, Print, Loop) where we can interact with the Python interpreter and see the output of the running code.

We can easily write Python code with Thonny. The default is to write Python 3 code, to be run on our machine.

If you are starting out with Python, Thonny is an excellent choice to introduce the language.

Changing the Python Interpreter to work with MicroPython or CircuitPython

Thonny has one feature that elevates it above other beginner editors. It can switch interpreters so that one application, Thonny, can be used to write Python, MicroPython and CircuitPython.

1. Click on Tools >> Options and from the dialog box choose Interpreter.

2. Select the Interpreter from the list. The top list are all of the interpreters for Local Python (on your machine), MicroPython for Raspberry Pi Pico, Pico 2 and Pico with Wi-Fi, RP2040 (for non-Raspberry Pi boards), ESP32 / 8266,BBC micro:bit and for CircuitPython devices.

To connect a Raspberry Pi Pico, we first need a Raspberry Pi Pico running MicroPython, we've got a guide that you can follow.

To follow this part of the how to you will need a Raspberry Pi Pico.

1.  With Thonny open, connect a Raspberry Pi Pico to your computer.

2. Go to Tools >> Options and select the Interpreter tab, and then select the MicroPython (Raspberry Pi Pico) interpreter. Leave the port to automatically detect. Click OK.

3. The Python Shell (3 in the annotated screenshot) will now show an active connection to the Raspberry Pi Pico.

4. In the editor (2 in the annotated diagram) import two modules of code. The first enables MicroPython to talk to the GPIO. The second is used to add pauses to the code.

import machinefrom time import sleep

5. Create an object, led and use it to set the onboard LED as an output. For the Raspberry Pi Pico W use the line of code with ‘LED’, for the original Pico use the line of code with 25. The Pico has the LED connected to GPIO 25, but the Pico W does not.

Raspberry Pi Pico W

led = machine.Pin('LED', machine.Pin.OUT)

Raspberry Pi Pico

led = machine.Pin(25, machine.Pin.OUT)

6. Create a for loop that iterates 10 times, each time the loop runs it will toggle the LED on / off, print a message to the REPL and sleep for 0.1 seconds.

for i in range(10):    led.toggle()    print("BLINK")    sleep(0.1)

7. Click Save and save the file to your Raspberry Pi Pico as blink.py

8. Click on Run >> Run Current Script (or click on the green play button) to start the code on the Pico. The LED on the Pico will blink on and off and the REPL will show the “BLINK” message.

Intermediate Python with Notepad++

You know your stuff, and you need a lightweight editor to get your Python code done. Sure you can install Visual Studio Code, PyCharm etc. But if you just need to edit a few project files, Notepad++ is for you. Notepad++ is a Swiss Army Knife of an editor, and it works exceptionally well with Python. Here we will install Notepad++ and set it up to run our Python code at the press of a button.

Note that you will need to install the Python 3 interpreter, the steps for which are at the start of this how to.

1. Open a browser to the Notepad++ website and download the latest Windows installer.

2. In the your Downloads folder, double click on the file to start the installer.

3. Set your preferred language and click OK.

4. Select Next.

5. Select “I Agree”.

6. Click Next.

7. Click Next.

8. Click Install to begin the process.

9. Check “Run Notepad++” and click Finish to end the installation and open Notepad++.

The Notepad++ Interface

Notepad++ has a more involved user interface than Thonny, and this reflects the flexibility of the editor. Notepad++ is much more than a Python editor, we can use it to write PHP, Perl, JSON etc.

Menus. Here we can load projects, save, create macros and install plugins for specific languages.

Editor. The code for our project is created here.

Workspace. If we are working on a large project with multiple project files, we can load the folder as a workspace and have quick access to the files.

Running Python code in Notepad++

1. Create a simple Python project that uses a for loop to print a message to the Python shell.

for i in range(10):    print("Writing Python in Notepad++")

2. Save the code as for_loop.py.

3. Click on Run >> Run..

4. Click on … and navigate to the Python executable file. Select the file and the path will be added to the dialog box. At the end of the path, add -i "$(FULL_CURRENT_PATH)" to force Notepad++ to open the file. Click Save.

Example path to PythonC:\Users\LattePanda\AppData\Local\Programs\Python\Python310\python.exe -i "$(FULL_CURRENT_PATH)"

5. Create a shortcut called Python3.10 to launch the Python interpreter then click OK. We chose ALT + SHIFT + P as it didn’t conflict with other shortcuts on our system.

6. Use your shortcut to run the Python code.

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

Murmurings of official Bluetooth support for the $6 Raspberry Pi Pico W have been running since early 2023. Developers favoring C/C++ received support back in February.  Today via a blog post from Raspberry Pi LTD CEO Eben Upton, MicroPython developers can now create Bluetooth projects using our favorite microcontroller thanks to the latest MicroPython build.

The Raspberry Pi Pico W's wireless chip, the Infineon CYW43439 provides both 2.4 GHz Wi-Fi and Bluetooth 5.2 over a three pin SPI bus between itself and the RP2040 SoC. The latest MicroPython update brings support for Bluetooth Classic (no ACL/SSO support just yet), BLE Central and Peripheral roles. Bluetooth Classic and BLE can be enabled individually. or at the same time. 

The good news is that you don't have to rush out and purchase a new Raspberry Pi Pico W. As this is a software update, work between Raspberry Pi, Infineon and MicroPython creator, Damien George. All you need to do is download the latest update and flash it to your Raspberry Pi Pico W. Also updated is Alasdair Allan's exceptional documentation. A book, Connecting to the Internet with Raspberry Pi Pico W illustrates just how simple a Bluetooth project can now be created using the Raspberry Pi Pico W.

With support now being added for MicroPython, it must only be a short time before it also arrives for CircuitPython.

Capacitive touch is a simple means to detect user input by measuring the dielectric constant. If it is different to a baseline measurement then it can be used as an input. In the past, we have used an MPR121 touch sensor to trigger an event using a Raspberry Pi Pico. The MPR121 is a dependable Stemma QT sensor that comes in various form factors for crocodile clips and standard wire gauges. We love it so much that we put it on our list of best Stemma QT and Grove add ons page. But is there a way to do it without using a sensor board?

Using just a piece of wire and a 1 Mega Ohm resistor in a banana, we can create our own touch interface and have a healthy snack. In this how-to, we will use the banana to toggle an LED on and off. 

Why something so simple? Learning to turn an LED on / off is the best way to understand how every part of your project works. Sure we could turn the banana into a space bar and play Flappy Birds, use it to open a browser window and “Rick-roll” a friend or start a robot to make a mad dash for the door. But before we can do that we need to understand how and why things work, and the humble LED is a cheap and easy way to do this.

For This Project You Will Need

• Raspberry Pi Pico
• Half-size breadboard
• 1 x 100 Ohm resistor (Brown-Black-Brown-Gold)
• 1 x 1 Mega Ohm resistor (Brown-Black-Green-Gold)
• 1 x Male to male jumper wire
• 1 x Banana (optional)

Building the Circuit

There are two parts to the circuit: the input and the output. The input is a banana (optional), connected to GPIO 16 on the Raspberry Pi Pico using a long jumper wire. GPIO 16 also has a 1 Mega Ohm resistor to connect it to GND. This is a pulldown resistor and ensures that the GPIO pin sees a constant 0V reference. Without it, the input would be erratic. This process can be repeated for multiple inputs, your only limits are GPIO pins, 1 Mega Ohm resistors and bananas. 

The output is a simple LED with the long leg (Anode) connected to GPIO 15 and the short leg (Cathode) connected to GND via a 100 Ohm resistor.

The banana can be replaced with anything that is conductive. Aluminum foil, play-doh and other fruits / vegetables can be used as inputs. You can also forgo the culinary inputs for bare wires. In certain cases this works better.

Build the circuit and double check your connections before moving onwards.

Configuring CircuitPython

We chose CircuitPython for this project for two key reasons. One, it is so easy to use and understand. Our code is easy-to-read, debug and we can write it on any device, even a Chromebook. Two, CircuitPython has the Touchio module which makes it easy to create touch inputs using the GPIO. But before we can start the project we need to write the latest version of CircuitPython to the Raspberry Pi Pico.

1. Go to the official CircuitPython page for the Raspberry Pi Pico and download the latest release UF2 firmware image. At the time of writing this was CircuitPython 8.10. We have chosen the Raspberry Pi Pico as we do not need Wi-Fi, but this project could be used to trigger a web-event, for that you will need a Raspberry Pi Pico W.

2. Whilst holding the BOOTSEL button, connect the Raspberry Pi Pico to your computer. A new drive, RPI-RP2 will appear.

3. Copy the downloaded CircuitPython UF2 file to RPI-RP2. This will write CircuitPython to the internal flash storage of the Pico . A new drive, CIRCUITPY will appear. 

Writing the Code

To write the code we used Thonny on Windows 10. You are free to use your choice of text editor, but Thonny has great CircuitPython (and MicroPython) integration which makes it a breeze to use. Best of all it is free and easy to install on Windows, macOS and Linux devices.

Writing the Code

1. Download and install Thonny if you don’t have it already. Thonny is a Python editor which covers Python 3, MicroPython and CircuitPython.

2. Open Thonny and go to Tools >> Options.

3. Select Interpreter, then set the interpreter as CircuitPython, port to automatic, and click OK. Thonny will now connect to the Pico running CircuitPython.

4. Click on File >> Open and select the CircuitPython device. Then select code.py. Code.py is used by CircuitPython as the main file for a project. It is set to auto-run when the Pico is powered up.

5. Delete any code in code.py. If you need the code, make sure to back it up to your computer.

6. Import four modules of code necessary for the project to work. Touchio is used to create a capacitive touch input using a GPIO pin. Time controls how long the code will pause between actions. Board is used to work with the GPIO, importing using * means that we do not have to include the module name. Digitalio is used to control the status of a pin. It can be an input or output.

import touchioimport timefrom board import *from digitalio import DigitalInOut, Direction

7. Create an object, led, and set the GPIO pin to GP15, and then set it to be an output. This will ensure that when the LED is triggered, current will flow from pin GPIO 15 to the anode of the LED. As the cathode is connected to GND via the 100 Ohm resistor, the complete circuit will turn on the LED.

led = DigitalInOut(GP15)led.direction = Direction.OUTPUT

8. Create an object, led_state and store the integer value 0 inside of it. This object will be used to record the current state of the LED. It can either be off (0) or on (1).

led_state = 0

9. Create an object, touch_pin to make a connection between the code and physical GPIO pin.

touch_pin = touchio.TouchIn(GP16)

10. Create a loop to continually run the code.

while True:

11. Inside the loop create a print function that will report the current state of the touch input pin. We use %s to use the value stored in touch_pin.value and convert it into a string for concatenation to the text.

   print("The pin state is %s" % touch_pin.value)

12. Write a conditional test to check if the input has been touched, and that the LED is turned off. Both tests have to pass in order for the conditional test to pass.

   if touch_pin.value == True and led_state == False:

13. Set the LED to turn on, then update the led_state object to 1, so that the code knows that the LED is on. Sleep for half a second to prevent accidental debounce (double press). This code will only run if the conditional test passes.

       led.value = True       led_state = 1       time.sleep(0.5)

14. Create a conditional test to check if the input has been touched and that the LED is currently on. This code will turn off the LED.

   elif touch_pin.value == True and led_state == True:

15. Toggle the LED off, update the led_state object so that the code knows the LED is off, and then pause for half a second.

       led.value = False       led_state = 0       time.sleep(0.5)

16. Outside of the conditional tests, but still inside the loop, pause the code for 0.1 seconds. Each time the loop iterates, it will pause for 0.1 seconds, this is useful pacing the project code.

   time.sleep(0.1)

17. Save the code to code.py on the CircuitPython device (Raspberry Pi Pico).

18. The code should autorun, if not click on Stop and then Run.

19. Touch the banana to toggle the LED on / off.

Complete Code Listing

import touchioimport timefrom board import *from digitalio import DigitalInOut, Directionled = DigitalInOut(GP15)led.direction = Direction.OUTPUTled_state = 0touch_pin = touchio.TouchIn(GP16)while True:   print("The pin state is %s" % touch_pin.value)   if touch_pin.value == True and led_state == False:       led.value = True       led_state = 1       time.sleep(0.5)   elif touch_pin.value == True and led_state == True:       led.value = False       led_state = 0       time.sleep(0.5)   time.sleep(0.1)

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

If you’re ready to race, you should check out Donkey Car. This open-source Python library makes it super easy to get off the ground with setting up your own driveable car project. Because it’s Python-focused, you can use it with a wide variety of boards ranging from Raspberry Pi to even the Nvidia Jetson range of boards.

This platform makes it easy to not only to drive cars remotely but also integrate them with AI systems so they can drive themselves. You can interface with it using a separate computer or device (like a smartphone or tablet) and make the RC car as complex as you want. Long gone are the days of building your own tool from scratch, Donkey Car has plenty of ready-to-go features out of the box that you can build off of to customize your project the way you want.

What can you do with Donkey Car

• Build your own toy car that can drive itself.
• Drive your car with your phone or laptop.
• Record images, steering angles & throttles.
• Train neural net pilots to drive your car on different tracks.

Not only can you use the SBC of your choice, you can build the RC car of your dreams. It works with plenty of existing car kits you can find online but you can also make one from scratch. The team at Donkey Car recommends using their Donkey2 setup. It costs around $250 to get all of the components and can be assembled in just a couple of hours.

The standard Donkey Car kit is available on the Donkey Car website for $92. It includes a camera, servo driver, 3D printed frame components, as well as screws and jumper wires for assembly. You’ll still need an RC car component, an SBC (like the Raspberry Pi), an SD card, and a battery. While it doesn’t have everything you need, it’s a great starting point. There are also a few chassis made by the brand Exceed that work well with Donkey Car. You can read more about the hardware requirements in the build guide.

If you want to read more about this project or maybe even make one yourself, check out the official Donkey Car website. If you’ve already got an RC car project lying around, it might be worth tinkering with to see how well it handles the Donkey Car library.

DietPi, the lightweight, multi-purpose OS for Raspberry Pi, SBCs and x86 machines, has announced version 8.17. And with this new release, we see new software and enhancements to the Debian-based OS.

Key Updates in DietPi 8.17

• New Software: openHAB Home automation software.
• New Software: Moonlight (CLI and GUI): Game streaming.
• New Software: Restic A command line based backup tool.
• Enhancement: Improvements for Raspberry Pi.
• Enhancement: Updates for NanoPi series boards.
• Enhancement: Update for ROCK4 boards.
• Bug Fix: Raspberry Pi analog audio bug fix.
• Bug Fix: DietPi reporting incorrect temperature (8.16 regression).
• Bug Fix: Google AIY ArmV7 conflicting Python module dependences resolved.
• Bug Fix: UnRAR install on RISC-V based systems is now fixed.
• Full release notes.

DietPi is an alternative Debian-based OS for many different SBCs and x86 machines. Rather than defaulting to a desktop-based OS, DietPi uses a series of menus and user interfaces to facilitate the installation and configuration of specific tools. This level of flexibility means that DietPi is not restricted to being a desktop OS. You can use it tobuild a web server, DNS server (Pi-Hole being one), NAS, or build an appliance to stream games via Steam Link, moonlight etc.

I've personally used DietPi to set up a Node-RED server in my home. Of course, if you want to install a desktop environment, you can. The same software installation process can furnish your desktop with LXDE, LXQt, MATE, Xfce or GNUstep.

If gaming is more your thing, then DietPi can also be used for emulating classic machines such as the Amiga (Amiberry) and classic DOS-era gaming using Box86 and Box64. A Steam client and Moonlight are on hand to stream games from your gaming PC to the living room.

Another level of flexibility afforded by DietPi is how many boards it can be used with. Around 48 SBCs and two images for x86 PCs means that DietPi can be used with a wide range of Raspberry Pi alternatives, and it can be used to breathe new life into aging x86 hardware.

DietPi is free and can be downloaded from the DietPi website. 

Recently, we've seen AI models that produce detailed text-to-video or use run a chatbot on your phone. Now, OpenAI, the company behind ChatGPT, has introduced Shap-E, a model that generates 3D objects you can open in Microsoft Paint 3D or even convert into an STL file you can output on one of the best 3D printers.

The Shap-E model is available for free on GitHub and it runs locally on your PC. Once all of the files and models are downloaded, it doesn't need to ping the Internet. And best of all, it doesn't require an OpenAI API key so you won't be charged for using it.

It is a huge challenge actually getting Shap-E to run. OpenAI provides almost no instructions, just telling you to use the Python pip command to install it. However, the company fails to mention the dependencies you need to make it work and that many of the latest versions of them just won't work. I spent more than 8 hours getting this running and I'll share what worked for me below.

Once I finally got Shap-E installed, I found that the default way to access it is via Jupyter Notebook, which lets you view and execute the sample code in small chunks to see what it does. There are three sample notebooks which demonstrate "text-to-3d" (using a text prompt), "image-to-3d" (turning a 2D image into a 3D object) and "encode_model" which takes an existing 3D model and uses Blender (which you need installed) to transform it into something else and re-render it. I tested the first two of these as the third (using Blender with existing 3D objects) was beyond my skillset.

How Shap-E Text-to-3D Looks

Like so many AI models we test these days, Shap-E is full of potential but the current output is so-so at best. I tried the text-to-video with a few different prompts. In most cases, I got the objects that I asked for but they were low res and missing key details.

When I used the sample_text_to_3d notebook, I got two kinds of output: color animated GIFs which displayed in my browser and monochrome PLY files I could open later in a program like Paint 3D. The animated GIFs always looked a lot better than the PLY files.

The default prompt of "a shark," looked decent as an animated GIF, but when I opened the PLY in Paint 3D, it seemed lacking. By default, the notebook gives you four animated GIFs that are 64 x 64, but I changed the code to up the resolution to 256 x 256 outputted as a single GIF (since all four GIFs looks the same). 

When I asked for something that OpenAI had as one of its examples, "an airplane that looks like a banana," I got a pretty good GIF, particularly when I upped the resolution to 256. The PLY, file, though, exposed a lot of holes in the wings. 

When I asked for a Minecraft creeper, I got something that a GIF that was correctly colored green and black and a PLY that was in the basic shape of a creeper. However, real Minecraft fans would not be satisfied with this and it was too messy of a shape to 3D print (if I had converted it to an STL).

Shap-E Image to 3D Object

I also tried the image-to-3d script which can take an existing 2D image file and turn it into a 3D PLY file object. A sample illustration of a corgi dog became a decent, low-res object that it outputted as a rotating, animated GIF which had less detail. Below, the original image is on the left and the GIF is on the right. You can see that the eyes seem to be missing. 

By modifying the code, I was also able to get it output a PLY 3D file that I could open in Paint 3D. This is what it looked like.

I also tried feeding the image-to-3d script some of my own images, including a photo of an SSD, which came out looking broken and a transparent PNG of the Tom's Hardware logo, which didn't look much better.

However, it's likely that if I had a 2D PNG that looked a bit more 3D-ish (the way the corgi does), I'd get better results. 

Performance of Shap-E

Whether I was doing text or image to 3D processing, Shap-E required a ton of system resources. On my home desktop, with an RTX 3080 GPU and a Ryzen 9 5900X CPU, it took about five minutes to complete a render. On an Asus ROG Strix Scar 18 with an RTX 4090 laptop GPU and an Intel Core i9-13980HX, it took two to three minutes. 

However, when I tried doing text-to-3D on my old laptop, with has an Intel 8th Gen U series CPU and integrated graphics, it had only finished 3 percent of a render after an hour. In short, if you are going to use Shap-E, make sure you have an Nvidia GPU (Shap-E doesn't support other brands of GPUs. The options are CUDA and CPU.). Otherwise, it will just take too long.

I should note that the first time you run any of the scripts, it will need to download the models, which are 2 to 3 GB and could take several minutes to transfer.

How to Install and Run Shap-E on a PC

OpenAI has posted a Shap-E repository to GitHub, along with some instructions on how to run it. I attempted to install and run the software in Windows, using Miniconda to create a dedicated Python environment. However, I kept running into problems, especially because I could not get Pytorch3D, a required library, to install.

However, when I decided to use WSL2 (Windows Subsytem for Linux), I was able to get it up and running with few hassles. So the instructions below will work either in native Linux or in WSL2 under Windows. I tested them in WSL2.

1. Install Miniconda or Anaconda in Linux if you don't already have it. You can find a download and instructions on the Conda site.

2. Create a Conda environment called shap-e with Python 3.9 installed (other versions of Python may work).

conda create -n shap-e python=3.9

3. Activate the shap-e environment.

conda activate shap-e

4. Install Pytorch. If you have an Nvidia graphics card, Use this command.

conda install pytorch=1.13.0 torchvision pytorch-cuda=11.6 -c pytorch -c nvidia

If you don't have an Nvidia card, you'll need to do a CPU-based install. The install is speedy but processing the actual 3D generation with the CPU was extremely slow in my experience. 

conda install pytorch torchvision torchaudio cpuonly -c pytorch

5. Build Pytorch. This is the area where it took me hours and hours to find a combination that worked. 

pip install "git+https://github.com/facebookresearch/pytorch3d.git"

If you get a cuda error, try running sudo apt install nvidia-cuda-dev and then repeating the process.

6. Install Jupyter Notebook using Conda.

conda install -c anaconda jupyter

7. Clone the shap-e repo.

git clone https://github.com/openai/shap-e

Git will create a shap-e folder underneath the one you cloned it from.

8. Enter the shap-e folder and run the install using pip.

cd shap-epip install -e .

9. Launch a Jupyter Notebook. 

jupyter notebook

10. Navigate to the localhost URL the software shows you. It will be http://localhost:8888?token= and a token. You'll see a directory of folders and files.

11. Browse to shap-e/examples and double-click on sample_text_to_3d.ipynb.

A notebook will open up with different sections of code.

12. Highlight each section and click the Run button, waiting for it to complete before moving onto the next section.

This process will take a while the first time you go through it, because it will download several large models to your local drive. When everything is done, you should see four 3D models of a shark in your browser. There will also be four .ply files in the examples folder and you will be able to open those in 3D imaging programs such as Paint 3D. You can also convert them to STL files using an online converter.

If you want to change the prompt and try again. Refresh your browser and change "a shark" to something else in the prompt section. Also, if you change size from 64 to a higher number, you get a higher resolution image. 

13. Double-click on sample_image_to_3d.ipynb in the examples folder again so you can try the image-to-3d script.

14. Highlight each section and click Run.

You'll end up, by default, with four small images of corgis. 

However, I recommend adding the following code to the last notebook section so that it will output PLY files as well as animated GIFs.

from shap_e.util.notebooks import decode_latent_meshfor i, latent in enumerate(latents):    with open(f'example_mesh_{i}.ply', 'wb') as f:        decode_latent_mesh(xm, latent).tri_mesh().write_ply(f)

15. Modify the image location in section 3 to change the image. Also, I recommend changing the batch_size to 1 so it only makes one image. Changing the size to 128 or 256 will give you a higher resolution image.

16. Create the following python script and save it as text-to-3d.py or another name. It will allow you to generate PLY files based on text prompts at the command line.

import torchfrom shap_e.diffusion.sample import sample_latentsfrom shap_e.diffusion.gaussian_diffusion import diffusion_from_configfrom shap_e.models.download import load_model, load_configfrom shap_e.util.notebooks import create_pan_cameras, decode_latent_images, gif_widgetdevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')xm = load_model('transmitter', device=device)model = load_model('text300M', device=device)diffusion = diffusion_from_config(load_config('diffusion'))batch_size = 1guidance_scale = 15.0prompt = input("Enter prompt: ")filename = prompt.replace(" ","_")latents = sample_latents(    batch_size=batch_size,    model=model,    diffusion=diffusion,    guidance_scale=guidance_scale,    model_kwargs=dict(texts=[prompt] * batch_size),    progress=True,    clip_denoised=True,    use_fp16=True,    use_karras=True,    karras_steps=64,    sigma_min=1e-3,    sigma_max=160,    s_churn=0,)render_mode = 'nerf' # you can change this to 'stf'size = 64 # this is the size of the renders; higher values take longer to render.from shap_e.util.notebooks import decode_latent_meshfor i, latent in enumerate(latents):    with open(f'{filename}_{i}.ply', 'wb') as f:        decode_latent_mesh(xm, latent).tri_mesh().write_ply(f)

17. Run python text-to-3d.py and enter your prompt when the program asks for it.

That will give you a PLY output, but not a GIF. If you know Python, you can modify the script to do more with it.

Managing modules in Python is often handled via pip, the Python package manager which uses a repository provided by PyPi to list available Python modules. But what is there for MicroPython? There was upip, a micro version of pip, but now there is mip, the new, official lightweight package manager for MicroPython. 

Mip is designed for all MicroPython devices, be they online or offline. Devices which can connect to the Internet can be used directly via the Python Shell while offline devices can use a tool, mpremote, to install modules from your computer.

In this how-to, fee we will show you how to use mip directly on a Raspberry Pi Pico W, then offline using a Raspberry Pi Pico and mpremote. We will also go through a few handy mpremote commands.

Using mip With the Raspberry Pi Pico W

Using mip with a network connected MicroPython device means that modules can be directly installed to the device in a similar means to pip installing Python modules, and package managers in Linux.

1. Follow these steps to download the latest version of MicroPython for the Raspberry Pi Pico W. The most important steps are to download and install the UF2 firmware image and to set up Thonny. The rest are optional. Ensure that you are downloading MicroPython 1.20 or newer.

2. Open Thonny and click on the Stop button to refresh the connection. This ensures that the Python Shell is open and working correctly.

3. Create a new file. This file will contain all of the steps necessary to connect to Wi-Fi.

4. Add the following lines of code to the new file. Change the SSID and PASSWORD to match your own.

import networkwlan = network.WLAN(network.STA_IF)wlan.active(True)wlan.connect("SSID","PASSWORD")print(wlan.isconnected())

5. Save the file to the Raspberry Pi Pico W as network-connection.py

6. Click on Run to start a Wi-Fi connection. After a few seconds it should print True to the Python shell. This indicates that we have an Internet connection. If false, click Stop and then Run again.

7. Import mip, the lightweight package manager.

import mip

8. Test mip by installing a package. I chose umqtt, a MQTT module for MicroPython. Packages are installed by calling mip’s install function and passing it the name of a package. Mip uses micropython-lib as its index, Python 3’s package manage, pip uses the PyPI index.

mip.install(“umqtt.simple”)

9. Test installing a third-party MicroPython package. Mip can also be used to install third-party packages outside of the micropython-lib index. Here we pass the install function the URL for the PicoZero library from the Raspberry Pi Foundation.

mip.install(“https://raw.githubusercontent.com/RaspberryPiFoundation/picozero/master/picozero/picozero.py”) 

Using Mip With Mpremote on Raspberry Pi Pico

For MicroPython on a device with no network access, a Raspberry Pi Pico, mip will need to be used with mpremote, a tool that will communicate with the device over a USB / serial interface.

1. Follow these steps to download the latest version of MicroPython for the Raspberry Pi Pico W. The most important steps are to download and install the UF2 firmware image and to set up Thonny. The rest are optional. Ensure that you are downloading MicroPython 1.20 or newer.

2. Ensure that Python 3 is installed on your machine.

3. Open a Command Prompt and use pip to install mpremote.

pip install mpremote

4. Run mpremote and pass mip as an argument, and then specify the package name or the URL for the module. Here I am installing a package to use seven segment displays with the Pico.

mpremote mip install https://raw.githubusercontent.com/mcauser/micropython-tm1637/master/tm1637.py 

Other Useful mpremote Commands

Mpremote is a useful tool for quick tasks on a MicroPython device. We’ve detailed a few extra useful commands that will help manage a MicroPython device.

mpremote: Automatically connects to a device running MicroPython to view the output of running code. Press CTRL + ] to close the connection.

mpremote repl: Opens an interactive Python shell, a REPL (Read, Eval, Print, Loop) where a user can directly work with the hardware.

mpremote soft-reset: Reboot the attached MicroPython device. This is the same as pressing CTRL + D in the REPL.

mpremote fs : Use a series of file system commands with the MicroPython device. These commands are similar to common Unix / Linux commands.

In the example we list the contents of the flash storage, create a new file, then re-list the storage to see the new file.

MORE: Best RP2040 Boards

MORE: Best Raspberry Pi Projects

MORE: Raspberry Pi: How to Get Started

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

A new version of MicroPython has been released for compatible microcontrollers. This release. version 1.20, sees support for the Raspberry Pi Pico W and brings a new package manager.

Version 1.20 brings support for the Raspberry Pi Pico W's CYW43439 Wi-Fi chip, this means that stock MicroPython can now take advantage of the $6 boards wireless connectivity. Bluetooth support is still missing, in this and the official MicroPython release. Support for Bluetooth isn't too far away now. Bluetooth support was recently added to the Raspberry Pi Pico SDK, so MicroPython isn't too far away now.

The other addition to the release is a new lightweight package manager, mip. Mip is optimized for use with embedded systems. In MicroPython creator Damien George's release post they state that "It is intended to take over the role of upip and supports installing packages from micropython-lib as well as any URL. Mip can be run directly on a device (with network connectivity) or via mpremote." Raspberry Pi Pico W users would need to ensure that their Pico W is connected to Wi-Fi and that they have access to the Python Shell (REPL) in order to use mip directly on the hardware. Raspberry Pi Pico users will need to use mpremote, a command line tool that provides utilities to communicate between a computer and a MicroPython device over a serial interface.

MicroPython, is the creation of programmer and theoretical physicist Damien George and in broad terms it is a port of Python 3 aimed squarely at microcontrollers. MicroPython has been used with a diverse range of boards (ESP32, ESP8266, W600 etc) but for some it was introduced via the Raspberry Pi Pico. 

We were keen to see if the official Raspberry Pi Pico MicroPython firmware featured support for mip. It seems that it does, the latest firmware for the Raspberry Pi Pico W, rp2-pico-w-20230427-unstable-v1.20.0-1-g82a59a824.uf2 does indeed feature mip. We were able to use mip to install a third-party MicroPython module and then directly use it, all from the Python Shell.

Autonomous agents, or bots that take an objective you give them and then use it to generate their own set of prompts, are the next big thing in generative AI. Rather than asking a chatbot to perform 10 different steps that lead to developing a business plan or writing a series of articles, you just ask for the end result and leave the software to figure out how to get there.

BabyAGI is one of the most popular of this new crop of autonomous agents, but it’s very much in an experimental phase (much like pretty much all current generative AI). You feed it an object and just one initial task and it attempts to take care of the rest.

Built by developer Yohei Nakajima and shared on Github, the Python-powered tool runs on your PC but uses OpenAI’s API and GPT 3.5 or GPT 4 model to do the actual ‘thinking.’ Note that OpenAI’s API costs money, charging you by the “token” (a unit of data that’s about 5 characters). You can get a free $18 credit on OpenAI, but if you are serious about your AI, you will end up spending money. BabyAGI also requires a free account on Pinecone, a vector database server that stores AI output. 

In my experience using BabyAGI, the results were interesting but not always practical. And you will have to manually stop the script by hitting CTRL + C when you think it’s done, because if left to its own devices, it will go on generating new tasks forever (and you will run up your API bilI).

For example, I asked BabyAGI to generate a list of five tutorials on popular Windows topics, but it ended up repeating some of the same topics over and over. One known bug is that BabyAGI doesn’t seem to follow its task lists and will change task number one over and over again without ever getting to task number two.

Despite its current limitations, BabyAGI is an interesting piece of tech that’s worth experimenting with. Below, we explain how to install and use BabyAGI on a PC (the same instructions will likely work on macOS or Linux). We also have an article on how to install and use Auto-GPT, another popular autonomous agent.

How to Set Up and Use BabyAGI

1. Install Python and Git if you don’t already have them installed. You can download the latest version of the programming language from python.org and, if you are using Windows, you can get Git for Windows (it is almost certainly in Linux). Make sure that the Python directory and Python Scripts directory are in your Path in Windows. You can do that by searching Windows for “environment variables” and clicking to edit the Path variable.

2. Obtain an OpenAI API key if you don’t have one already. You can get one by navigating to OpenAI’s API key page, logging in / creating a free account and clicking the Create new secret key button. You’ll then have the opportunity to copy the key, which you can never get again (though you can create new ones).

3. Get an API Key from Pinecone. Pinecone is a vector database for storing AI data. You can get a free account though there may be a waiting list. You can get an API key by clicking on the API Keys tab and hitting the copy button or “Create API Key”. Also, take note of the “Environment” location (ex: us-central1-gcp).

4. Open a command prompt or (in Linux) terminal window and navigate to the folder under which you want to install BabyAGI.

5. Clone BabyAGI by entering the following command.

git clone https://github.com/yoheinakajima/babyagi

A new directory called babyagi will be created underneath the one you are in.

6. Enter the babyagi directory and Install the required dependencies using pip.

cd babyagipip install -r requirements.txt

7. Copy the file .env.example to a new file named just .env

copy .env.example .env

8. Open .env for editing in a text editor such as notepad.

9. Enter the OpenAI API key, Pinecone API Key and Pinecone environment variable in the appropriate places. Do not put quotation marks around the keys.

10. Make optional changes:

• Modify API_MODEL field if you want to use gpt-4 instead of the default, gpt-3.5-turbo. GPT 4 may provide better results but it incurs higher API costs.
• Set TABLE_NAME or just leave it as the default, baby-agi-test-table. This is the table name it will use in Pinecone.
• Change BABY_NAME if you want to give this instance a name other than BabyAGI

11. Set an OBJECTIVE and an INITIAL_TASK. Don’t put them in quotes, but do use natural language. Your objective should be what you want to accomplish and INITIAL_TASK should be the first task to start with. You cannot designate subsequent tasks as BabyAGI will plan them for you.

12. Save your .env file and exit.

13. Enter python babyagi.py at the command prompt from within the babyagi directory.

python babyagi.py

14. Watch the output and hit CTRL + C to stop it when you want to quit the program.

Don't walk away and just leave BabyAGI running because it could run up a huge OpenAI API bill as it doesn't stop itself, at least in the current version and implementation I tried.

It seems that the dream of a CircuitPython powered home computer is inching ever closer. Adafruit's recently released Feather RP2040 DVI simplifies the process of using the Raspberry Pi Pico's RP2040 SoC with DVI / HDMI output. In a video from Adafruit we can see live CircuitPython output running on an HDMI monitor using code that was originally developed for bare metal CircuitPython on the Raspberry Pi. This new board could become a hot contender to join our Best RP2040 Boards list.

In the video we can see Adafruit founder Limor "Ladyada" Fried demonstrating DVI output using CircuitPython. We can see that this is CircuitPython 8.1.0-beta and Fried demonstrates video output using a port of Python Turtle, itself a version of LOGO's turtle command. CircuitPython code is written on an external PC and when saved it triggers the code to execute. Fried's second demo shows Sierpiński triangle, a fractal composed of triangles, rendered in real-time.

So why is this important? For two reasons. Firstly to output graphics with the RP2040 we would normally need a lean programming language. In the past C/C++ and Arduino code provided the best results. In fact early demos of this board used the PicoDVI Arduino library to generate video output. With a CircuitPython alternative, we have an easier entry point for those who want to dip their toe into the project. CircuitPython abstracts much of the complexity via pre-written modules of code. Secondly, we now are a step closer to using CircuitPython without the need for a laptop or desktop computer. Once we have USB keyboard support, we could run the board "bare metal" with CircuitPython.

The idea of a "bare metal" version of CircuitPython for the Raspberry Pi was first mentioned by CircuitPython lead developer, Scott Shawcroft, during an episode of Tom's Hardware: The Pi Cast. The idea is to boot the Raspberry Pi directly into a Python Shell (REPL) where the user can directly work with Python and the GPIO in a manner similar to 1980s home computers. Shawcroft's Github branches contained a build of CircuitPython with support for DVI output.

Adafruit's $14.95 Feather RP2040 with DVI is currently out of stock. But, we can't wait to try it out for our self.

When we think about Raspberry Pi, we normally picture single-board computers, but the Raspberry Pi Foundation was started to help kids learn about computers and it wants to help whether or not you own its hardware. The non-profit arm of Raspberry Pi this week released its new, browser-based code editor that's designed for young people (or any people) who are learning.

The Raspberry Pi Code Editor, which is considered to be in beta, is available to everyone for free right now at editor.raspberrypi.org. The editor is currently designed to work with Python only, but the organization says that support for other languages such as HTML, JavaScript and CSS is coming.

I tried out the Code Editor on my PC's browser and, in its current form, there's nothing particularly unique about it. However, I found the UI very user-friendly and was impressed with how it is integrated into someone online tutorials. The interface consists of three panes: a list of files in your project, a code editor and an output pane that runs the result of your code when you hit the Run button.

If you create a free account on raspberrypi.org, which I did, the system will save all of your projects in the cloud and you can reload them any time you want. You can also download all the files in a project as a .zip file. 

Since the entire programming experience takes place online, there's no way (at least right now) to use Python to control local hardware on your PC or your Raspberry Pi. If you want to attach one of the best Raspberry Pi HATs or use the GPIO pins on your Pi to light up an LED light, you need a local editor like Thonny, which comes preinstalled on all Raspberry Pis and is a free download for Windows, Mac and Linux.

The Raspberry Pi Code editor isn't the only online Python editor around by any stretch of the imagination as you can also use a service such as Trinket.io, which will let you write Python code in one pane while previewing it in another. However, what's interesting about Raspberry Pi's tool is that the organization has a few Python tutorials that are designed to be used with it.

The Raspberry Pi Foundation already had a nice set of Python tutorials on its site, but it has adapted some of them to open sample code directly in the online editor. For example, when I tried the "Say hello" lesson, the first link on the page opens the working set of code in the editor in a new tab in my browser. When I revisited the page and clicked the link a few minutes later, it took me back to the same code I had edited before, because it saved the lesson as a project that was associated with my account.

I had fun writing a simple Python script that printed "Tom's Hardware was here" to screen and repeated it 500 times. The editor supports using emojis in your output and the sample code gives you some emojis you can copy and paste into your commands.

At present, the Editor only works with the first two lessons in Raspberry Pi Foundation's "Intro to Python" learning path. However, you can use all of the lessons with Trinket or another editor and I'm sure they will integrate the new editor into all of the lessons soon.

The Pi Foundation says that it plans to add a number of features to the Code Editor, including sharing and collaboration. The organization also plans to release the editor as an open-source project so anyone can modify it. Based on my brief experience testing it, I can say that it seems like it will be a great learning platform for new coders, especially when used with the tutorial paths on raspberrypi.org.

The GurgleApps team is back with another cool Raspberry Pi Pico W project: a Pico W-based web server. But this project does more than serve web pages — it can also run your Python code on the Pico W via a web interface.

The web server is accessible by any device with a web browser, on a local or external network. The project is coded in MicroPython and at a basic level it works with two files. Wi-Fi configuration details are stored in config.py, and the project code is stored in main.py (which MicroPython will autorun when powered on). 

The clever part of this project is the abstraction. Rather than bog the user down with complexities, the team has created its own webserver module (gurgleapps_webserver.py) which the project code imports and uses.
Abstracting code is a good way of getting users comfortable with a project / language before pulling back the curtain to reveal the complexities of a powerful language.

GurgleApps demonstrates the web server by bundling a project to control the Pico's onboard LED using a rather responsive web interface. Crafting a custom URL, advanced users can directly access the function and control the LED. This advanced approach also returns a JSON object to the user, which, in this case, tells us the current delay (blinking on / off) of the LED and the LED's current state. Other example projects include a frequency generator which was used in a Physics experiment to visualize vibrations in sand (or polenta). The frequency data is also displayed on a tiny OLED screen.

The team then goes into great detail on how to create your own functions which can be called via the web interface. This detail is what sells the project — using not very much code we can create a web interface for a robot or see real-time sensor data in a web page.

The user interface is created using HTML and CSS. These files are stored in the www directory of the project's Pico download. Changing the graphics and layout of the user interface would be a quick and easy task for most learners.

It is great to see the GurgleApps team building another simple-yet-powerful project based around our favorite microcontroller. You can learn more about the project via the GurgleApps blog and find all of the raw code this GitHub repository.

A YouTuber has published a video where he tricks ChatGPT into generating usable Windows 95 activation keys. After asking Open AI’s chatbot directly for Windows 95 keys, he received an expected reasoned refusal. YouTuber Enderman then asked the same thing but from a different angle. The result was a success which was somewhat limited by ChatGPT’s ability to process natural language requests into formulas.

In its initial refusal to generate a Windows 95 key, ChatGPT explained that it couldn't perform that task and suggested that its inquisitor consider a newer, supported version of Windows.

It has been known for a while that a working Windows 95 key is relatively simple to generate, so this ChatGPT exercise was definitely just for fun. The Windows 95 OEM key format is outlined above, and the Windows 95 retail keys are even shorter and more straightforward.

So, to bypass the principled refusal of ChatGPT to generate a software key, Enderman put the formula into words. The first attempts didn’t work out and caused an error. However, a few tweaks to the structure of the query appeared to do the job.

Some of the tested results were checked by attempting to activate a fresh Windows 95 install in a virtual machine. While the keys passed a casual inspection, it turns out that only about 1-in-30 keys seem to work as expected.

So what is the problem with these keys? Enderman complains that “the only issue keeping ChatGPT from successfully generating valid Windows 95 keys almost every attempt is the fact that it can’t count the sum of digits and it doesn’t know divisibility.” In the five-digit string divisible by seven section, the AI appears to provide a stream of random numbers that don’t pass this simple mathematical test.

That is about as deep as this ‘Activating Windows with ChatGPT’ video goes. However, it is worth sticking to the end for some fun trolling. After the ‘successful’ generation of a host of Windows 95 keys (with a 1-in-30 chance of working), Enderman thanked the AI by inputting, “Thanks for these free Windows 95 keys!” Then, in what seems to be a trend among AIs, ChatGPT claimed its innocence, and when confronted with the fact that “I just activated my Windows 95 install,” responded, “I’m sorry, but that is not possible...”

If you would like to have a closer look at the algorithm(s) behind the Windows 95 retail and OEM keys from a modern perspective, YouTube channel stacksmashing has published a six-minute video on the topic. The video shows that most of the data format clues for Win95 key generating can be found within the PIDVALIDATE function in setupx.dll file.

Tom’s Hardware colleagues who dabble in the mystic arts of programming and scripting suggest that while quizzing ChatGPT about key generating may be fun, it would have probably been more productive to manipulate the AI into writing a Python script to generate a conforming key or to DIY it.

Pimoroni's Tufty2040 is a Raspberry Pi Pico-powered color LCD badge, but it can do much more than names. Coder Pixylatte has coded the Atari classic River Raid in MicroPython for Tufty2040 — and it looks perfect.

For those of us too young to remember (I wish that were the case), River Raid was released in 1982 for the Atari 2600 games console (I remember playing it on a Commodore 64). The goal of the game is to fly your jet fighter down a river, attacking enemy vehicles as you fly. You have to dodge attacks and vehicles and make sure you have enough fuel to carry on your mission — "Don't shoot the fuel tanks," is what I would tell my younger self. 

The game never ends, but bridges act as checkpoints along the way to measure your progress, and each life lost returns you to the previous bridge.

Pixylatte's version of the game is coded entirely in MicroPython, and is added as a menu item to the default Tufty 2040 menu. This means that a simple name badge can be quickly turned into a game badge when we're taking a break at a conference!

The coding for the game is fabulous — it uses a sprite map (a large grid of sprites that are swapped as needed) for the game assets. The MicroPython code reacts to player input to control the direction and speed of the jet, along with a button to fire at your enemies. The enemy sprites fly left to right on the screen, dodging your fire as your fly further up the river.

Protecting Tufty2040 from the rigours of gaming is a 3D printed case — one that could be easily reproduced on any of the best 3D printers. The case, designed by Funkypiwy (aka Pierre-yves Baloche) provides great protection to the perimeter of Tufty2040 and also has an optional stand. It appears that Pixylatte has printed a different case back — one which has an integrated coin cell battery pack. You can also design your own case for the Tufty2040.

Pixylatte's project is great fun — you can find all of the details on their GitHub repository.

Overclocking any model of Raspberry Pi is really simple. But overclocking the Raspberry Pi Pico is even simpler. All it takes is two lines of MicroPython and your Pico can easily run at double its normal speed, and without the need for the best CPU coolers.

In this how to we will overclock a Raspberry Pi Pico to 270 MHz, double the base speed of 133 MHz. Then we will write a script to test how far we can overclock, and then how low we can underclock the CPU.

You might be thinking “Why overclock a Raspberry Pi Pico?”Using a low level language, such as C, the Pico is capable of being used to play games such as Doom (the full game) using an HDMI output board. It can emulate retro computers such as the ZX Spectrum and Commodore 64. With MicroPython, overclocking will give us a noticeable speed boost, and underclocking may provide us with longer battery life if we’re using it in a battery-powered project.

This how to will work with the Raspberry Pi Pico, Pico W and many other of the best RP2040 based boards when using MicroPython. There are other methods for changing the frequency when programming the boards in other languages.

For This Project You Will Need

A Raspberry Pi Pico or Pico W or any other RP2040 based board that’s running MicroPython.

Overclocking the Raspberry Pi Pico With MicroPython

1.  Install the latest version of MicroPython on your Pico. If you haven’t already done this, follow up to step three of this guide to learn how.

2. In the REPL, import the machine module and check the current speed of the Raspberry Pi Pico. The returned value will probably be 125000000 Hertz (125 MHz). Some boards or versions of MicroPython may have it set a little higher by default.

import machinemachine.freq()

3. Using the same command, set the CPU speed to 270 MHz.

machine.freq(270000000)

4. Check the CPU speed to ensure that the overclock has worked. The returned value should be 270000000 Hertz (270 MHz).

machine.freq()

Right now this speed boost is temporary. When the Pico is rebooted, it will return to its default speed (usually 125 MHz). In order to retain the overclock, it must be set each time the Pico boots. Adding these two lines to the start of any MicroPython code will overclock the RP2040 to the desired speed when the code is run.

import machinemachine.freq(SPEED IN HERTZ)

How Far Can The RP2040 Be Pushed?

Overclockers are always looking to go just that little bit faster but how can we determine our luck in the silicon lottery? For that we automated the process with a little Python code. 

1. In Thonny start a new file by first importing two modules. Machine is used to change the CPU speed, and time is used to pace the code.

import machineimport time

2. Create a variable, freq and store 270 MHz as Hertz. We know that 270 MHz works well, so we start from a known working speed. If your goal is to underclock the RP2040, reduce the value accordingly.

freq = 270000000

3. Create an object, speed, and in there store the current speed of the RP2040. Using a little math, the returned value in Hertz is converted to megahertz, then rounded to one decimal place, before finally being converted to a string.

speed = str(round(machine.freq()/1000000,1))

4. Print the current CPU speed as part of a message. We needed to convert the speed to a string in order to place it in the message.

print("The starting speed is",speed,"MHz")

5. Print a message to the user, informing them that the test starts in five seconds, then wait for five seconds.

print("Starting the test in five seconds")time.sleep(5)

6. Create a loop to continually run the code. We could use a for loop, but a while True loop will crash when it hits a bad frequency, so we gain nothing from a for loop.

while True:

7. Set the CPU speed using the freq variable.

   machine.freq(freq)

8. Create an object, speed, and in there store the current speed of the RP2040. Using a little math the returned value in Hertz is converted to MegaHertz, then rounded to one decimal place, before finally being converted to a string.

   speed = str(round(machine.freq()/1000000,1))

9. Print the current CPU speed as part of a message. We needed to convert the speed to a string in order to place it in the message.

   print("The starting speed is",speed,"MHz")

10. Increment the speed by 10 MHz and save the value to freq. The += operator translates to freq = freq + 10000000. It is shorter and neater in the code. Both work equally as well, and can be interchanged for clarity. The += can be swapped for -= so that the values count down to find the lowest CPU speed.

   freq += 10000000

11. Pause the code for two seconds. This will give us time to read the values before the loop repeats.

   time.sleep(2)

12. Save the code to the Raspberry Pi Pico as speedtest.py and click run. Our best speed was 280 MHz, but you may get lucky.

We also tested an underclock (reducing the speed by 10 MHz each loop) and managed to get it down to 10 MHz, which should significantly reduce the amount of power draw for projects that require a long battery life. We were unable to capture any data due to the level of precision equipment required.

Complete Code Listing

import machineimport timefreq = 270000000speed = str(round(machine.freq()/1000000,1))print("The starting speed is",speed,"MHz")print("Starting the test in five seconds")time.sleep(5)while True:   machine.freq(freq)   speed = str(round(machine.freq()/1000000,1))   print("The current speed is",speed,"MHz")   freq += 10000000   time.sleep(2)

Watch any tech-inspired movie from the 1980s (we're thinking Wargames, Aliens and Ferris Bueller's Day Off) and there will inevitably be a scene with low-res text slowly scrolling across a burnt-out CRT screen. This project from SomePeopleCallMeJJ (Jeff Jetton) takes a different angle to the countless "magic mirrors." It uses an old CCTV monitor and a Raspberry Pi to show us the latest news, with an 1980s twist.

neither_magic_nor_a_mirror_retrostyle_newsfeed from r/raspberry_pi

The RetroFeed project uses a Raspberry Pi -- we're not sure which model but given that it outputs scrolling text, any model will have the power to do this. With the right accessories, even a Raspberry Pi Pico W could do the job. The Pi is connected to an old CCTV monitor, using composite output, which slowly scrolls a series of news and finance headlines, weather data and the location of the International Space Station across the screen. Rather than dump everything at once,the project slowly types the text, which Jetton likens to Don Lancaster's TV Typewriter, using random horizontal parking positions to reduce screen burn in. Everything is text-based and at the super low resolution of 80x24 characters. 

So where does the data come from? The Raspberry Pi scrapes the data using the Python requests library, with each feed (news, finance, ISS, weather) having its own module. These modules are imported by the main newsfeed.py file, and with a little parsing and formatting the data is output to the delightfully old-school CCTV display.

Jetton is honest about the state of the project, "Currently this is just doing some very clumsy web-scraping, with refreshes at certain intervals. Expect the scrapers to break at some point, if they're not already broken by the time you read this." But we really don't mind this approach. It is honest, fun and quirky. The retro output of the project lends itself rather well to the occasional issue. Jetton mentions that the project could also be achieved using APIs and RSS feeds, something that we did back in 2020.

Jetton has detailed the steps necessary to recreate the project via his GitHub repository. You'll need to route video output to the composite jack (the 3.5mm jack on all but the first Raspberry Pi), then modify the boot process to drop you into a terminal.

Geekbench, one of the simplest-to-run benchmarks that works across different computing platforms, is getting an update. Primate Labs is shipping Geekbench 6 for Windows, Linux, macOS and Android, which it says will address the ways people use their computers and phones in real life.

The new version is designed to focus on machine learning workflows and to address how processors with "big" and "little" cores share workloads. On the machine learning side, that means that Geekbench will "better take advantage of your GPU," as those jobs rarely just use the CPU.

"New frameworks and abstraction layers for our benchmark also mean more accurate cross-platform comparisons for these measurements across device types and environments, with support for more ML acceleration instructions, as well as more uniform GPU performance across platforms," Primate Labs' press release reads.

For multi-core benchmarking, the tests will be able to quantify the way that cores share tasks in "true-to-life workload examples." Previously, Geekbench added together the performance of each core. It also features larger images, to simulate what you might actually take with your phone's camera.

Additionally, the new Geekbench will include a bunch of new tests. Here's the list from Primate Labs:

• Background blur, as during video conferences
• Photo filters, similar to those used by modern social media apps
• Object detection for AI workloads
• Photo library for importing and semantic tagging photos and metadata
• Text processing for parsing and converting things like markdown and regex in Python (more true to real developer use cases)

Primate also says it is updating ray tracing, horizon detection and navigation tests, while keeping around measurements of loading websites, processing HDR, importing photo files, rendering a PDF and more. These workloads are more intense, so the runtime should be longer. It took my personal MacBook Pro with M1 Pro just over three minutes to run the updated test.

Geekbench 6 on Windows 11

Geekbench 6 on macOS

The new baseline score of 2,500 is based off of an Intel Core i7-12700. Despite the new functionality, running the benchmark hasn't changed. There are still CPU and compute tests (the latter of which places a heavier emphasis on the GPU), both of which can be started with just a click.

The new version has slightly updated pricing. Gone are single-user licenses; instead, all non-commercial use is free. The Pro version, which will stay at $99, will add more features, including offline results, automation from the command line and a portable version. For the next two weeks, Primate Labs will sell the Pro version 20% off, or $79. Licenses from Geekbench Pro won't carry over, so you'll need a new one.

We use Geekbench on our laptop and gaming PC benchmarks, so expect Geekbench 6 to pop up on Tom's Hardware soon, once we've gathered enough comparison data to make it useful.

The new Raspberry Pi Camera Module 3 offers exceptional image quality and a choice between a standard (75 degrees) and wide (120 degrees) lenses. Best of all, we now have autofocus. Taking pictures with the Picamera2 is easy, but sometimes we just want to press a button and take a picture, and appear in the shot!

In this project we will use Blue Dot, a Python module and Android app to create a Bluetooth controlled camera trigger. Thanks to Blue Dot’s easy to use library and Picamera2’s verbose structure we will be capturing 1080p photos via a small amount of code.

For This Project You Will Need

• A Raspberry Pi 3 or 4
• A Raspberry Pi Camera
• An Android device

Installing the Raspberry Pi Camera Module

 1. Open the camera port by gently lifting the plastic lock upwards.

2. Insert the ribbon connector with the blue tab facing the USB / Ethernet ports. Raspberry Pi Zero users will need to use an adapter and connect the camera to the port on the right side of the board.

3. Close the lock on the connector and give it a very gentle pull to make sure it is in place.

4. Power up the Raspberry Pi to the desktop. Open a terminal and install the latest Picamera updates.

sudo apt update && sudo apt upgrade -y

5. From the terminal, check that your camera is working properly. The libcamera command is handy for quickly checking that our camera is connected and working as expected.

libcamera-hello

Installing Blue Dot

Blue Dot is the creation of Martin O’Hanlon and it provides a truly simple means to remotely control a Raspberry Pi. The name “Blue Dot” represents the large, blue dot that dominates the Android device’s screen. We’re going to use Blue Dot as a large, blue button to trigger the camera to take a picture.

1. On your Android device open the Google Play Store and search for Blue Dot. Alternatively follow this link.

2. Install Blue Dot on your Android device.

3. On your Raspberry Pi, open a terminal and install Blue Dot’s Python library.

sudo pip3 install bluedot

4. Go to the Bluetooth menu, right click and select “Make Discoverable”.

5. On your Android device go to the Settings >> Connected devices and select Pair New Device.

6. Select “raspberrypi” and follow the pairing instructions. If your Raspberry Pi has a different hostname, then “raspberrypi” will not appear, look for your hostname.

With our Android device and Raspberry Pi now connected we will write a quick Python script to check that Blue Dot can communicate between the two devices.

1. Open Thonny, found in the main menu under Programming.

2. Create a new file and import the Blue Dot Python library.

from bluedot import BlueDot

3. Create an object, bd, that we will use to work with the library.

sudo pip3 install bluedot

4. Wait for the user to press the blue button. This line of Python is a blocker. It will wait until the user interacts. When that happens the code moves to the next line.

bd.wait_for_press()

5. Print a message to the Python shell.

print("You pressed the blue dot!")

6. Save the code as bd-test.py and click Run. The code will wait for a connection from our Android device.

7. On your Android device, open Blue Dot.

8. Select the hostname of your Raspberry Pi. Typically this is “raspberrypi”. 

9. Click on the Blue Dot to trigger the Python code into action. You should see a message in the Python shell.

Complete Test Code Listing

from bluedot import BlueDotbd = BlueDot()bd.wait_for_press()print("You pressed the blue dot!")

Creating a Camera Trigger with Blue Dot

The goal of this project is to create a camera trigger with Blue Dot. When the button is pressed a function is launched on the Raspberry Pi which handles taking a photograph.

1. Create a new file and import the Blue Dot Python library.

from bluedot import BlueDot

2. Import Picamera2 and libcamera. The preview class is used to generate preview windows, useful for framing a shot. The controls class from libcamera enables us to use autofocus with the new Camera Module 3.

from picamera2 import Picamera2, Previewfrom libcamera import controls

3. Import the pause function from signal and then the time library. Pause will be used to stop the code from exiting. Time will delay the code after a preview window is created, giving us time to frame a shot.

from signal import pauseimport time

4. Create an object, bd, that we will use to work with the library.

bd = BlueDot()

5. Create an object, picam2, that will enable us to easily use the Picamera2 library.

picam2 = Picamera2()

6. Define a function, take_picture() that will be used to take a picture. Functions work by calling their name, this triggers the function to run through all of the steps within it.

7. Create a configuration for the camera to take still images. This sets the image size to 1080p, while preview windows will be 720p.

   camera_config = picam2.create_still_configuration(main={"size": (1920, 1080)}, lores={"size": (1280, 720)}, display="lores")

8. Set Picamera2 to use the new configuration.

   picam2.configure(camera_config)

9. Start a preview window with a 720p resolution. We set the position using X and Y coordinates, otherwise it defaults to 0,0. Tweak this to meet your needs.

   picam2.start_preview(Preview.QTGL, x=100, y=200, width=1280, height=720)

10. Show the preview window.

   picam2.start(show_preview=True)

11. Set the camera to use continuous autofocus. Note, this only works with the Camera Module 3.

   picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous})

12. Pause for two seconds before capturing the image to a file called picam1.jpg.

   time.sleep(2)   picam2.capture_file("picam1.jpg")

13. Close the preview window and then stop Picamera2.

   picam2.stop_preview()   picam2.stop()

14. Out of the function, use Blue Dot’s “when_pressed” function to react to user input by running the take_picture function.

bd.when_pressed = take_picture

15. Use pause to prevent the code from exiting.

pause()

16. Save the code as bluedot_camera.py and click Run to start the code. You will see that the code waits for the Android device to connect.

17. On your Android device, open Blue Dot.

18. Select the hostname of your Raspberry Pi. Typically this is “raspberrypi”.

19. Click on the Blue Dot to trigger the camera. You will see the preview window appear and then, two seconds later, an image will be saved to the micro SD card. Repeated presses will create a new image, but as the filename is the same it will overwrite each time.

Complete Code Listing

from bluedot import BlueDotfrom picamera2 import Picamera2, Previewfrom libcamera import controlsfrom signal import pauseimport timebd = BlueDot()picam2 = Picamera2()def take_picture():   camera_config = picam2.create_still_configuration(main={"size": (1920, 1080)}, lores={"size": (1280, 720)}, display="lores")   picam2.configure(camera_config)   picam2.start_preview(Preview.QTGL, x=100, y=200, width=1280, height=720)   picam2.start(show_preview=True)   picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous})   time.sleep(2)   picam2.capture_file("picam1.jpg")   picam2.stop_preview()   picam2.stop()bd.when_pressed = take_picturepause()

You will not have missed the frenzy of excitement surrounding ChatGPT (Chat Generative-Pre-Trained Transformer). It can create images, write code, songs, poetry and try to solve our problems, big or small. It may not know how to beat Star Trek’s Kobayashi Maru simulation, but it can write Python and Bash code with ease. At a push it can also be used to write G-Code for the best 3D printers though we have yet to try it on our Creality Ender 2 Pro.

Typically we interact with ChatGPT via the browser, but in this how to, we will use a special Python library that will connect our humble Raspberry Pi to the powerful AI and provide us with a tool to answer almost any question. This project is not exclusive to Raspberry Pi; it can also be used with Windows, macOS and Linux PCs. If you can run Python on it, then chances are this project will also work. 

If you are using a Raspberry Pi then you can use almost any model with this project as we are simply making requests over an Internet connection. However, for the smoothest performance overall, we recommend a Raspberry Pi 5 or Raspberry Pi 4.

Setting Up ChatGPT API Key for Raspberry Pi

Before we can use ChatGPT with our Raspberry Pi and Python we first need to set up an API key. This key will enable our code to connect to our OpenAI account and use AI to answer queries, write code, write poetry or create the next hit song.

1. Login to your OpenAI account.

2. Click on the menu and select View API Keys.

3. Click on Create new secret key to generate an API key. Make sure to copy and paste this key somewhere safe, it will not be shown again. Never share your API keys, they are unique to your account, any costs incurred will come from your account.

Installing the ChatGPT Python API on Raspberry Pi

With our API key in hand we can now configure our Raspberry Pi and specifically Python to use the API via the openAI Python library.

1. Open a Terminal and update the software on your Raspberry Pi. This command is two-fold. First it runs an update, checking that the list of software repositories on our Pi is up to date. If not, then it downloads the latest details. The “&&” means that if the first command (update) runs cleanly, then the second command where we upgrade the software will begin. The “-y” flag is used to accept the installation with no user input.

sudo apt update && sudo apt upgrade -y

2. Install the openai Python library using the pip package manager.

pip3 install openai

3. Open the bashrc file hidden in your home directory. This file is where we need to set a path, a location where Raspberry Pi OS and Python can look for executable / configuration files.

nano ~/.bashrc

4. Using the keyboard, scroll to the bottom of the file and add this line.

export PATH="$HOME/.local/bin:$PATH"

5. Save the file by pressing CTRL + X, then Y and Enter.

6. Reload the bashrc config to finish the configuration. Then close the terminal.

source ~/.bashrc

Creating a ChatGPT Chatbot for Raspberry Pi

The goal of our chatbot is to respond to questions set by the user. As long as the response can be in text format, this project code will work. When the user is finished, they can type in a word to exit, or press CTRL+C to stop the code. We tested it with facts and trivia questions, then asked it to write Python code, Bash and a little G-Code for a 3D printer.

1. Launch Thonny, a built-in Python editor. You can find it on the Raspberry Pi menu, under Programming >> Thonny.

2. Import the openai library. This enables our Python code to go online and ChatGPT.

import openai

3. Create an object, model_engine and in there store your preferred model. davinci-003 is the most capable, but we can also use (in order of capability) “text-curie-001”, “text-babbage-001” and “text-ada-001”. The ada model has the lowest token cost.

model_engine = "text-davinci-003"

4. Create an object, open.api_key and store your API key. Paste your API key between the quotation marks.

openai.api_key = "YOUR API KEY HERE”

5. Create a function, GPT() which takes the query (question) from the user as an argument. This means we can reuse the function for any question.

def GPT(query):

6. Create a response object that will pass the details of our query to ChatGPT. It uses our chosen model and query to ask the question. We set the maximum token spend to 1024, but in reality, we will spend far less so this can be tweaked. The “temperature” controls how creative the responses can be. The higher the value, say 0.9, the more creative the model will try to be. 0.5 is a good mix of creative and factual.

   response = openai.Completion.create(       engine=model_engine,       prompt=query,       max_tokens=1024,       temperature=0.5,   )

7. Return the data from ChatGPT, stripping out the response text, and the number of tokens used. The returned data is in a dictionary / JSON format so we need to specifically target the correct data using keys. These keys return the associated values.

   return str.strip(response['choices'][0]['text']), response['usage']['total_tokens']

8. Create a tuple and use it to store a list of strings that can be used to exit the chat. Tuples are immutable, meaning that they can be created and destroyed, but not updated by the running code. They make perfect “set and forget” configurations.

exit_words = ("q","Q","quit","QUIT","EXIT")

9. Use a try, followed by while True: to instruct Python to try and run our code, and to do so forever.

try:   while True:

10. Print an instruction to the user, in this case how to exit the chat.

       print("Type q, Q, quit, QUIT or EXIT and press Enter to end the chat session")

11. Capture the user query, using a custom prompt and store in an object called query.

       query = input("What is your question?> ")

12. Use a conditional test to check if any of the exit_words are solely present in the query. We can use these words in a query, but if they are the only words, then the chat will end.

       if query in exit_words:

13. Set it so that, if the exit_words are present, the code will print “ENDING CHAT” and then use break to stop the code.

           print("ENDING CHAT")           break

14. Create an else condition. This condition will always run if no exit_words are found.

       else:

15. Run the ChatGPT query and save the output to two objects, res (response) and usage (tokens used).

           (res, usage) = GPT(query)

16. Print the ChatGPT response to the Python shell.

           print(res)

17. Print 20 = in a row to create a barrier between the ChatGPT text and then print the number of tokens used.

           print("="*20)           print("You have used %s tokens" % usage)           print("="*20)

18. Create an exception handler that will activate if the user hits CTRL+C. It will print an exit message to the Python shell before the code exits.

except KeyboardInterrupt:   print("\nExiting ChatGPT")

19. Save the code as ChatGPT-Chatbot.py and click Run to start. Ask your questions to the chatbot, and when done type one of the exit_words or press CTRL+C to exit.

Complete Code Listing

import openaimodel_engine = "text-davinci-003"openai.api_key = "YOUR API KEY HERE"def GPT(query):   response = openai.Completion.create(       engine=model_engine,       prompt=query,       max_tokens=1024,       temperature=0.5,   )   return str.strip(response['choices'][0]['text']), response['usage']['total_tokens']exit_words = ("q","Q","quit","QUIT","EXIT")try:   while True:       print("Type q, Q, quit, QUIT or EXIT and press Enter to end the chat session")       query = input("What is your question?> ")       if query in exit_words:           print("ENDING CHAT")           break       else:           (res, usage) = GPT(query)           print(res)           print("="*20)           print("You have used %s tokens" % usage)           print("="*20)except KeyboardInterrupt:   print("\nExiting ChatGPT")

The Raspberry Pi has many of the best accessories and one that is sure to appear on that list is the new Camera Module 3. In our Raspberry Pi Camera Module 3 review, we said that we love the fast autofocus and HDR images and we want to share these features with you in this how to. 

If you have never used a Raspberry Pi camera before, our beginner's guide to Picamera2 is a great primer to get your Pi taking great pictures. In this how to, we shall explore the many ways that we can use the Camera Module 3’s focus system with Picamera2 and learn how to take HDR images with a quick and simple script that automates the process. If Python isn’t your thing then the Camera Module 3 can also be controlled using libcamera via the terminal.

Getting to Know Autofocus

Autofocus has three modes in which it operates.

• Manual: Requiring the user to specify the LensPosition control to alter the focus of the lens. A value of zero will produce an infinite focus. Values up to 10 are accepted with 10 setting the focus to 1/10 of a meter (10CM).
• Auto: The typical autofocus which uses AfTrigger to start an autofocus cycle.
• Continuous: The camera will hunt for a target, refocusing on the target when the algorithm detects it.

Project 1: Using Continuous Focus

Continuous focus uses an algorithm to search the image stream for a target. It doesn’t matter if the target is near (around 10cm) or far, the algorithm will find the target and lock on. But how do we use it? Let's run a quick test. We’ll use a continuous focus mode to hunt for the best possible focus on our target. It would be useful to have an object that you can hold to the camera, we used a dollar bill.

1. From the main menu open Programming >> Thonny.

2. Import Picamera2.

from picamera2 import Picamera2

3. Import libcamera’s controls class. With this we can configure the camera to suit our requirements.

from libcamera import controls

4. Create an object, picam2 which we will use as a link between the code and our camera.

picam2 = Picamera2()

5. Start a preview window. The preview is where we see the output of the camera.

picam2.start(show_preview=True)

6. Set the AfMode (Autofocus Mode) to be continuous.

picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous})

7. Save the code as AFtest.py.

8. Click Run to start the code. A preview window will appear. Move an object, we chose a dollar bill, around the frame and watch as the focus shifts. Try moving the object nearer to the lens, remember that the nearest focus point is 10 centimeters.

Complete Code Listing

from picamera2 import Picamera2from libcamera import controlspicam2 = Picamera2()picam2.start(show_preview=True)picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous})

Project 2: Setting the Focus Manually

Sometimes a fixed focus is what we need to get that great shot. After all, we don’t want to capture a blurry mess. Fixing the focus is relatively straightforward; in fact it is so easy that we can reuse most of the code from the previous example.

1. Use Save As on the previous example to create a new file called ManualFocusTest.py

2. Change the last line to use LensPosition, in this case set the value to 0.0 for an infinite focus.

picam2.set_controls({"AfMode": controls.AfModeEnum.Manual, "LensPosition": 0.0})

3. Run the code. Notice how the focus is sharp for objects far away, but close up they are blurred.

4. Change the LensPosition value to 0.5. This will give us approximately a 50 cm focal distance.

5. Save and run the code. Move an object towards and from the camera. Notice how the focus becomes sharp around 50 cm.

Complete Code Listing

from picamera2 import Picamera2from libcamera import controlspicam2 = Picamera2()picam2.start(show_preview=True)picam2.set_controls({"AfMode": controls.AfModeEnum.Manual, "LensPosition": 0.5})

Project 3: Fast Focus for Multiple Images

Be it a bird cam, school sports day or home security, sometimes we need to get a series of sharp images. Luckily we can set the Camera Module 3 to take a series of rapid images and set the autofocus to high speed.

1. Create a new file called AfFastFocus.py

2. Import Picamera2.

from picamera2 import Picamera2

3. Import libcamera’s controls class. With this we can configure the camera to suit our requirements.

from libcamera import controls

4. Create an object, picam2 which we will use as a link between the code and our camera.

picam2 = Picamera2()

5. Start a preview window. The preview is where we see the output of the camera.

picam2.start(show_preview=True)

6. Set the autofocus mode to Continuous and set the AfSpeed to Fast.

picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous, "AfSpeed": controls.AfSpeedEnum.Fast})

7. Set the camera to capture three files, with a delay of half a second between each shot. The filename “fastfocus.jpg” will append 0, then 1 and 2 to each file. Giving us three files in numerical order.

picam2.start_and_capture_files("fastfocus{:d}.jpg", num_files=3, delay=0.5)

8. Close the preview window.

picam2.stop_preview()

9. Close the camera connection.

picam2.stop()

10. Save and run the code. Hold an object at three different distances to the camera and watch as the focus changes, the preview window freezes as the camera takes a shot, then releases for the next shot. Once three shots are taken, the preview window will close.

Complete Code Listing

from picamera2 import Picamera2from libcamera import controlspicam2 = Picamera2()picam2.start(show_preview=True)picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous, "AfSpeed": controls.AfSpeedEnum.Fast})picam2.start_and_capture_files("fastfocus-test{:d}.jpg", num_files=3, delay=0.5)picam2.stop_preview()picam2.stop()

Capturing an HDR Image With Picamera2

HDR (High Dynamic Range) images can be easily captured with libcamera. We just need to pass the –hdr argument when we run the command. But for Picamera2 we need to run a terminal command before we run our Python code. 

HDR increases the dynamic luminosity range of images. With HDR we get deeper darkness and brighter images. This works by capturing multiple images of the same scene, each with different exposures. These images are then combined into a single image which encompasses the entire range. Camera  Module 3 can capture HDR images, but not at the full 12MP resolution. Instead we get a 3MP image with a resolution of 2304 x 1296 pixels.

For our test we are going to reuse the code from the AfFastFocus.py project, to capture a series of HDR images. We will also use Python’s OS library to run a terminal command that will turn on and off the HDR setting with no user interaction. This means we will not forget to turn on and off the HDR settings.

1. Create a new file called HDRAfFastFocus.py

2. Import Picamera2.

from picamera2 import Picamera2

3. Import libcamera’s controls class. With this we can configure the camera to suit our requirements.

from libcamera import controls

4. Import the OS module. This enables our code to interact with the underlying operating system, in this case Raspberry Pi OS (Linux).

import os

5. Create an object, picam2 which we will use as a link between the code and our camera.

picam2 = Picamera2()

6. Use the system function from the os module to set the camera to use HDR. Picamera2 supports HDR, but not directly in the module. The issue is with V4L2, the kernel interface between the camera and the Linux video system. Right now, it does not offer ready support for HDR with this camera so we have to run this quick workaround to make it available in Picamera2.

7. Print a message to the Python Shell informing us that HDR is on.

print("Setting HDR to ON")

8. Start a preview window. The preview is where we see the output of the camera.

picam2.start(show_preview=True)

9. Set the autofocus mode to Continuous and set the AfSpeed to Fast.

picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous, "AfSpeed": controls.AfSpeedEnum.Fast})

10. Set the camera to capture three files, with a delay of one second between each shot. The filename “HDRfastfocus.jpg will append 0, then 1 and 2 to each file. Giving us three files in numerical order. We double the delay between each shot to give the camera time to save the previous image and then set the focus for the next image. We tested it with a 0.5 delay and our shots were sometimes a little too blurred.

picam2.start_and_capture_files("HDRfastfocus{:d}.jpg", num_files=3, delay=1)

11. Close the preview window.

picam2.stop_preview()

12. Close the camera connection.

picam2.stop()

13. Print a message to the user that HDR is now off, and then run the command using os.system.

print("Setting HDR to OFF")os.system("v4l2-ctl --set-ctrl wide_dynamic_range=0 -d /dev/v4l-subdev0")

14. Save and run the code. Hold an object at three different distances to the camera and watch as the focus changes, the preview window freezes as the camera takes a shot, then releases for the next shot. Once three shots are taken, the preview window will close.

Complete Code Listing

from picamera2 import Picamera2from libcamera import controlsimport ospicam2 = Picamera2()os.system("v4l2-ctl --set-ctrl wide_dynamic_range=1 -d /dev/v4l-subdev0")print("Setting HDR to ON")picam2.start(show_preview=True)picam2.set_controls({"AfMode": controls.AfModeEnum.Continuous, "AfSpeed": controls.AfSpeedEnum.Fast})picam2.start_and_capture_files("HDRfastfocus{:d}.jpg", num_files=3, delay=1)picam2.stop_preview()picam2.stop()print("Setting HDR to OFF")os.system("v4l2-ctl --set-ctrl wide_dynamic_range=0 -d /dev/v4l-subdev0")

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

The Raspberry Pi Pico is the ideal way to get into microcontrollers. Starting from $4, the board is cheap and easy to work with. The low cost and ease of use means we can easily drop them into a project without fearing the worst for our wallet.

In this how-to, we will use a Raspberry Pi Pico to capture live temperature data using a DS18B20. This sensor comes in many forms, from a bare transistor chip, to a water resistant cable. We’ll be using the latter version, which can be partially submerged in a liquid to monitor the temperature. Our project will take a temperature reading and using a conditional test in MicroPython it will trigger an LED to flash if the temperature goes below 20 degrees Celsius.

For This Project You Will Need

• Raspberry Pi Pico / Pico W
• DS18B20 Sensor
• LED
• 330 Ohm Resistor
• 4.7K Ohm Resistor
• 5 x Male to male jumper wires
• Breadboard

Building The Circuit

The circuit is made up of two parts. The DS18B20 temperature sensor, and the LED. We’ll break them down into two sections.

The DS18B20 has three connections to the Raspberry Pi Pico.

All three connections are made into the breadboard, and the wires are used to connect to the Pico. Between the data and 3V3 pins (yellow and red), there is a 4.7K Ohm resistor which is used to pull the data pin high using the 3.3V supplied. This maintains a steady connection between the data pin and Pico.

The LED has only two connections to the Raspberry Pi Pico.

The LED has a 330 Ohm resistor on the cathode leg, inline with GND. This reduces the amount of current that the LED can consume.

Writing the Code

1. Follow this guide to download and install the latest MicroPython release for your model of Raspberry Pi Pico. Follow the steps up to and including connecting the Raspberry Pi Pico to Thonny.

2. Create a new blank project in Thonny.

3. Import three modules of pre-written code. First is onewire, a module that enables the Pico to talk to the one-wire interface of the DS18B20. Next is ds18x20, a module that interprets the sensor data from the DS18B20 and provides us with human readable data. Lastly we import time which is used to pace our project code.

import onewire, ds18x20, time

4. From the Machine module import the Pin class. This will enable our code to interact with the components connected to the GPIO.

from machine import Pin

5. Create two objects, SensorPin and alert. SensorPin is the GPIO pin used to connect the data pin from the DS18B20 to the Pico. Alert is the GPIO pin that connects to the anode (long leg) of the LED.

SensorPin = Pin(26, Pin.IN)alert = Pin(15, Pin.OUT)

6. Create an object, sensor and use it to tell the ds18x20 module where to find our DS18B20 temperature sensor. This line also uses the onewire module, as that is the protocol that the sensor uses for connection.

sensor = ds18x20.DS18X20(onewire.OneWire(SensorPin))

7. Create an object, roms and use the sensor object to scan the interface to find our DS18B20 temperature sensor. All one-wire devices, such as our DS18B20, have a unique registration number stored in ROM that we need to identify before they can be used.

roms = sensor.scan()

8. Use a while True loop to run the next lines of code in a never ending loop.

while True:

9. Set the temperature reading to use Celsius. Note that the code within the while True loop is indented to show that it belongs in the loop.

   sensor.convert_temp()

10. Add a two second pause to the code. This gives the DS18B20 time to settle before we take a reading.

   time.sleep(2)

11. Use a for loop to iterate through the returned list of ROMs. As we only have one DS18B20 on the one-wire interface, only one ROM will be stored in the list that we iterate over.

   for rom in roms:

12. Create an object, temperature, and use it to store the output of reading the DS18B20 sensor. The output is wrapped in a round() function that will round the returned data to 1 decimal place.

       temperature = round(sensor.read_temp(rom),1)

13. Use a conditional test to check the value stored in the temperature object against a hard coded value. In this example, if the temperature is less than or equal to 20 Degrees Celsius then the condition will evaluate as True, and the next section of indented code will run.

       if temperature <= 20:

14. Print a message to the Python Shell that warns the user that the temper is below 20 C and include the temperature value in the sentence.

            print("Warning the temperature is",temperature,"C")

15. Use a for loop to blink the LED 10 times, with a 0.5 second delay.

           for i in range(10):               alert.toggle()               time.sleep(0.5)

16. Create an else condition that activates if the temperature is greater than 20 C. This condition will print the current temperature before ending.

       else:           print(temperature,"C")

17. Add a five second pause before ending the loop and returning back to the start of the loop.

   time.sleep(5)

18. Save the code to the Raspberry Pi Pico as TemperatureMonitor.py.

19. Click on the Run icon to start the code. After a short pause the temperature details will appear in the Python shell. If the temperature is below 20 C, the LED will blink five times to warn us.

Complete Code Listing

import onewire, ds18x20, timefrom machine import PinSensorPin = Pin(26, Pin.IN)alert = Pin(15, Pin.OUT)sensor = ds18x20.DS18X20(onewire.OneWire(SensorPin))roms = sensor.scan()print(roms)while True:   sensor.convert_temp()   time.sleep(2)   for rom in roms:       temperature = round(sensor.read_temp(rom),1)       if temperature <= 20:           print("Warning the temperature is",temperature,"C")           for i in range(10):               alert.toggle()               time.sleep(0.5)       else:           print(temperature,"C")   time.sleep(5)

NeoPixels are “candy” for makers. These bright, easily =-controllable RGB LEDs power signs, light shows and holiday decorations across the world. We’ve used NeoPixels with Python to make a Simon game, Node-RED and even BASIC.

We can control NeoPixels using Raspberry Pi, Arduino and Raspberry Pi Pico W (plus many more boards) and in this how to we will use CircuitPython on the Raspberry Pi Pico W. CircuitPython has a ready to go CircuitPython module that we can use to get up and running with very little code.

Our goal for this project is to create a holiday themed decoration which uses NeoPixels. How we control it is via the Cheerlights API. Cheerlights is a global network of synchronized lights. Sending a tweet to @cheerlights containing one of the supported colors will trigger our project to change color, but better than that, it changes the color of every Cheerlight across the globe.

Cheerlights supports the following colors. In the code we have converted these hex values into RGB for ease of use with CircuitPython’s NeoPixel module.

• red (#FF0000)
• green (#008000)
• blue (#0000FF)
• cyan (#00FFFF)
• white (#FFFFFF)
• oldlace (#FDF5E6)
• purple (#800080)
• magenta (#FF00FF)
• yellow (#FFFF00)
• orange (#FFA500)
• pink (#FFC0CB)

Building the Circuit

For This Project You Will Need

• A Raspberry Pi Pico W
• A half size breadboard
• Circular NeoPixels (7 Pixels)
• 3 x Male to male jumper wires
• 3D Printed plinth

The circuit is essentially just a NeoPixel ring connected to the Raspberry Pi Pico W’s GPIO. We take power from the 3.3V pin, connect GND and use GP0 as a data pin to control the NeoPixels.

Building the Decoration

We wanted to make this project a little special, so we designed a quick 3D print to celebrate a holiday season.

Using the same principle (but massively simplified) as we used for the Tufty 2040 badge holder, we created a basic layout using Inkscape and SVG files.

We then imported the project into Tinkercad and extruded the SVG to create a solid 3D object, then added a plinth to contain the graphics.

Lastly we cut sections from the rear to house our LEDs and wires. We got this wrong but the end result is not impaired.

We exported the design as an STL, then sliced it using Prusa Slicer for use with our Creality Ender 2 Pro, a low-cost printer which appears on our best 3D printers page.

Configuring CircuitPython

1. Go to the official CircuitPython page for the Raspberry Pi Pico W and download the latest release UF2 firmware image. At the time of writing this was CircuitPython 8 Beta 2.

2. Whilst holding the BOOTSEL button, connect the Raspberry Pi Pico W to your computer. A new drive, RPI-RP2 will appear.

3. Copy the downloaded CircuitPython UF2 file to RPI-RP2. This will write CircuitPython to the internal flash storage of the Pico W. A new drive, CIRCUITPY will appear.

We need a number of CircuitPython libraries before we can continue. These libraries of prewritten code add extra features to a project.

1. Download the bundle of libraries for the same version of CircuitPython as installed on the Pico W. We installed CircuitPython 8 so downloaded the bundle for version 8.x.

2. Extract the bundle to your desktop and then open the lib folder contained within.

3. Copy the following files / folders from this lib folder to the lib folder on the CIRCUITPY drive.

adafruit_pixelbuf.mpy

neopixel.mpy

adafruit_requests.mpy

Working with CircuitPython

1.  Download and install Thonny if you don’t have it already. Thonny is a Python editor which covers Python 3, MicroPython and CircuitPython.

2. Open Thonny and go to Tools >> Options.

3. Select Interpreter, then set the interpreter as CircuitPython, port to automatic, and click OK. Thonny will now connect to the Pico W running CircuitPython.

Our project code is made up of two files, secrets.py and code.py. The secrets.py file is essentially a Python module with two variables that will contain the SSID of our Wi-Fi access point, and the password. It is best practice to save your Wi-Fi details to a separate file called secrets.py, this reduces the risk of accidentally sharing your credentials. This process works for CircuitPython and MicroPython.

1. Create a new file and in there create two objects, ssid and password.

2. For the ssid object, assign it the name of your Wi-Fi access point / router.

ssid = “YOUR WI-FI AP NAME HERE”

3. For the password, assign the Wi-Fi password.

password = “YOUR SECRET PASSWORD”

4. Save the file to the CIRCUITPY drive as secrets.py.

Secrets.py Code Listing

ssid = "YOUR WI-FI AP NAME HERE"password = "YOUR SECRET PASSWORD"

The code for this project is contained in a file called code.py. This file will autorun when the Pico W is powered up, this is a feature of CircuitPython. In MicroPython we would name the file main.py to achieve the same result. We now start the process of writing the code that will make up our project.

1. Click on File >> Open and select the CircuitPython device. Open code.py on the CIRCUITPY drive. Delete any code in the file.

2. Import modules of pre-written code to handle pause (time) our code, set an IP address, use the Pico W’s Wi-Fi chip and to create web sockets.

import timeimport ipaddressimport wifiimport socketpool

3. Import five more modules for secure connections, to make web requests, a module with our Wi-Fi login details,a module to interact with the GPIO and finally the NeoPixel module.

import sslimport adafruit_requestsimport secretsimport boardimport neopixel

4. Create an object, pixel_pin to instruct the code as to where our NeoPixels are connected, then create another object to set the number of pixels.

pixel_pin = board.GP0num_pixels = 7

5. Use another object, pixels, to configure the NeoPixels connected to the GPIO. This object passes the GPIO pin and number of pixels, saved in the previous objects and we can set the brightness of the pixels. Consider 0.3 as a safe maximum brightness.

pixels = neopixel.NeoPixel(pixel_pin, num_pixels, brightness=0.1, auto_write=False)

6. Create an object, off to store a tuple that contains three integers, 0,0,0. These integers represent the mix of red, green and blue light that we use to make colors with NeoPixels. Three zeros represent no light, essentially turning them off.

off = (0,0,0)

7. Use the pixels object, and the value stored in off to turn off the NeoPixels, then use show to set the pixels to that “color” and pause for 0.1 seconds.

pixels.fill(off)pixels.show()time.sleep(0.1)

8. Create a function called “scare” and set it to accept an argument which will be the NeoPixel color.

def scare(color):

9. Create a dictionary inside the function called “colors” and in there store the name and RGB values for the Cheerlights colors. A Dictionary is a Python data storage object which uses keys to retrieve values. In this case the keys are the color names, and when they are called, they retrieve the RGB values that our NeoPixels use.

   colors = {"red":(255,0,0),             "green":(0,255,0),             "blue":(0,0,255),             "cyan":(0,255,255),             "white":(255,255,255),             "oldlace":(253,245,230),             "purple":(128,0,128),             "magenta":(255,0,255),             "yellow":(255,255,0),             "orange":(255, 165, 0),             "pink":(255, 192, 203)             }

10. Still inside the function create a conditional test that checks for the color, passed as an argument in the function, is present in the colors dictionary.

   if color in colors:

11. If the color is present we print the name of the color, and then set the NeoPixels to that color.

       print(colors[color])       pixels.fill(colors[color])       pixels.show()

12. If the code is not present, an error message is printed to the Python shell. This section ends the function code.

   else:       print("Sorry that color is not in the list")

13. Connect to the Wi-Fi using the ssid and password stored in the secrets module.

wifi.radio.connect(ssid=secrets.ssid,password=secrets.password)

14. Create a pool of sockets that we can use for connections and then create a new HTTP session to be used when making web requests.

pool = socketpool.SocketPool(wifi.radio)request = adafruit_requests.Session(pool, ssl.create_default_context())

15. Create a while True loop to run the main project code. This loop will continue for as long as the Pico W is powered on.

while True:

16. Create an object, feed, to store the JSON feed URL for the last color tweeted to Cheerlights.

   feed = request.get("http://api.thingspeak.com/channels/1417/field/1/last.json")

17. Print the last color to the Python shell. This is stored in the JSON object under “filed1”.

   print(feed.json()['field1'])

18. Call the scare function and pass the last color, from the JSON feed.

   scare(feed.json()['field1'])

19. Add a ten second pause to hold the NeoPixel color before the loop repeats.

   time.sleep(10)

20. Save the project to the Raspberry Pi Pico W as code.py. Click Run to start the code and watch the NeoPixels change color.

21. Use your Twitter account to send a tweet to @cheerlights, using one of the supported colors.

Complete Code Listing

import timeimport ipaddressimport wifiimport socketpoolimport sslimport adafruit_requestsimport secretsimport boardimport neopixelpixel_pin = board.GP0num_pixels = 7pixels = neopixel.NeoPixel(pixel_pin, num_pixels, brightness=0.1, auto_write=False)off = (0,0,0)pixels.fill(off)pixels.show()time.sleep(0.1)def scare(color):   colors = {"red":(255,0,0),             "green":(0,255,0),             "blue":(0,0,255),             "cyan":(0,255,255),             "white":(255,255,255),             "oldlace":(253,245,230),             "purple":(128,0,128),             "magenta":(255,0,255),             "yellow":(255,255,0),             "orange":(255, 165, 0),             "pink":(255, 192, 203)             }   if color in colors:       print(colors[color])       pixels.fill(colors[color])       pixels.show()   else:       print("Sorry that color is not in the list")wifi.radio.connect(ssid=secrets.ssid,password=secrets.password)pool = socketpool.SocketPool(wifi.radio)request = adafruit_requests.Session(pool, ssl.create_default_context())while True:   feed = request.get("http://api.thingspeak.com/channels/1417/field/1/last.json")   print(feed.json()['field1'])   scare(feed.json()['field1'])   time.sleep(10)

Python is a multi-purpose programming language. It does many things, from creating web apps to checking out who is on the International Space Station with a Raspberry Pi Pico W.
Python is easy to learn due to it being easy to read. What makes Python multi-purpose are modules of prewritten code, sometimes referred to as “libraries”. These modules bring in new functionality, for example RPi.GPIO enables Python to control the GPIO of the Raspberry Pi.

In this how to, we will use two Python modules to create a GUI application that will remove the background from an image. The first module, rembg from Daniel Gatis will remove the background from any image presented to it. The second module, easygui provides a means to create dialogs and menus using the operating system’s toolkit. So a file open / save dialog box will look exactly like those used in many other applications.

To take this project further, you can make your applications by packaging the project code into a single executable file.

Setting Up

Before we write a line of code we need to get everything in order. First we will create a folder to store the images that we will be working with. We will then open a Python editor for the coding part of the project.

1. Create a new folder on your desktop called rembg.

2. In the folder place an image that you wish to remove the background from.

3. Open your preferred Python editor, we prefer Thonny as it provides a simple user interface. Follow this guide to install Thonny.

Installing the Python Modules

In order to use Rembg we first need to download and install its Python module. This can be handled via Thonny’s built-in package manager, or via Python’s packaging tool, pip. 

Installing via Thonny

1. Click on Tools >> Manage Packages.

2. Search for rembg and click Search on PyPi. Select rembg from the returned list.

3. Click on Install to download and install rembg for Python. We have already installed rembg on our system, hence the uninstall button.

4. Repeat steps 2 and 3, but this time search for and install easygui.

Installing via Pip

If you are using another Python editor, you will need to install the Python packages using pip.

1. Open a Command Prompt and install rembg. Press Enter to start the process.

pip install rembg

2. Install easygui using pip. Easygui provides a basic user interface for file open and save operations.

pip install easygui

Writing the Code

The code is essentially very simple, with just eight lines of Python we can remove the background from any image. The underlying modules, rembg and easygui will be doing all of the heavy lifting for us.

1. From the rembg module import the remove class. This is what we shall use to remove the background.

from rembg import remove

2. From the Python Imaging Library (PIL), import Image. PIL is a powerful module that contains many different options for creating and working with images and image streams.

from PIL import Image

3. Import the easygui module and create a reference to it as “eg”. Easygui is our GUI for basic file operations. Renaming it to “eg” makes it easier to work with.

import easygui as eg

4. Create an object, input_path and use it to store the path and name of a file that we wish to remove the background from. Using easygui’s file open dialog box, we give the dialog a title, to explain what it is for. The chosen file and its path are stored to the input_path object.

input_path = eg.fileopenbox(title='Select image file')

5. Create an object, output_path and use easygui’s file save dialog box to capture the file path and save it to the object.

output_path = eg.filesavebox(title='Save file to..')

6. Create an object, input and use it to open and store the image via PIL’s Image.open function.

input = Image.open(input_path)

7. Use rembg to remove the background from the image.

output = remove(input)

8. Save the new image using the file path stored in output_path.

output.save(output_path)

9. Save the code as background_remover.py.

10. Run the code by clicking on the Run button.

11. Select the image that you wish to remove the background from. Notice that the dialog has the title that we specified in the code.

12. Navigate to the rembg folder and give the file a name and set the file format to PNG. Click Save. In our example we save the file as les-no-bg.png.

13. You may encounter an error, but this is to be expected. Download the u2net file and save it to .u2net folder in your user directory. This folder is automatically created and stored.

14. Go back to Step 10 and re-run the code. There will be no error this time so skip step 13.

15. Go to the rembg folder and your image is now ready for use.

Complete Code Listing

from rembg import removefrom PIL import Imageimport easygui as eginput_path = eg.fileopenbox(title='Select image file')output_path = eg.filesavebox(title='Save file to..')input = Image.open(input_path)output = remove(input)output.save(output_path)

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

The Raspberry Pi Pico certainly put the cat amongst the pigeons in 2021, but it was missing one key feature, Wi-Fi. Sure we can hack our own solution but we had to wait until mid 2022 for Raspberry Pi to announce the Raspberry Pi Pico W in order to get official support.

The Raspberry Pi Pico W was released with a robust MicroPython firmware, but CircuitPython, our favorite microcontroller Python release, was sadly missing support. It may have taken a few months but down to the hard work of @jeffepler we now have CircuitPython 8 Beta 2 which offers Wi-Fi support for the Pico W, while retaining the familiar CircuitPython ecosystem.

To celebrate this milestone we put together a project to highlight CircuitPython on the Raspberry Pi Pico W. We’ll be working with live data from an RSS news feed, converted to JSON and then displayed on a tiny OLED screen.

Building the Circuit

For this project you will need

• A Raspberry Pi Pico W
• 128 x 32 0.91 inch OLED
• 4.7K Ohm Resistors
• Half Breadboard
• Male to male jumper wires

The circuit is essentially just the OLED screen connected to the Raspberry Pi Pico via an I2C connection. The only addition to the circuit are two 4.7K Ohm resistors which connect to the + rail and the SDA and SCL pins of the Pico. This rail is connected to 3.3V, and the resistors are used to pull the pins high, ready for sending and receiving data.

The connections are as follows

Configuring CircuitPython

1. Go to the official CircuitPython page for the Raspberry Pi Pico W and download the latest release UF2 firmware image. At the time of writing this was CircuitPython 8 Beta 2.

2. Whilst holding the BOOTSEL button, connect the Raspberry Pi Pico W to your computer. A new drive, RPI-RP2 will appear

3. Copy the downloaded CircuitPython UF2 file to RPI-RP2. This will write CircuitPython to the internal flash storage of the Pico W. A new drive, CIRCUITPY will appear.

We need a number of CircuitPython libraries before we can continue. These libraries of prewritten code add extra features to a project.

1. Download the bundle of libraries for the same version of CircuitPython as installed on the Pico W. We installed CircuitPython 8 so downloaded the bundle for version 8.x.

2. Extract the bundle to your desktop and then open the lib folder contained within.

3. Copy the following files / folders from this lib folder to the lib folder on the CIRCUITPY drive.

adafruit_bitmap_font

adafruit_display_text

adafruit_displayio_ssd1306.mpy

adafruit_requests.mpy

Working with CircuitPython

1. Download and install Thonny if you don’t have it already. Thonny is a Python editor which covers Python 3, MicroPython and CircuitPython.

2. Open Thonny and go to Tools >> Options.

3. Select Interpreter, then set the interpreter as CircuitPython, port to automatic, and click OK. Thonny will now connect to the Pico W running CircuitPython.

Our project code is made up of two files, secrets.py and code.py. The secrets.py file is essentially a Python module with two variables that will contain the SSID of our Wi-Fi access point, and the password. It is best practice to save your Wi-Fi details to a separate file called secrets.py, this reduces the risk of accidentally sharing your credentials. This process works for CircuitPython and MicroPython.

1. Create a new file and in there create two objects, ssid and password.

2. For the ssid object, assign it the name of your Wi-Fi access point / router.

ssid = “YOUR WI-FI AP NAME HERE”

3. For the password, assign the Wi-Fi password.

password = “YOUR SECRET PASSWORD”

4. Save the file to the CIRCUITPY drive as secrets.py.

Secrets.py Code Listing

ssid = "YOUR WI-FI AP NAME HERE"password = "YOUR SECRET PASSWORD"

The code for this project is contained in a file called code.py. This file will autorun when the Pico W is powered up, this is a feature of CircuitPython. In MicroPython we would name the file main.py to achieve the same result. We now start the process of writing the code that will make up our project.

1. Click on File >> Open and select the CircuitPython device. Open code.py on the CIRCUITPY drive. Delete any code in the file.

2. Import modules of pre-written code to handle pause (time) our code, set an IP address, use the Pico W’s Wi-Fi chip and to create web sockets.

import timeimport ipaddressimport wifiimport socketpool

3. Import four more modules for secure connections, to make web requests, a module with our Wi-Fi login details and a module to interact with the GPIO.

import sslimport adafruit_requestsimport secretsimport board

4. Import the final group of modules for accelerated bus access, a display library, a terminal style text module, scrolling text, and a driver for the OLED display.

import busioimport displayioimport terminaliofrom adafruit_display_text.scrolling_label import ScrollingLabelimport adafruit_displayio_ssd1306

5. Release the display for CircuitPython to use it and then specify the GPIO pins used for I2C.

displayio.release_displays()i2c = busio.I2C(board.GP1, board.GP0)

6. Specify the I2C interface and I2C address for the OLED screen on the display bus and then use that to create a display object. Don’t forget to set the width and height to match your OLED display. To find the I2C address of the OLED display, consult its datasheet or use an I2C scanner to search for it.

display_bus = displayio.I2CDisplay(i2c, device_address=0x3C)display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=32)

7. Connect to the Wi-Fi using the ssid and password stored in the secrets module.

wifi.radio.connect(ssid=secrets.ssid,password=secrets.password)

8. Create a pool of sockets that we can use for connections and then create a new HTTP session to be used when making web requests.

pool = socketpool.SocketPool(wifi.radio)request = adafruit_requests.Session(pool, ssl.create_default_context())

9. Create a while True loop to run the main project code. This loop will continue for as long as the Pico W is powered on.

while True:

10. Create a banner, and save it to toms object.The Banner is a string of * followed by  “Tom’s Hardware News” then a further 10 more *.

toms = "*"*10+" Tom's Hardware News"+"*"*10

11. Create an object to handle scrolling the text stored in the toms object. The animate time handles the scrolling speed, scale is used to increase the text size, with 3 being the largest available for our 128x32 screen.

my_scrolling_label = ScrollingLabel(terminalio.FONT, text=toms, max_characters=20, animate_time=0.1, scale=3)

12. Set the position of the text (horizontal, x and vertical, y).

my_scrolling_label.x = 10my_scrolling_label.y = 10

13. Show the text on the OLED display.

display.show(my_scrolling_label)

14. Use a for loop to scroll the banner across the screen. We use the length of the text stored in the toms object, minus six to create a pleasant scroll. This will need to be tweaked to suit your banner text.

for i in range(len(toms)-6):        my_scrolling_label.update()        time.sleep(0.1)

15. Create an object, feed to store the URL of the JSON feed that contains the news headlines. We used rss2json.com to convert the Tom’s Hardware RSS feed into JSON, which can be easily worked with in CircuitPython.

feed = request.get("https://api.rss2json.com/v1/api.json?rss_url=https%3A%2F%2Fwww.tomshardware.com%2Ffeeds%2Fall")

16. Use a for loop to retrieve the first five stories from the feed.

for story in range(5):

17. Print the story’s headline to the Python shell.

print(feed.json()['items'][story]['title'])

18. Update the scrolling text to scroll the headline, with a buffer of 20 blank spaces before the text and a scale (text size) of 2.

my_scrolling_label = ScrollingLabel(terminalio.FONT, text=" "*20+str(feed.json()['items'][story]['title']), max_characters=20, animate_time=0.1, scale=2)

19. Set the position of the text (horizontal, x and vertical, y).

my_scrolling_label.x = 10my_scrolling_label.y = 10

20. Show the text on the OLED display.

display.show(my_scrolling_label)

21. Use another for loop to scroll the headline text. The iterations in the loop are set by the length of the headline, plus 21 characters to create a buffer.

for i in range(len(feed.json()['items'][story]['title'])+21):            my_scrolling_label.update()            time.sleep(0.1)

22. Finally add a sleep of 30 minutes, (1800 seconds) to set the Pico W to check for new headlines every half hour.

time.sleep(1800)

23. Save the project as code.py to CIRCUITPY and click Run to test start the code.

You should see the OLED screen come to life and scroll a banner, then the news headlines. As we saved the project to the code.py file, this code will autorun when the Pico W is powered up.

Complete Code Listing

import timeimport ipaddressimport wifiimport socketpoolimport sslimport adafruit_requestsimport secretsimport boardimport busioimport displayioimport terminaliofrom adafruit_display_text.scrolling_label import ScrollingLabelimport adafruit_displayio_ssd1306# Setup the displaydisplayio.release_displays()i2c = busio.I2C(board.GP1, board.GP0)display_bus = displayio.I2CDisplay(i2c, device_address=0x3C)display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=32)wifi.radio.connect(ssid=secrets.ssid,password=secrets.password)pool = socketpool.SocketPool(wifi.radio)request = adafruit_requests.Session(pool, ssl.create_default_context())while True:    toms = "*"*10+" Tom's Hardware News"+"*"*10    my_scrolling_label = ScrollingLabel(terminalio.FONT, text=toms, max_characters=20, animate_time=0.1, scale=3)    my_scrolling_label.x = 10    my_scrolling_label.y = 10    display.show(my_scrolling_label)    for i in range(len(toms)-6):        my_scrolling_label.update()        time.sleep(0.1)    feed = request.get("https://api.rss2json.com/v1/api.json?rss_url=https%3A%2F%2Fwww.tomshardware.com%2Ffeeds%2Fall")    for story in range(5):        print(feed.json()['items'][story]['title'])        my_scrolling_label = ScrollingLabel(terminalio.FONT, text=" "*20+str(feed.json()['items'][story]['title']), max_characters=20, animate_time=0.1, scale=2)        my_scrolling_label.x = 10        my_scrolling_label.y = 10        display.show(my_scrolling_label)        for i in range(len(feed.json()['items'][story]['title'])+21):            my_scrolling_label.update()            time.sleep(0.1)    time.sleep(1800)

When Raspberry Pi OS moved from being based on Debian Buster, to Bullseye, the transition wasn’t the smoothest. For many years Raspberry Pi OS used three tools to access the official Raspberry Pi camera. The first two were raspistill / raspivid, which offered control and access to the camera via the Linux terminal. 

It was a powerful and flexible means to work with the camera, both could produce video effects and stream video with no extra work. The other means was a community created project called PiCamera. Originally created by Dave Jones, Picamera grew from a community project into an essential tool. Picamera offered a purely Python means to interact with the camera, and being based on Python it also meant that we could mix the camera into our projects.

With the move to Bullseye, we saw Picamera sadly break. Raspberry Pi LTD even went as far as to offer a “legacy” version of Buster with Picamera and security updates. This was a stop-gap measure while its developers worked on Picamera2. With the September 2022 release of Raspberry Pi OS we now have a working Picamera2 module that we can use in our projects.

In this how-to we shall learn how to use Picamera2’s rather splendid API [pdf] to capture images, record video, and work with the GPIO to react to input as a means to capture an image. This how-to is compatible with all models of the official Raspberry Pi camera, including the Raspberry Pi Camera Module 3 which now comes with autofocus, HDR and a 110 degree wide angle lens.

 For the projects you will need 

• A Raspberry Pi (3B+, 4 or Zero 2 W are best)
• An official Raspberry Pi camera
• A mini breadboard
• A button
• 2x female to male wires

Connecting your Raspberry Pi Camera

The Raspberry Pi camera has been part of the best Raspberry Pi accessories for almost as long as the Pi has been with us. Nearly every model of Raspberry Pi has a camera (CSI) connector (the exception being the first model of Raspberry Pi Zero) and this meant that the camera rapidly became the must have accessory for your Pi. The same is still true, thanks to the official HQ camera offering much better image quality and a series of interchangeable lenses.

Connecting any official camera to the Raspberry Pi is easy to do, just follow these steps.

 1. Set up a Raspberry Pi if you don't have one already. See our guide on how to set up a Raspberry Pi. 

2.  With the Raspberry Pi powered off, lift the tabs of the CSI port. 

3. Insert the cable with the blue tab facing the USB / Ethernet port.

4. Gently slide the tabs down to lock the cable in place.

5. Secure / mount the camera so that it does not flop over and touch the Pi or its GPIO. One method is to use modelling clay / blu tack. 

Installing Picamera2 software

1. Boot the Pi.

2. Open a terminal and update the installed software.

sudo apt updatesudo apt upgrade -y

3. Install the Picamera2 Python3 module. For the latest Raspberry Pi OS releases (September 2022 onwards) it comes pre-installed, but this command will also update your version to the latest release.

sudo apt install -y python3-picamera2

Taking a Photograph with Picamera2

Taking a photograph with Picamera2 is the most basic task that you can perform with the module. By design, it has been created to be simple to use, but underneath the simplicity is a complex module that we can tweak to suit our needs.

In this project we shall capture an image, using a preview to frame the shot.

1. Open Thonny. You can find it in the main menu.

2. In a new file, import the Picamera2 module, along with the preview class. On a new line, import the time module. The Picamera2 module will provide us with control of the camera and time is used to control how long the preview image will remain on screen.

from picamera2 import Picamera2, Previewimport time

3. Create an object, picam2, which is used to reference the Picamera2 module and control the camera.

picam2 = Picamera2()

4. Create a new object, camera_config and use it to set the still image resolution (main) to 1920 x 1080. and a “lowres” image with a size of 640 x 480. This lowres image is used as the preview image when framing a shot.

camera_config = picam2.create_still_configuration(main={"size": (1920, 1080)}, lores={"size": (640, 480)}, display="lores")

5. Load the configuration.

picam2.configure(camera_config)

6. Start the preview window and then start the camera.

picam2.start_preview(Preview.QTGL)picam2.start()

7. Pause the code for two seconds.

time.sleep(2)

8. Capture an image and save it as test.jpg.

picam2.capture_file("test.jpg")

9. Save the code as camera-test.py and click Run to start. A preview window will appear, use this to frame your shot. If two seconds is too short a delay, change the delay to meet your needs.

10. Open the system File Manager and double click on test.jpg to view the image.

Complete Code Listing

from picamera2 import Picamera2, Previewimport timepicam2 = Picamera2()camera_config = picam2.create_still_configuration(main={"size": (1920, 1080)}, lores={"size": (640, 480)}, display="lores")picam2.configure(camera_config)picam2.start_preview(Preview.QTGL)picam2.start()time.sleep(2)picam2.capture_file("test.jpg")

Recording a Video with Picamera2

HD video recording is something that we now take for granted. The same is true for the Raspberry Pi thanks to numerous models of official (and unofficial) cameras. With Picamera2 we can record video at various resolutions using different encoders.

In this project we will show how to record a simple 1080P video stream, while previewing the stream in a lower resolution window.

1. Open Thonny and create a new file. You can find Thonny on the main menu.

2. Import the H264 encoder from the Picamera2 module.

from picamera2.encoders import H264Encoder

3. Import the Picamera2 module, along with the preview class. Next import the time module.

from picamera2 import Picamera2, Previewimport time

4. Create an object, picam2, which is used to reference the Picamera2 module and control the camera.

picam2 = Picamera2()

5. Create a new object, video_config and use it to set the still image resolution (main) to 1920 x 1080. and a “lowres” image with a size of 640 x 480. This lowres image is used as the preview image when framing a shot.

video_config = picam2.create_video_configuration(main={"size": (1920, 1080)}, lores={"size": (640, 480)}, display="lores")

6. Load the configuration.

picam2.configure(video_config)

7. Set the bitrate of the H264 encoder.

encoder = H264Encoder(bitrate=10000000)

8. Set the output file to test.h264. This will create a file containing the video.

output = "test.h264"

9. Start the preview window, then start recording using the encoder settings and saving the video to the output file.

picam2.start_preview(Preview.QTGL)picam2.start_recording(encoder, output)

10. Use a sleep to record ten seconds of video. The previous recording command is not a blocking line of code. Using a sleep command, we keep the recording from stopping after a fraction of a second.

time.sleep(10)

11. Stop the camera recording and close the preview window.

picam2.stop_recording()picam2.stop_preview()

12. Save the code as video-test.py and click Run to start. The preview window will appear and you have ten seconds to record a video.

13. View the video.You can get there in the File Manager by locating test.h264. And double-clicking on the video file to play it in VLC. 

Complete Code Listing

from picamera2.encoders import H264Encoderfrom picamera2 import Picamera2, Previewimport timepicam2 = Picamera2()video_config = picam2.create_video_configuration(main={"size": (1920, 1080)}, lores={"size": (640, 480)}, display="lores")picam2.configure(video_config)encoder = H264Encoder(bitrate=10000000)output = "test.h264"picam2.start_preview(Preview.QTGL)picam2.start_recording(encoder, output)time.sleep(10)picam2.stop_recording()picam2.stop_preview()

Using a Trigger to Take a Picture on Raspberry Pi

Camera triggers are a classic Raspberry Pi project. They are used to capture images / video of animals, intruders or to prank unwilling family members. A trigger can be a sensor such as a Passive Infrared (PIR) movement sensor, an ultrasonic sensor, or in our case, a simple push button.

In this project we will create a simple trigger activated camera trap. We press the button, frame the shot using the preview window, and the file then automatically saves to our Pi using the current time and date as a filename.

The wiring for this project is simple. The button is connected to GPIO17 and GND via a breadboard and two female to male wires.

1. Open Thonny and create a new file. You can find Thonny on the main menu. 

2. Import the Picamera2 module, along with the preview class. Next import the time module.

from picamera2 import Picamera2, Previewimport time

3. Import the datetime, GPIO Zero and Signal modules. Datetime is used to generate a timestamp for our image filenames. GPIO Zero is used for a simple button interface. Signal is used to stop the Python code from exiting.

from datetime import datetimefrom gpiozero import Buttonfrom signal import pause

4. Create an object, picam2, which is used to reference the Picamera2 module and control the camera.

picam2 = Picamera2()

5. Create an object, button, and use the object to store the GPIO pin to which our button is connected.

button = Button(17)

6. Create a new object, camera_config and use it to set the still image resolution (main) to 1920 x 1080. and a “lowres” image with a size of 640 x 480. This lowres image is used as the preview image when framing a shot.

camera_config = picam2.create_still_configuration(main={"size": (1920, 1080)}, lores={"size": (640, 480)}, display="lores")

7. Load the configuration.

picam2.configure(camera_config)

8. Create a function, capture(), to store a series of commands that will be run when the trigger is pressed. Code inside of the function is automatically indented to show that it belongs to the function.

def capture():

9. Start a preview window. This will enable us to frame our image.

   picam2.start_preview(Preview.QTGL)

10. Create an object, timestamp, and use it to store the time and date of the trigger event.

   timestamp = datetime.now().isoformat()

11. Start the camera, then pause for two seconds to allow time to frame the image.

   picam2.start()   time.sleep(2)

12. Set the capture file, ultimately the image file, to use the current timestamp as the filename.

   picam2.capture_file('/home/pi/%s.jpg' % timestamp)

13. Finally in the function stop the preview, and stop the camera.

   picam2.stop_preview()   picam2.stop()

14. Use GPIO Zero’s button class to react to a button press by calling our “capture” function. Finally use pause() to prevent the code from ending.

button.when_pressed = capturepause()

15. Save the code as trigger-test.py and click Run to start the code.

16. Press the button to start the camera, and to take an image.

17. Open the system File Manager and double click on the image to view.

Complete Code Listing

from picamera2 import Picamera2, Previewimport timefrom datetime import datetimefrom gpiozero import Buttonfrom signal import pausepicam2 = Picamera2()button = Button(17)camera_config = picam2.create_still_configuration(main={"size": (1920, 1080)}, lores={"size": (640, 480)}, display="lores")picam2.configure(camera_config)def capture():    picam2.start_preview(Preview.QTGL)    timestamp = datetime.now().isoformat()    picam2.start()    time.sleep(2)    picam2.capture_file('/home/pi/%s.jpg' % timestamp)    picam2.stop_preview()    picam2.stop()button.when_pressed = capturepause()

Raspberry Pi systems can bask in that new operating system glow today, with the launch of the latest edition of the tiny computer’s Debian-based OS. This release features many smaller tweaks, but the headline features seem to be an improved Python camera interface, and a simplified ability to easily make a Raspberry Pi into a wireless access point.

Behind the scenes, this means Pi OS has moved from using the easily edited but slightly obscure dhcphd file to manage networking to the NetworkManager application already used by other Linux distributions. It’s not the default yet, dhcphd is still there, but it will become so in future releases so we’d better get used to it. 

NetworkManager makes it easier to connect to Wi-Fi networks with hidden SSIDs, and smooths the process of dealing with VPNs. Some may find the ability granted by the app to configure your Pi as a wireless access point interesting too. It’s being considered a beta feature for now, and must be switched to using the raspi-config tool.

Elsewhere, the new Picamera2 Python library takes over from the original PiCamera (a community developed project which grew from a personal project) as the "Pythonic" means to interface a camera with your Pi. It is claimed to be easier to use, but differs from the older software. The libcamera library, which offers a command line interface via the terminal is still available for those not ready to PiCamera2.

Keyboard shortcuts, though not particularly exciting, can speed the use of a computer, and they’ve come under the microscope in this release. Bluetooth and Wi-Fi menus can now be accessed without using the mouse, and there are new audio input controls too - right-clicking the new mic icon in the taskbar gives you a level control, and you can switch between input devices too.

The new OS release is detailed in a blog post at the Raspberry Pi site, and can be obtained the usual way by downloading it from the appropriate page, or using the Raspberry Pi Imager tool.

Python is a glue. We can use it to join different elements of code together. As a language, Python is easy to learn, and human readable which makes it one of the most effective languages for learning and general purpose programming. Part of Python’s charm are the many modules of code which can be easily inserted into a project. 

Thonny is a powerful yet simple editor for Python and, with the release of version 4, we wanted to use it to create a project. In this how to we shall use the latest version of Thonny to create a web application that will pull Raspberry Pi stock data from rpilocator.com and use it to populate a table in our app.

RSS is a great way to share a stream of information. It can be used to serve news headlines, such as the Tom’s Hardware RSS feed or even the latest xkcd comic strip.

Nore that the RSS feed from rpilocator is not as up-to-date as the data on rpilocator.com. Think of this project as more of a notification system, than a “sniping” tool.

Installing Thonny 4.0

Thonny is the default Python IDE on the Raspberry Pi, but it is not limited to just that machine. Thonny is also available for Windows, Mac and Linux machines, and it can be used to write Python and MicroPython for devices such as the Raspberry Pi Pico W and ESP32.

1. Open a browser to the Thonny homepage.

2. Select the download for your OS. For Windows, there are a few options to choose from. The first choice is which version of Python, we would recommend the latest (3.10 at the time of writing). Next is your choice of installing Thonny to your machine, or using a portable version. We recommend installing Thonny to your machine.

3. Click on the downloaded file to start the installation.

4. Click on “More Info” to continue the installation. The new installation has a certificate that is relatively unknown and has yet to build up a reputation.

5. Click on “Run anyway” to continue.

6. Click next to continue.

7. Accept the License agreement.

8. Select the checkbox to create a desktop icon. This is an optional step, We chose not to do this as we prefer icons in the task bar.

9. Click Install to start the install process.

10. Click Finish to end the installation.

Creating Our Project with Thonny 4.0

Thonny is beginner focused, but don’t be fooled, Thonny is a competent and fully featured editor for makers. Thonny has a multi-window layout that can be edited to suit your needs.

1. Files: This is a basic file manager that can be used to open files in a project. Raspberry Pi Pico W and other MicroPython devices will open an additional pane that we can use to copy files to and from the device.

2. Coding Area: Here is where we create the project for our code. We can have multiple tabs, for multiple files.

3. Python Shell: The Python Shell (REPL, Read, Eval, Print, Loop) is where we can see the output of our code, and also interact with it.

4. Assistant: If your code has a bug, or doesn’t follow a styling guideline, it will be flagged here.

Installing Modules with Thonny

Python modules (sometimes also referred to as “libraries”) are pre-written segments of code that enable extra functionality. Popular examples include RPI.GPIO and GPIO Zero for the Raspberry Pi. Modules often abstract / simplify complex tasks. In our project we will use two modules. PyWebIO is a module to create HTML content using Python. It also creates a web server that we can use to quickly connect to our app. The second module is Feedparser, an RSS feed reader module that we shall use to read the rpilocator Raspberry Pi stock level feed.

1. Open Thonny and ensure that no projects are open.

2. Click on Tools >> Manage Packages. Thonny has a built-in GUI for the Python 3 package manager “pip”.

3. Search for pywebio.This is the module that we shall use to generate a web page using Python.

4. Click Install to download and install the module.

5. Repeat the previous steps, this time install feedparser. Feedparser is a Python module for RSS feeds.

6. Click Close to quit the dialog.

Writing the Project Code

Our goal is to create a Python project that will use the data from rpilocator’s RSS feed to populate a table. We will grab the current five entries and display them in an HTML table, created using Python.

1. In a new blank document, import two modules from pywebio. The first contains the code to start a simple web server. The pywebio.output module is used to generate HTML elements such as tables and hyperlinks.

from pywebio import start_serverfrom pywebio.output import *  

2. Import the feedparser module.

import feedparser

3. Create a function called main.

def main():

4. Inside the function create an object, “stock” and use it to store the parsed output of the rpilocator RSS feed.

   stock = feedparser.parse('https://rpilocator.com/feed/')

5. Create three empty lists, in_stock, in_stock_link and category. These will be used to store the data retrieved from the “stock” object containing the RSS data.

   in_stock = []   in_stock_link = []   category = []

6. Create a for loop that will iterate five times.

   for i in range(5):

7. Use “append” to add the stock status, link and category (reseller name) to the appropriate list. The RSS data stored in “stock” is a mixture of lists and dictionaries. For the data in a list we can use its numerical index, which is the value of i in our for loop. This will count from 0 to 4 as the for loop iterates. The data stored in a dictionary requires us to know the key (‘entries’ for example). Using the key will return its value.

       in_stock.append(stock['entries'][i]['title'])       in_stock_link.append(stock['entries'][i]['link'])       category.append(stock['entries'][i]['category'])

8. Outside of the for loop, create a pop-up notification using “toast”. The message can be a mixture of a strong, and even emojis.

   toast('🍓I found Raspberry Pi in stock!🍓')

9. Use “put_html” to write an HTML H1 heading element to the web page. We can use this function to write any HTML elements to the page, but do take note that the PyWebIO module has many different means to create specialist elements.

   put_html("
Raspberry Pi Stock
")

10. Create a list, “table” and use it to store two columns of data, taken from our in_stock, in_stock_link and category lists. The first row are the column headings Details and URL. In stock will print a brief description of what is in stock. Using “put_link” we create an HTML hyperlink, with the link text being the name of the reseller, stored in the category list, and the address stored in in_stock_link.

   table = [['Details','URL'],       [in_stock[0], put_link(category[0],url=in_stock_link[0])],       [in_stock[1], put_link(category[1],url=in_stock_link[1])],       [in_stock[2], put_link(category[2],url=in_stock_link[2])],       [in_stock[3], put_link(category[3],url=in_stock_link[3])],       [in_stock[4], put_link(category[4],url=in_stock_link[4])],       ]

11. Use PyWebIO’s “put_table” function to create an HTML table from our table object.

   put_table(table)

12. Use “put_link” to create a hyperlink under the table, in this case it takes us to the source of the Raspberry Pi stock levels, rpilocator.

   put_link('Data provided by RPiLocator',url='https://rpilocator.com')

13. Outside of the function, call PyWebIO’s “start_server” function, and pass it three arguments. The arguments are our “main” function which will create the table from the RSS data. The port is set to 8080, and debugging is enabled via the Python shell and on our web page.

start_server(main, port=8080, debug=True)

14. Save the code as RSS-Feed-Reader.py and click Run to start.

15. Click on the link in the Python shell to open the web page in your default browser.

Complete Code Listing

from pywebio import start_serverfrom pywebio.output import *    import feedparserdef main():   stock = feedparser.parse('https://rpilocator.com/feed/')   in_stock = []   in_stock_link = []   category = []   for i in range(5):       in_stock.append(stock['entries'][i]['title'])       in_stock_link.append(stock['entries'][i]['link'])       category.append(stock['entries'][i]['category'])   toast('🍓I found Raspberry Pi in stock!🍓')   put_html("
Raspberry Pi Stock
")   table = [['Details','URL'],       [in_stock[0], put_link(category[0],url=in_stock_link[0])],       [in_stock[1], put_link(category[1],url=in_stock_link[1])],       [in_stock[2], put_link(category[2],url=in_stock_link[2])],       [in_stock[3], put_link(category[3],url=in_stock_link[3])],       [in_stock[4], put_link(category[4],url=in_stock_link[4])],       ]   put_table(table)   put_link('Data provided by RPiLocator',url='https://rpilocator.com')start_server(main, port=8080, debug=True)

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

Update 7th August 2022: We've updated this article to include how to program the Explora in Python on page 2.

Original Tutorial Published June 4, 2022:

Building your own robot is one of the most satisfying things you can do. It combines mechanical, electrical, and programming skills together in a way few projects do.

I’ve been building robots for a couple of years now and love to expand my knowledge and skills by using different controller boards, motors, wheels, and sensors to detect the world around the robot.

Raspberry Pi robots are particularly impressive. The Raspberry Pi provides the robot with the full power of Linux and a plethora of Python libraries.  With all of this power, it means we can add advanced machine learning, computer vision, and Internet connectivity into the mix. All this at an affordable price point and tiny form factor too.

Building Raspberry Pi robots from kits, such as  Pimoroni’s Trilobot, or from a custom design such as Explora, is fun and helps develop skills such as programming in Python, mechanical design, and electronics. People love playing with robots and teaching them to perform tasks and move around the environment unaided.

Explora uses the Pimoroni Explorer pHAT (we included the Explorer HAT Pro in our best Raspberry Pi HATs guide) to control the motors and has a handy Python library to make this simple. Explora is programmed in Python and uses sensors to avoid obstacles and follow your handExplora can also be remotely controlled over Wi-Fi.

Explora can detect objects in front of it using an HC-SR04 ultrasonic range finder module. These modules come in either a 5v version or a 3.3v version (HCSR04+ or HC-SR04P). The Explorer pHAT is 5v tolerant, but it's best to get the HC-SR04+ or HC-SR04-P version to be on the safe side. Using the 5v version on a Raspberry Pi can damage the board.

Explora was designed using AutoDesk Fusion 360. Each piece is a discrete component to enable easier  3D printing. Fusion 360 makes it really easy to export the models into STL files, ready for slicing and then 3D printing. To slice the robot parts (creating the instructions for a 3D printer to print the part) from Fusion 360 I use Cura, and then upload it to OctoPrint to manage the print jobs. The 3D printed parts are designed to be quick and easy to print, and the whole thing is easy to assemble using a couple of screws and wire up.

My personal choice of 3D printer is the Creality Ender 3 Pro and Ender 3 V2.

The electronics for the project are relatively straightforward and involve some soldering. You will need to solder wires to each motor and then to some Male DuPont cables (jumper jerky), one set per motor. You’ll also need something to hold the motors while you solder the wires to the tiny motor connectors which can be a bit tricky if you’ve not done this before. Some “helpful hands” or modeling clay is useful to keep the wires in place.

What You Will Need

• A 3D printer and filament
• 8 x M3 10mm screws and nuts
• 4 x N20 Motors
• 1 x Pimoroni Explorer Hat
• 1 x Raspberry Pi Zero 2 W / Raspberry Pi Zero W
• USB Powerbank battery pack
• 400mm of red wire - solid core is preferable over the braided wire
• 400mm of black wire - solid core is preferable over the braided wire
• 8 x M2.5 Stand-offs (with male screw)
• 4 x M2.5 Stand-offs (without male screw)
• 8 x M2.5 Screws
• 4 x Moon buggy wheels
• 4 x Male to female Dupont cables (200mm)
• Some velcro straps for the battery pack
• SD Card for the Raspberry Pi Zero
• PIR Obstacle sensor

Tools

• Soldering iron
• Solder and some flux
• Screwdriver
• Wire cutters
• Wire strippers
• Helping hands - for use with soldering
• A computer with an SD card reader slot

3D Printed Files

• 1x Chassis
• 4x Motor holders
• 1x Camera Holder
• 1x Camera back
• 1x Top section

Building Explora

The print times for each of Explora’s parts depends on your specific printer and quality settings. I found the files took the following amount of time to print:

I prefer to use PLA+ for my prints and usually have some white or yellow filament already in each printer, ready to go.

To Prepare Explora’s 3D Printed Parts

1. Download the 3D printable STL files.

2. Slice the parts using Cura - We like to use Cura, but you are free to use an alternative. and don't forget to enable supports for the motor holders

3. Transfer the G-Code file from Cura to your 3D Printer. Save the G-Code file to an SD card (if that's how your 3D printer accepts files) alternatively you can use software such as OctoPrint that runs on a Raspberry Pi and presents a Web-based interface for managing 3D Print jobs. If you’re using OctoPrint you can drag the G-Code file over the left-hand side of the page and it will begin to upload the file, ready for printing.

4. Load the G-code and print - We used Octoprint to manage our print jobs

Wiring up Explora

Soldering is an essential maker skill. Learning to solder opens up the entire world of electronics and this project could be your first steps on an exciting journey. If your motors come without any wires attached you’ll need to prepare your own wires and solder these onto the tiny motors. Soldering small parts can be tricky; you will need a steady hand and something to hold the motors while you hold the solder in one hand and the soldering iron in the other.

• Prepare the wires for soldering. Cut four strips of red wire 100mm long each and another four strips of black wire. We should have a pair of black and red wires for each motor.
• Strip wires. Strip about 4mm of wire from each end, exposing the copper wire. A good pair of wire strippers is an essential part of a maker's toolbox.
• Add Flux. Apply some flux to one end of the wire that will be soldered. Flux helps the solder run around the part correctly. Even if your solder comes with a flux core, a little extra flux will make soldering much easier.
• Tin the wires by adding a small amount of solder to the wires with your soldering iron. Tinning will help the wires solder to the small motor terminals
• Solder the red wire onto the motor terminal - you’ll notice a small + sign above the terminal that is the positive terminal. Take your time, as this can be tricky if you’ve not done it before.
• Push the wire through the hole in the terminal first to make a good mechanical connection and will help hold the wire in place as you solder, then solder the wire to the terminal.
• Repeat the last step for the black wire but this time solder the black wire to the Negative terminal on the motor.
• Twist red and black wires for strength. This will help strengthen the connection if you accidentally tug on the wires.

9. Solder the 40 pin header and 20 pin header to the Explorer pHat

Assembly

The assembly part of the build won’t take long as it only involves screwing the four motor holders into the chassis using the M2.5 screw and nuts. Then we screw the standoffs into the chassis and Raspberry Pi Zero 2 W, and finally, we attach the Camera holders and top section.

1.Push each motor into a 3D printed motor holder. The motor holders ensure that the motor remains in place on Explora’s chassis. They also offer mechanical rigidity so that the motors do not move position in use.

2.Put a nut into each hexagonal pocket on the motor holder, then screw it from the top side of the chassis through to the motor holder into the nut. Don’t over-tighten as you’ll end up splitting the chassis. This will create a substantial connection between the motor holder and the chassis.

3.Add stand-offs to the chassis by screwing four M2.5 screws into the bottom of the chassis, and screw on a stand-off barrel onto the exposed screw thread until it becomes tight against the chassis.

4.Add four stand-offs to the Raspberry Pi Zero, then attach the Explorer pHat.

5.Screw the Raspberry Pi Zero into the Chassis stand-offs.

6.Push the Camera Holder into the Chassis. You may need to file off some material if it's a tight fit.

7.Push the ultrasonic rangefinder into the Camera Holder.

8.Push the female end of the DuPont wires onto the Rangefinder.

9.Push the male end of the DuPont wires onto Explorer pHATs 5v, GND, Output 1 to Trigger, Input 1 to Echo connections. 

10.Push the Camera back into the Chassis.

11.Add the last four stand-offs onto the Raspberry Pi Zero

12.Push the Top section over the two camera holders and screw the last 4 M2.5 screws from the top section into the standoffs

13.Using a velcro strap, secure the battery in place. 

14.Push the 4 wheels onto the ends of the motors. The motor axles are D-shaped, be sure to match the alignment of the axle to the wheel before firmly pushing on.

Preparing the Raspberry Pi

The Raspberry Pi needs a suitable OS to run the Python code to control the motors and optionally capture images. When the Raspberry Pi camera first launched a software library called PiCamera was provided to make it simple to capture stills and video. With the most recent release of Raspberry Pi OS ‘Bullseye’, this old library has been replaced with a library called LibCamera, which is not backward compatible with PiCamera. On the 32-bit release of Bullseye you can choose a legacy camera option from raspi-config, however, this option is not available on the 64bit release.

1. Using the official Raspberry Pi Imager tool, flash the latest 32-bit OS to a micro SD card. We use the 32-bit version of Raspberry Pi OS because the PiCamera library is currently not compatible with the 64-bit version of Raspberry Pi OS. 

2. Put the micro SD card into the SD card reader slot on your computer.

3. Select the micro SD card from the Raspberry Pi imager Storage menu.

4. Click the Advanced (cog) button, and add your Wi-Fi SSID and password details to enable the Raspberry Pi to connect to the wifi automatically.

5. Click on Enable SSH and create a username and password. SSH enables a remote to the Raspberry Pi using a terminal without the need for a monitor, keyboard, or mouse.

6. Click Write to begin flashing the image to the micro SD card.

7. Insert the micro SD card into the Raspberry Pi and then power up the Raspberry Pi via the power bank.

Connecting to the Pi

1.  Find out the IP address of your Raspberry Pi - you can usually do this from your router (or wherever your router gets its IP addresses from, or by typing:

ssh pi@raspberrypi.local

- where `pi` is the username you created earlier in step 5 above.

2. Launch Terminal - if you’re on Windows, you’ll need to use some terminal software such as Putty (https://www.putty.org). Mac and Linux computers have terminal build-in. 

3. SSH to the Raspberry Pi - Type `ssh pi@raspberrypi.local>` into the terminal to connect to the Pi. Linux / Mac users can use the following to SSH into the Pi. If you know the IP address you cal also type `ssh@`, where is the IP address of the Raspberry Pi.

ssh pi@raspberrypi.local

From the Raspberry Pi terminal, clone the Explora software repository. The software is on Github, and we can use the git clone command to download the latest version to our Raspberry Pi:

git clone https://www.github.com/kevinmcaleer/explora

4. Install the Explorer Library via Pimoroni’s online install script.

curl https://get.pimoroni.com/explorerhat | bash

4.From the Raspberry Pi terminal, clone the Explora software repository. The software is on Github, and we can use the git clone command to download the latest version to our Raspberry Pi:

curl https://get.pimoroni.com/explorerhat | bash

You should now have a fully assembled Explora robot on your desk, ready to receive your first Explora Python program. You can expand the capabilities of Explora by adding a LIDAR laser scanner and Raspberry Pi Camera such as the ones in the picture below.

Next, we create some programs for Explora in Python to move the robot around and detect objects.

Writing the project code

The board at the heart of our robot is the Pimoroni Explorer HAT. The Explorer HAT has been around since 2015 and it has been proven to be a reliable and easy to use platform for robotics. This is in part due to the Python 3 library and its corresponding documentation. The Explorer HAT Python 3 module provides several helper functions that we will use in our project. 

Explorer pHAT has a series of connections broken out along one side of the board. There are two physical motor connectors,each with a positive and negative connection. There are also four input pins and four output pins,and four analog inputs. Two 5 Volt outputs (labeled 5V) and two Ground connections (labeled GND) are there to provide power to components. 

These pins are all referred to in the Explorer HAT Python 3 module as:

Motorsexplorerhat.motor.oneexplorerhat.motor.twoInputsexplorerhat.input.oneexplorerhat.input.twoexplorerhat.input.threeexplorerhat.input.fourOutputsexplorerhat.output.oneexplorerhat.output.twoexplorerhat.output.threeexplorerhat.output.four

Motor functions

The Explorer HAT Python 3 module has several motor functions that we can call from within our code. The Documentation describes these as:

• invert() - Reverses the direction of forwards & backwards for this motor
• forwards(speed) - Turns the motor forwards at speed (default speed is 100%)
• backwards(speed) - Turns the motor backwards speed (default speed is 100%)
• speed(-100 to 100) - Turns the motor at the speed you specify, with -100 being full backwards to 100 being full forwards
• stop() - Stops the motor by setting the speed to 0

Detecting objects

Our robot uses a passive infrared (PIR) obstacle sensor module to detect objects. The sensor module has 3 pins:

• VCC
• Ground (GND)
• Signal 

The PIR module attaches to the front, underside section of the robot, and only costs around $3. It works by firing invisible infrared light and using it to detect obstacles. When an obstacle is detected, the signal pin changes state from low to high, and this change is used as a trigger in our code.. The range of the sensor can be tweaked using the potentiometer and can be set from 2 to 30 Centimeters. 

The PIR sensor attaches to the Explorer pHAT as follows

Controlling the Robot

Our robot has the sensor to “see” the world around it, but now we need to give it the intelligence to use that data as a means to navigate the world. Luckily this is made quite simple thanks to Explorer HAT’s abstracted Python 3 library.

1. Go to the main Raspberry Pi OS menu and select Programming >> Thonny. Thonny is the default Python editor for Raspberry Pi OS.

2. Create a new file and import the Explorer HAT Python 3 module as eh. By doing this we shorten the reference to the module and reduce the risk of a typo.

import explorerhat as eh

3. Import the sleep function from the time module. We will use this to control the duration of our motors.

from time import sleep

4. Create a new function to move the robot forward which takes one argument, the speed at which the motors should spin.. Functions are reusable blocks of code we can call from within our program. Functions take parameters, such as ‘speed’, that allow us to change values within our function’s code. In this example, the speed parameter will change the speed the motors spin when moving our robot forward. A speed of 0 will stop our robot.

def forwards(speed):

5. Print a message to the Python shell for debug purposes. This will print “Forward” to the shell, enabling us to debug any motor issues.

   print(“Forward”)

6. Set the motor connected to motor one to move forwards, motor two to backwards. Motor two is on the other side of the robot, and so to make the motor move in the same direction as motor one, we need to spin it backward.

  eh.motor.one.forwards(speed)  eh.motor.two.backwards(speed)

7. Create a new function to move the robot backward. This is essentially the same as forwards, but we reverse the motor directions.

def backwards(speed):   print("Backward")   explorer_hat.motor.one.backwards(speed)   explorer_hat.motor.two.forwards(speed)

8. Create a new function to spin the robot to the left. By moving both motors in the same direction it will spin the robot.

def turn_left(speed):   print("Left")   eh.motor.one.forwards(speed)   eh.motor.two.forwards(speed)

9. Create a new function to spin the robot to the right. We spin the motors in the opposite direction to the left, causing the robot to spin on the spot.

def turn_right(speed):   print("Right")   eh.motor.one.backwards(speed)   eh.motor.two.backwards(speed)

def stop():   print("Stop")   eh.motor.one.stop()   eh.motor.two.stop()

10. Create a loop that will continually run the robot code. We need this loop so that the code within the loop is continually checked.

while True:

11. Create a conditional statement that will check the obstacle sensor output by reading the state of input 1. When the sensor detects an obstacle, its state changes from 0 (low) to 1 (high). Our if condition trigger will activate when the sensor sends 1.

   if eh.input.one.read() == 1:

12. Stop the robot, then turn left at 100% speed. This will force the robot to stop moving, then spin to the left, searching for a path around an obstacle.

       stop()       turn_left(100)

13. Pause for half a second then stop spinning and add an additional half second sleep. The extra sleep will slow the code looping back to the start of the conditional test. If there were no sleep, the code would loop far too quickly, and our robot would become unpredictable.

       sleep(0.5)       stop()       sleep(0.5)

14. Add an else condition, which will move the robot forwards at full speed for five seconds. If there is no obstacle, en.input.one.read() will return 0 (low) and our robot will move forwards for five seconds before the loop repeats.

   else:       forwards(100)       sleep(5)

15. Save the code and click Run (green arrow on toolbar) to start the code. The robot will attempt to navigate the world. It is worth elevating your robot so that its wheels are lifted off of the ground. That way you are not chasing your robot around the room while debugging any issues.

Complete Code Listing

import explorerhat as ehfrom time import sleepdef forwards(speed):  print("Forward")  eh.motor.one.forwards(speed)  eh.motor.two.backwards(speed)def backwards(speed):   print("Backward")   eh.motor.one.backwards(speed)   eh.motor.two.forwards(speed)def turn_left(speed):   print("Left")   eh.motor.one.forwards(speed)   eh.motor.two.forwards(speed)def turn_right(speed):   print("Right")   eh.motor.one.backwards(speed)   eh.motor.two.backwards(speed)def stop():   print("Stop")   eh.motor.one.stop()   eh.motor.two.stop()while True:   if eh.input.one.read() == 1:       stop()       turn_left(100)       sleep(0.5)       stop()   else:       forwards(100)       sleep(5)

Checklist: What Have We Achieved?

Congratulations you’ve created a robot that can detect and avoid objects.

• How to download, slice and print the Explora 3D printable files.
• How to build and assemble all the parts.
• How to solder wires onto the motors.
• How to prepare the Raspberry Pi OS and install the Explorer Hat Python module.
• You’ve learned how to use the Pimoroni Explorer HAT Python module.
• You have created a control system that senses the real world and feeds this back to our program, steering the robot away from obstacles in its path.

Automating the code

To set the Python 3 robot code to run when the Raspberry Pi boots, all we need to do is follow our guide on running Python code at boot, and your robot will be truly autonomous.

Connecting our projects to the Internet just got a lot easier, and cheaper! The $6 Raspberry Pi Pico W, an upgrade on the original Raspberry Pi Pico, brought one great update: Wi-Fi. This upgrade, along with the $6 price, enables makers to harness the power of the RP2040 SoC for a plethora of Internet of Things applications. The Pico W also tops the list of our best RP2040 boards.

We’ve already covered how to pass data to and from a Raspberry Pi Pico W to another web service, Anvil. But what if you just want to collect some data and send it off into the world? There are many ways to do this, but the simplest has to be IFTTT. 

IFTTT (If This Then That) is a web service that can take data from many different inputs (Twitter, Home Automation, Google, Facebook etc) and send it to other services.

In this project we’ll use the most basic service, webhooks, to send an HTTP POST request from a Raspberry Pi Pico W to IFTTT’s service. On IFTTT we will create an applet that will intercept the webhook, and trigger a tweet to be sent on Twitter.

For this project you will need

• Raspberry Pi Pico W
• DHT11 Temperature Sensor
• Half Breadboard
• 3x Male to male jumper wires

The Temperature Sensor Circuit

Our circuit is simple, consisting of just the Raspberry Pi Pico W and a temperature sensor. The DHT11 is a low-cost four-pin temperature sensor which is ubiquitous in the maker community. Looking from the front (the blue “cage”), we connect to the Raspberry Pi Pico W as follows:

Pin 1: (Red Wire) Connect VCC to 3V3(OUT) of the Pico W.

Pin 2: (Yellow Wire) Connect Data out to GP4 of the Pico W.

Pin 3: No connection.

Pin 4: (Black Wire) Connect GND to GND of the Pico W.

Setting Up IFTTT

IFTTT (If This, Then That) is the conduit which links our Raspberry Pi Pico W to Twitter. IFTTT is a free service that offers a myriad of ways to connect different data services together.

We are going to create an applet which reacts to a webhook (a custom URL) sending data to IFTTT. Then IFTTT will add the data into a message that will be sent to our followers on Twitter.

1. In a browser visit IFTTT and login / create an account.

2. Click on Create.

3. Click on Add. This is our trigger event. If this happens, our applet starts. In our case if a webhook is sent from the Raspberry Pi Pico W.

4. Search for webhook, and then click on the webhook icon.

5. Click on Receive a web request. This is our request, sent from the Raspberry Pi Pico W.

6. Set the Event Name to Post_Tweet and then click Create Trigger.

7. Click on Then That Add. This is the outcome of our trigger, in this case a Tweet is sent.

8. Search for Twitter and then click on the Twitter icon.

9. Select Post a Tweet.

10. Check that the correct Twitter account is selected, you may have to link your Twitter account to IFTTT. Replace the tweet text with your own custom message. Linking your Twitter account to IFTTT is an automated process, which IFTTT will trigger and ask you to confirm.

11. Click on Add ingredient and select Value 1. Then finish the remainder of the message, in this case stating that the temperature is in degrees Celsius. Click Create Action to save. Ingredients are IFTTT’s way of adding extra information to our tweet by pulling the data from our custom URL.

12. Click Continue.

13. Review the applet details, check the notifications option to on, and click Finish when ready. Notifications enable us to debug the applet, should an issue occur.

The IFTTT Applet has been created, but we don’t yet have the webhook URL. This URL is what sends the temperature data from the Raspberry Pi Pico W to our IFTTT service. The URL requires our trigger (Post_Tweet) and an API key, unlocking IFTTT access.

1.Visit this link in a new browser tab / window.

2. Copy the Make a POST or GET web request link into notepad or a text editor. Your text will show a correct API key, for security reasons we have edited the text.

https://maker.ifttt.com/trigger/{event}/json/with/key/YOUR API KEY HERE

3. Remove /json and change {event} to Post_Tweet.

https://maker.ifttt.com/trigger/Post_Tweet/with/key/YOUR API KEY HERE

You now have a valid webhook URL which will link your Raspberry Pi Pico W to Twitter via IFTTT.

Setting up the Raspberry Pi Pico W

Our Raspberry Pi Pico W is acting as a data collection device. It connects to our Wi-Fi, and every hour takes a temperature reading. This is then sent to IFTTT using a custom webhook URL. IFTTT then sends the message to Twitter as per the applet we have just created. 

Our goal is now to install the latest MicroPython firmware release for our Raspberry Pi Pico W, then write a few lines of MicroPython code to connect to our Wi-Fi, take a temperature reading, and then send that data to IFTTT.

1. Follow this guide to download and install the MicroPython firmware, and setup Thonny.

2. Open Thonny and create a new file.

3. Import three modules of code. Network enables the Pico W to connect to a Wi-Fi network. Urequests is a version of requests, a means to work with web data, for MicroPython. DHT refers to the DHT11 temperature sensor used in the project.

import networkimport urequestsimport dht

4. Import two further modules of code. From the Time module, import the sleep function, we’ll use this to add a pause to the project. From the Machine module import Pin, this enables our code to interact with the GPIO.

from time import sleepfrom machine import Pin

5. Create an object, “sensor” which connects our code to the DHT11 connected via the GPIO. This object enables us to interact with the sensor connected on Pin 2, querying temperature data.

sensor = dht.DHT11(Pin(2)) 

6. Create an object “wlan” and use it to connect the code to the Wi-Fi on the Raspberry Pi Pico W, then turn the Wi-Fi on.

wlan = network.WLAN(network.STA_IF)wlan.active(True)

7. Connect your Pico W to your Wi-Fi access point using its SSID and password.

wlan.connect("SSID","PASSWORD")

8. Pause for five seconds before proceeding onward. This isn’t strictly necessary as the previous Wi-Fi connection is a blocking call that will either connect or fail, then release the block. This pause is present to allow a little extra leeway.

sleep(5)

9. Print the current status of the Wi-Fi connection. This will either be True for a successful connection, or False if it was unable to connect.

print(wlan.isconnected())

10. Add a loop to continually run the following code. A while True loop will continuously run the code until the Pico W is turned off. Note that the code following this line is indented to show that it is part of the loop.

while True:

11. Take a reading with the DHT11. We need to do this in order to get the raw data.

   sensor.measure()

12. Save the current temperature to an object, temperature.

   temperature = sensor.temperature()

13. Print the temperature to the Python Shell (REPL). This is useful to debug any issues. It should show the temperature each time the loop iterates.

   print(temperature)

14. Create an object, message, to store the unique webhook URL that we created earlier. At the end of the URL add ?value1= and ensure that this is contained between quotation marks “ “. Remember to add your unique IFTTT API key.

   message = "https://maker.ifttt.com/trigger/Post_Tweet/with/key/YOUR IFTTT API KEY HERE?value1="

15. To the same line, add the current temperature stored in the “temperature” object. Note that we need to convert the temperature from an integer / float into a string using the str() function. Your message line should now read as follows.

   message = "https://maker.ifttt.com/trigger/Post_Tweet/with/key/YOUR IFTTT API KEY HERE?value1="+str(temperature)

16. Post the message to Twitter using urequests.post. This essentially sends the data to IFTTT via the webhook URL, and IFTTT then sends it to Twitter.

   urequests.post(message)

17. Pause the code for one hour (3600 seconds) before allowing the loop to repeat. IFTTT has a rate limit of 25 tweets per day, so to have a constant feed of data we need to limit the tweets to one per hour. If you go over this limit, IFTTT disables the applet until the next day.

   sleep(3600)

18. Save the code to your Raspberry Pi Pico W as tweet_temp.py

Complete Code Listing

import networkimport urequestsimport dhtfrom time import sleepfrom machine import Pinsensor = dht.DHT11(Pin(2)) wlan = network.WLAN(network.STA_IF)wlan.active(True)wlan.connect("SSID","PASSWORD")sleep(5)print(wlan.isconnected())while True:    sensor.measure()    temperature = sensor.temperature()    print(temperature)    message = "https://maker.ifttt.com/trigger/Post_Tweet/with/key/YOUR IFTTT API KEY HERE?value1="+str(temperature)    urequests.post(message)    sleep(3600)

Testing and Running the Code

Before we properly deploy the project we need to test that the code works.

1. Click on the Run button, located in the top left corner of Thonny.

2. Check the output. You should see True, confirming we are connected to the Wi-Fi. Then the temperature should appear.

3. Visit your Twitter account and check that the message has been posted. This should take approximately 10 - 20 seconds to appear.

4. Click on Stop to stop the running code.

With the code successfully tested, we can now set the code to automatically run when the Raspberry Pi Pico W boots.

1. Save As the code to your Raspberry Pi Pico W as main.py. MicroPython (on any device) will look for main.py when it powers up. If present, the code inside this file is autorun.

2. Unplug the micro USB lead from the Pico W, then re-insert to force a reboot.

3. Check your Twitter account for the corresponding tweet.

The Raspberry Pi Pico W packs a ton of functionality into a very affordable package. For just $6 we get the same dual core Arm Cortex M0+ CPU running at 133 MHz, 264KB of RAM and 2MB of flash memory as the original Raspberry Pi Pico. But we also get a 2.4 GHz capable Wi-Fi chip, all in the same DIP package.

The inclusion of Wi-Fi is the biggest draw. We have a simple and cheap microcontroller, with enough horsepower to accomplish many projects typically reserved for more powerful and expensive Raspberry Pis, such as the Raspberry Pi 4 and the Raspberry Pi Zero 2 W.

Wi-Fi enables Internet of Things (IoT) projects and for that we need a secure and easy-to-use means to write projects. Step forward Anvil, which,  offers Pico W firmware that trivialises IoT projects and takes advantage of its uplink service. With Anvil and the uplink service, we can easily write code on the web that will interact with the $6 Wi-Fi enabled micro-controller.

In this how-to we shall write a project that enables two-way communication between the Raspberry Pi Pico W and Anvil’s servers in the cloud. We will send live sensor data from the Raspberry Pi Pico W to a web app on Anvil’s servers. We shall also send messages from the app to the Raspberry Pi Pico W, to be displayed on a small LCD display.

For this project you will need

• Raspberry Pi Pico W
• An I2C LCD display
• A DHT11 Temperature Sensor
• 4x Female to male jumper wires
• 3x Male to Male jumper wires
• 1x Half size breadboard

Building the Circuit for Anvil on a Pico W

The circuit for this project consists of one input device, a DHT11 temperature sensor, and one output, an LCD screen connected over I2C. The DHT11 will measure the temperature and humidity, which is then sent to Anvil to be displayed in a web app. The LCD screen will display short messages, typed into the same Anvil web app.

The DHT11 has four pins. Looking from the front (the blue “cage”) we connect to the Raspberry Pi Pico W as follows

Pin 1: (Red Wire) Connect VCC to 3V3(OUT) of the Pico W.

Pin 2: (Yellow Wire) Connect Data out to GP4 of the Pico W.

Pin 3: No connection.

Pin 4: (Black Wire) Connect GND to GND of the Pico W.

The LCD has four connections.

GND: (Black Wire) Connect to any GND on the Pico W.

VCC: (Red Wire) Connect to VBUS on the Pico W.

SDA: (Yellow Wire) Connect to I2C0 SDA on the Pico W.

SCL: (Orange Wire) Connect to I2C0 SCL on the Pico W.

Check your wiring before moving onwards.

Setting up the Raspberry Pi Pico W

Anvil uses a custom firmware image for the Raspberry Pi Pico W, an image which simplifies connecting the Pico W to Anvil’s services. The firmware is based on MicroPython, with the Pico W appearing as a USB drive with two files (boot.py and main.py). Before we can write any code for our project we first need to flash the custom firmware to the Pico W, and connect to our Wi-Fi.

1. Download the custom Raspberry Pi Pico W firmware from Anvil.

2. Push and hold the BOOTSEL button on the Pico, then connect to your computer using a micro USB cable. Release BOOTSEL once the drive RPI-RP2 appears on your computer.

3. Drag and drop the Anvil UF2 file onto the RPI-RP2 drive. The Raspberry Pi Pico will reboot and will now run MicroPython.

4. Open File Explorer and navigate to the new USB drive. Anvil’s firmware uses MicroPython, and presents itself as a USB drive, similar to CircuitPython.

5. Open boot.py in a text editor and change the values for WIFI_SSID and WIFI_PASSWORD to match your setup. Save and exit when done. This file contains all of the Python code which is run at boot. In this case, it will connect to our Wi-Fi AP and flash the Pico W’s onboard LED if there is no connection.

Your Raspberry Pi Pico W should now connect to your Wi-Fi and the onboard LED should stop blinking. A static LED means we are connected to the Wi-Fi and ready for our project.

Code for the Raspberry Pi Pico

1. Install Thonny on your computer if you haven’t done so already. Follow the steps in our article on how to set up a Raspberry Pi Pico W.  Thonny is an easy to use Python editor which has been configured to work with the Raspberry Pi Pico.

2. Create a new blank file in Thonny.

3. Open this link and copy the text from the page.

4. Save the file to the Raspberry Pi Pico as lcd_api.py

5. Create another blank file.

6. Open this link and copy the text from the page.

7. Save the file to the Raspberry Pi Pico as pico_i2c_lcd.py These two files enable the use of the I2C LCD screen with the Raspberry Pi Pico W.

8. Open main.py, found on the Raspberry Pi Pico W drive.

9. Delete the contents of main.py.

10. Import three modules of pre-written code. The first is anvil.pico and this enables our Pico W to connect to Anvil’s servers. Next, uasyncio creates an asynchronous scheduler on the Pico W, we need this for running concurrent functions in our code. The third module is machine, and from that we need the Pin (GPIO pins) and I2C classes to communicate with the GPIO and LCD screen.

import anvil.picoimport uasyncio as afrom machine import Pin, I2C

11. Import three more modules. The time module enables control over the pace of our code. The dht module is specific for the DHT11 (and DHT22) temperature sensor and acts as an easier means to get data from the sensor. The pico_i2c_lcd enables our code to use the LCD display.

from time import sleepimport dhtfrom pico_i2c_lcd import I2cLcd

12. Create an object, i2c, to create a connection from our code to the I2C bus. I2C0 has SDA at pin 0 and SCL at pin 1.

i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000)

13. Create an object I2C_ADDR to store the I2C address of the LCD display. This line of code will scan the I2C bus for the address and store it in the object.

I2C_ADDR = i2c.scan()[0]

14. Create an object, lcd, to make a connection between our code and the LCD display. This uses the i2c object, the I2C address, and sets the display to have 2 lines and 16 characters. There are screens with differing sizes, so adjust this to match your screen.

lcd = I2cLcd(i2c, I2C_ADDR, 2, 16)

15. Turn the LCD backlight on, and set the cursor to blink. The backlight is essential as the screen can be hard to read. The flashing cursor, that’s more of a retro vibe.

lcd.backlight_on()lcd.blink_cursor_on()

16. Create an object UPLINK_KEY, and for now store blank data. This is where our Anvil Pico Uplink key will be stored. We will get that information later.

UPLINK_KEY = " “

17. Create an object, sensor, to store a connection from our code to the DHT11 temperature sensor. Using this object we can interact with the DHT11 and get data.

sensor = dht.DHT11(Pin(2)) 

18. Use a Python decorator to instruct Anvil that the next function is callable from the Anvil web app. Decorators are a means to add additional functionality to a function, without impacting the function.

@anvil.pico.callable(is_async=True)

19. Create a function, dht11data which will work with the scheduler.

async def dht11data():

20. Take a reading with the DHT11. We need to do this in order to get the raw data. Note that we are now inside the function and our code is now indented to show that it belongs to the function.

   sensor.measure()

21. Create two objects, temp and hum to store the temperature and humidity readings from the DHT11. The round() function rounds the values to one decimal place.

   temp = round(sensor.temperature(),1)   hum = round(sensor.humidity(),1)

22. Create an object, data, which will store a string / sentence containing the temperature and humidity data using string formatting to insert the data into the sentence.

   data = ("Temperature: {}°C   Humidity: {:.0f}% ".format(temp, hum))

23. Print the sentence to the Python shell, and then use return to output the sentence for Anvil to read. These lines are the last for this function.

   print(data)   return data

24. Create another decorator, this time for a function that will show messages on the LCD screen. The message is passed as an argument to the function (message).

@anvil.pico.callable(is_async=True)async def show_message(message):

25. Use a for loop to flash the LCD backlight three times. This will get our attention for an incoming message. The backlight is simply turned on and off, with a short pause between each.

   for i in range(3):       lcd.backlight_on()       sleep(0.2)       lcd.backlight_off()       sleep(0.2)

26. Turn the backlight on. We need the backlight to see the text.

   lcd.backlight_on()

27. Write the message to the LCD display, and then pause for ten seconds. Long enough to read the message. Then clear the LCD display. This is the end of this function.

   lcd.putstr(message)   sleep(10)   lcd.clear()

28. Connect the Pico W to Anvil’s servers using your uplink key. We will get the key later in this project.

anvil.pico.connect(UPLINK_KEY)

29. Save the code as main.p

Anvil Code for Raspberry Pi Pico W

1. Go to the Anvil website and click on Start Building.

2. Sign in or sign up for a free account.

3. Create a new blank app.

4. Select Material Design Theme.

The Anvil editor is split into two sections. Design and Code. In the Design section we create the user interface for our app. In Code, we give the application the functionality that we require. We’ll start by adding elements to the app, and then we shall add functionality to the elements.

1. From the Toolbox, drag a Label tool and place it on “Drop title here.”

2. Change the label text via the text field in the properties menu.

3. Drag an image tool into the form. With this we can add a logo or image to our project.

4. From Properties, select Source and select the image for your application.

5. From the Toolbox, drag another label and place it under the image. This will become an instruction to the user.

6. Write an instruction to the user, in this case to write a message.

7. From the Toolbox, drag a text box and place it to the right of the “Write a message” label. Anvil will adjust the layout to accommodate the text box.

8. From the Toolbox, drag a space and place below the image, and above the label and text box. This spacer is used to add a little distance between the image and the app.

9. From the Toolbox, drag a button and place it next to the text box. This button will be used to “send” a message to the Raspberry Pi Pico W.

10. Change the button text via the Properties section. A simple “Show Message” is all we need as this button will trigger a function to send a message to the Pico W’s LCD screen.

11. Drag another label and place it under the previous elements. This label will show the DHT11 sensor data from the Pico W.

12. Change the name of the label to Temp. Anvil will auto insert “self.”. This will enable us to identify the correct label in Code, which will display our sensor data.

13. In Properties, scroll down to Text and click MORE. Then set the text to bold, and font size to 32pt.

14. In the Toolbox, click on More Components and drag the Timer into the form.

15. Using the Properties, set the timer to an interval of 3 seconds. This time is used to update the screen for our sensor data.

With the design now complete, our focus turns to the Code section which will bring the functionality to the project.

1. Double click on the SHOW MESSAGE button to open a split view code editor. The code which relates to the button is automatically highlighted.

2. Add a new line to the function which will call the “show message” function that we created on the Raspberry Pi Pico W. The function on the Pico W requires a message to be sent, and we get this by using the text from the text box. The anvil.server_call_s call will run the command, but we will see no output in the web app.

anvil.server.call_s("show_message",self.text_box_1.text)

3. Double click on the Timer element to edit its code.

4. Add two lines to the timer function. The first to create a variable, data, which will store the data sent using the “dht11data” function on the Pico W. The second sets the Temp label text to show the message from the Pico W.

   data = anvil.server.call_s("dht11data")   self.Temp.text = data

Linking Raspberry Pi Pico W to Anvil

Anvil has an “uplink” tool, which enables the Raspberry Pi Pico W (and the Raspberry Pi) to securely connect to Anvil’s servers and communicate between the Pico W and the web app.

1. On the left of the screen, click on the blue + and from the menu select Uplink.

2. Click on Enable server Uplink.

3. Copy the uplink key. Do not share this key with anyone else.

4. Open main.py in Thonny and paste in the Uplink key to the UPLINK_KEY variable. Click Save.

Running the Web Application

With both sides of the project complete, now we use Anvil’s Uplink to communicate between the Raspberry Pi Pico W and Anvil’s servers.

1. In Thonny, click on Run to start the code. It will take the Raspberry Pi Pico W a few moments to connect to the Wi-Fi, confirmation of which can be seen in the Python shell.

2. Go back to Anvil and click on Run to start the web app.

3. Type in a message, and click SHOW MESSAGE to send it to the Pico W. The LCD display will flash three times and then display the message. The current temperature and humidity will appear in the app.

Publishing the Application

Currently the application is only available to us. We can easily share the application by publishing it. But first we need to give our app a name, title, description and logo.

1. Click on My Apps / Material Design to open the Settings tab.

2. Give the application a name, title, description, and add an icon.

3. Click Publish.

4. Click Add Private URL and copy the URL. This URL is useful for sharing with friends and colleagues when testing the app.

5. Click the link to ensure that everything is working. Note that you will need to start the code on the Raspberry Pi Pico W.

6. Click Add Public link to create a public app.his link is easier to read . A public link can be used when you are ready to share the project on social media.

7. Click the link to test that it works. The code on the Raspberry Pi Pico W must also be running.

We now have a working web application running via a Raspberry Pi Pico W and Anvil’s servers.

Anvil, a popular web applications development tool has today announced a new toolkit developed for the recently released Raspberry Pi Pico W. The toolkit provides a means of communicating between a web application and a Raspberry Pi Pico W using nothing but Python.
This new toolkit brings secure IoT applications for the Wi-Fi enabled $6 microcontroller. Applications normally reserved for the more powerful, and hard to come by Raspberry Pi.

The magic which makes this possible is two-fold. A custom "Just Press Go" MicroPython UF2 firmware release and "Anvil Uplink", a two-way communication link between your physical project and Anvil's servers. Applications are written using pure Python via the Anvil online IDE and on the Raspberry Pi Pico W we write our code using MicroPython. The uplink enables transmission between the Pico W and Anvil's servers and via the online IDE we can easily create user interfaces to send messages to the Pico W, or receive data from the board. 

The "Just Press Go" firmware image is just that. We had access to a pre-release image and within minutes had our Raspberry Pi Pico W connected to the Wi-Fi and to Anvil's servers. Via this firmware we have a lot of opportunities for invention. The low cost Raspberry Pi Pico W can work with common sensors and components, enabling projects such as remote data collection and robotics. Now with Anvil we can create GUI web applications for these projects using a drag and drop layout editor and Python code.

Anvil founder Meredydd Luff explains that Anvil's firmware offers a more secure IoT experience "Anvil have added proper TLS security to the Pico firmware, including enabling server certificate validation and making use of the Pico's real-time clock to verify certificate validity. These changes have been contributed back to the Micropython and Pico SDK projects." 

The Anvil team have also been working on documentation for the Raspberry Pi Pico W toolkit and it can be found via Anvil's microsite. In just ten lines of code you can be controlling an LED on your Raspberry Pi Pico W from any location in the world. A few more lines and you can be collecting data from remote Pico W sensors, and displaying it all in your web browser.

Anvil is a versatile toolkit, from controlling a Raspberry Pi HQ camera, to controlling Lego Spike kits, it is great to see it adopt the newest microcontroller into its ecosystem.

With a low cost microcontroller, Anvil's new toolkit and a little imagination we can't wait to see what makers will do with this exciting new tech.

The release of the Raspberry Pi Pico W brings with it an interesting opportunity. In the past if we wanted to connect a Raspberry Pi to the world, we would need one of the larger models. The Raspberry Pi Zero 2 W, and Raspberry Pi 4 were often pressed into data collection duties. The Raspberry Pi 4 is a bit of a power hog, the Zero 2 W is a bit better but still overkill for a simple information project.

With the arrival of the Raspberry Pi Pico W we have a low power, microcontroller with a competent Wi-Fi chip, in the Pico form factor and only $6! 

So where do we start? How do we get our Raspberry Pi Pico W online, and where can we find interesting data to collect? Let us guide you through making the most of your $6 Raspberry Pi Pico W.

Getting the Raspberry Pi Pico W Online

The Raspberry Pi Pico W comes with an Infineon CYW43439 2.4 GHz Wi-Fi chip and onboard antenna. This means we get good Wi-Fi reception without the need for lots of wires. We’re using the latest MicroPython release for the Pico W as it offers the easiest means to get online and do fun projects.

1. Setup your Raspberry Pi Pico W by following our getting started guide. You will need to install MicroPython on your Pico W before you can proceed further.

2. Open the Thonny editor to a blank document.

3. Create an object called SSID and in it store the SSID of your Wi-Fi access point.

SSID = "YOUR WIFI AP"

4. Create an object called PASSWORD and store your Wi-Fi password.

PASSWORD = "TRUSTNO1"

5. Save the file to the Raspberry Pi Pico W as secrets.py By storing our sensitive details in a secrets file, we can freely share the project code with friends, or online. Just remember not to share the secrets file too.

6. Click on New File to create a new blank document.

7. Import three modules of code, network, secrets and time. These three modules enable our Pico to connect to a Wi-Fi network, use the data stored in secrets.py and to add a pause to the code.

import networkimport secretsimport time

8. Create an object, wlan, to create a connection from our code to the Pico W wireless chip. We use this connection to issue commands that will connect and check our Wi-Fi connection.

wlan = network.WLAN(network.STA_IF)

9. Turn on the Raspberry Pi Pico W’s Wi-Fi.

wlan.active(True)

10. Connect to your router using the SSID and PASSWORD stored in the secrets.py file.

wlan.connect(secrets.SSID, secrets.PASSWORD)

11. Print the connection status to the Python shell. This will print True if connected, and False if the connection failed.

12. Click Save and then select “Raspberry Pi Pico”. Save the file as Wi-Fi.py to the Raspberry Pi Pico W.

13. Click on Run to start the code.

14. Look in the Python Shell for True or False. True means we are connected.

Complete Code Listing

import networkimport secretsimport timewlan = network.WLAN(network.STA_IF)wlan.active(True)wlan.connect(secrets.SSID, secrets.PASSWORD)print(wlan.isconnected())

Using the Raspberry Pi Pico W With External Data

Now that we have an Internet connection, we will use it with publicly available datasets to pull data from external sources and display it on the Pico W. For this example we are going to use Open Notify’s “How many people are in space right now” dataset. This has the number and names of all the astronauts currently on the International Space Station.

We are going to adapt our previous example code, Wi-Fi.py.

1. Add a line after “import time” and import the urequests module. This module enables us to work with network requests such as HTTP and JSON.

import urequests

2. After print(wlan.isconnected()) add a new line which creates an object “astronauts” and then uses urequests to get the information in a JSON format. JavaScript Object Notation is an open standard file format which bears a striking resemblance to Python’s Dictionary which uses keys (names) to retrieve values from the object.

astronauts = urequests.get("http://api.open-notify.org/astros.json").json()

3. Create an object, number, which will open the astronauts object, and look for the key ‘number’. The value linked to that key is then stored in the number object.

number = astronauts['number']

4. Create a for loop that will iterate for the number of people on the International Space Station. This value could change as astronauts come and go, so rather than hard coding a value we use the live data.

for i in range(number):

5. Print the name of each astronaut on the International Space Station using a series of keys that target the specific data. Our dictionary ‘astronauts’ has many keys, but we are interested in the ‘people’, the value of “i” will increment each time the loop goes round, and it selects each person from a list embedded in the dataset. We then use another key, ‘name’ to get the name of that astronaut.

   print(astronauts['people'][i]['name'])

6. Save the code and when ready click on Run to start the code.

7. The names of all the astronauts on the International Space Station will appear in the Python Shell. Note that “True” still appears, confirming that our Internet connection is established.

Complete Code Listing

import networkimport secretsimport timeimport urequestswlan = network.WLAN(network.STA_IF)wlan.active(True)wlan.connect(secrets.SSID, secrets.PASSWORD)print(wlan.isconnected())astronauts = urequests.get("http://api.open-notify.org/astros.json").json()number = astronauts['number']for i in range(number):    print(astronauts['people'][i]['name'])

There is no denying that the Raspberry Pi Pico made a big impact back in 2021. The $4 microcontroller was quickly adopted by many of the maker communities and groups and one of those was CircuitPython. CircuitPython, a fork of MicroPython which is a version of Python 3 for microcontrollers, is backed by Adafruit who are one of the partners that launched its own RP2040 range of boards. Since its creation back in 2018, CircuitPython has seen a massive investment from the community, with many projects and libraries being ported to the language.

CircuitPython is the best means to introduce Python on microcontrollers, because it’s easy to use with devices appearing in the host OS as USB flash drives. We write our code into the code.py file and we can enable external sensors, screens and inputs via a dazzling array of libraries. 

So how can we work with the Raspberry Pi Pico and CircuitPython? Typically we connect up our Pico to a PC and start writing code, but we can also build projects with a Chromebook or other Chrome OS device. With an easy-to-use programming language, cheap microcontroller and an easy-to-use OS we have the perfect platform for creativity, no matter our age or ability.

In this how to we will show you how to set up your Raspberry Pi Pico for CircuitPython, install the software to write code and communicate with your Pico, and finally we shall build a temperature sensor project.

For this project you will need

• Chromebook or other Chrome OS device
• Raspberry Pi Pico
• Half size breadboard
• LED
• 330 Ohm resistor
• DHT22 temperature sensor
• 5x Male to male jumper wires
• 10K Ohm Resistor (Brown-Black-Orange-Gold)

Install CircuitPython onto the Raspberry Pi Pico

The Raspberry Pi Pico can run many different languages, even a version of a 50+ year old language. Our focus is on CircuitPython, and installing CircuitPython on a Pico is super easy to do.

1. Download the latest version of  CircuitPython for the Raspberry Pi Pico. At the time of writing the latest version was 7.3.0.

2. Press and hold the BOOTSEL button on the Raspberry Pi Pico, then connect your Pico to the Chromebook via a USB cable.

3. Copy the downloaded UF2 file from Downloads to the RPI-RP2 drive in files. The process will take under a minute and when complete a new drive CIRCUITPY will appear in the Files browser.

Install the Tools to use CircuitPython on Chrome OS

Ideally we would have just one application which could do everything, but for now, alas we need to install two. The first is a text editor, Caret, which we can use to write CircuitPython code directly to the CIRCUITPY drive. The second is Beagle Term, a serial terminal emulator for Chrome OS.

1. Install the Caret Text Editor via the Chrome Web Store.

2. Install Beagle Term via the Chrome Web Store. 

Writing our Test CircuitPython Code on Chromebook

Before we start any electronics, let's check that we can control and communicate with the Raspberry Pi Pico. Our demo code is a simple Hello World that prints to the Python shell every second.

1. Open the Caret text editor using the Search key (the spyglass where caps lock normally resides) and type Caret. Press Enter to open. 

2.  Click on File >> Open and select code.py found on your CIRCUITPY drive. This drive is your Raspberry Pi Pico running CircuitPython.

3. Delete any code in the file.

4. Import the time module. We will use this to control the speed at which our code loops.

import time

5. Create a while True loop to continually run the code within.

while True:

6. Use a print function to print “Hello World”. Note that the code is indented by one TAB keypress or four spaces. Do not mix tabs and spaces as Python will throw an error. This is a classic example of testing code. It is a simple means that we can use to confirm that we have control of and communication with a device.

   print(“Hello World”)

7. Add a one second pause

This gives us a second to read the Hello World message.

   time.sleep(1)

8. Save your code to code.py. CircuitPython will automatically run the code each time we save.

Test Code Listing

import timewhile True:    print(“Hello World”)    time.sleep(1)

Using the Beagle Term Serial Emulator

To see the output of our code we need to run the Beagle Term serial terminal emulator. This app will connect to the Python console, running over a USB to serial connection. CircuitPython has a REPL (Read, Eval, Print, Loop) Python console which can be used to interactively work with the board and it can output information directly to the console.

1. Open the Beagle Term application using the Search key (the spyglass where caps lock normally resides) and type Caret. Press Enter to open.

2. Set your Port to your Raspberry Pi Pico. This is a little bit of a trial and error approach as we do not know the name of the port. In our tests we saw /dev/ttyACM1 for our Raspberry Pi Pico.

3. Set the Bitrate to 9600. This is the speed at which our Chrome OS device and Raspberry Pi Pico will communicate. 

4. Set the Data Bit to 8 bit, Parity to none, Stop Bit to 1 bit, and finally set Flow Control to none.

5. Click Connect to start the serial connection to your Raspberry Pi Pico. Hello World should be scrolling down the screen. If not, press CTRL+C to stop the code running, and then press CTRL+D to restart the code. 

Building a Temperature Sensor Project

The DHT22 has four pins, but we shall only need to use three of them. The sensor is relatively easy to work with. It needs 3V to power it, and the data output pin is pulled high using a 10K Ohm resistor. By pulling the pin high we ensure that the data from the sensor is read, as the pin is always “on”.

1. Insert your Raspberry Pi Pico into the breadboard so that the microUSB port is on the left side of the board. 

2. Run a jumper wire from the 3V3 out (red wire) to the + rail of the breadboard. This provides a connection to the 3.3V pin to the entire + rail. Run another wire from the GND pin to the - rail. 

3. Insert the DHT22 into the breadboard. 

4. Connect 3.3V (red wire) and GND (black wire) to pins 1 and 4 of the DHT22. The pin numbers go from left to right, as we face the plastic “frame” of the sensor. 

5. Connect the 3.3V rail to pin 2 of the DHT22 using a 10K Ohm resistor. This is our pull-up resistor for the data pin.

6. Connect the data pin (pin 2) of the DHT22 to GP15 of the Raspberry Pi Pico. Your breadboard should look like this.

Coding the Project

1. Download the CircuitPython Libraries bundle for your version of CircuitPython.

2. Go to your Downloads folder. Right click and extract the ZIP file.

3. Open the adafruit-circuitpython-bundle folder and navigate to the lib sub-folder.

4. Copy adfafruit_dht.mpy to the /lib/ folder of your CIRCUITPY drive. This library enables our Raspberry Pi Pico to work with the DHT11 and DHT22 sensors.

5. Open code.py on your Raspberry Pi Pico using the Caret text editor. Delete the test code from the file.

6. Import three modules to enable our code to access the GPIO (board), use the temperature sensor(adafruit_dht) and to control the speed of the loop (time).

import boardimport adafruit_dhtimport time

7. Create an object, dht to connect the code to the DHT22 sensor connected to GP15 on the Raspberry Pi Pico.

dht = adafruit_dht.DHT22(board.GP15)

8. Create a loop to run the code.

while True:

9. Store the current temperature in a variable called temp. The temperature is saved in Celsius.

   temp = dht.temperature

10. Create an object, text and in there store a string which will print “The temperature is    Celsius”. You’ll notice {:>8}, this is a string format which will include eight spaces in the center of the sentence. This gives us a clear space to place the temperature data.

   text = "The temperature is {:>8} Celsius."

11. Use the print function along with the text format to insert the temperature data into the gap.

   print(text.format(temp))

12. Finally add a one second pause. This enables the loop to slowly repeat.

   time.sleep(1)

13. Save the project to code.py on your CIRCUITPY drive.

14. Open Beagle Term and connect to your Raspberry Pi Pico. You should see the temperature data scroll across the screen. If not, press CTRL + C, then CTRL+D to restart the code.

Complete Code Listing

import boardimport adafruit_dhtimport timedht = adafruit_dht.DHT22(board.GP15)while True:    temp = dht.temperature    text = "The temperature is {:>8} Celsius."    print(text.format(temp))    time.sleep(1)

Related Tutorials

• How To Control Neopixels with BASIC on Raspberry Pi Pico
• How To Make a Raspberry Pi Pico Reaction Game With PicoZero

With the rise in popularity of video conferencing, so has the demand increased for real-time video effects. With the help of this Raspberry Pi project from Freedom Tech, you can replace the background of your video feed with any color or custom image you want. The project uses artificial intelligence (AI) to automatically change the background by detecting where the edges are of the person in the frame.

While this technology isn’t exactly new and can be replicated locally on many PCs using software, this is the first time we’ve come across someone using a Raspberry Pi to automatically filter out the background image. Freedom Tech is using a few familiar tools to pull off the project including both OpenCV and Python.

This is one of many projects developed and shared by Freedom Tech—most of which are open source. In fact, we recently covered their OpenCV-based distance detection project which uses a camera and AI to estimate distance values without a distance sensor. Previous projects often include various machine learning and AI-based applications like this text detecting project which was also created using Python and OpenCV.

To operate this project, you’ll need a Raspberry Pi. While smaller versions like the Pi Zero will work, you’ll likely have better success with a more capable model like the Raspberry Pi 3 B+ or a Raspberry Pi 4. In addition to the Pi, you’ll need a camera of sorts to capture the video feed. In this case, Freedom Tech is using a USB webcam, but a camera module would work just as well.

Freedom Tech provides a full video setup tutorial detailing what libraries and dependencies are necessary as well as digging into how to create the custom Python script that brings it all together. The major tool used in this project is CVZone which is responsible for handling the AI-based system that draws edges for the background to adhere to.

If you’re interested in recreating this Raspberry Pi project, check out the full tutorial shared by Freedom Tech over at YouTube which delves into all of the details you need to build it from scratch. Be sure to follow Freedom Tech for more exciting AI-based Pi projects and tutorials to make them yourself at home.

Used by NASA, ILM, Disney and hardware hackers, Python is a versatile programming language and an ideal choice for beginners. Whether you’re just  creating a “Hello World” or a full-blown application, Python needs an interpreter and a bunch of supporting libraries to work. What if we could make a GUI application, all bundled inside of a single executable file?

With auto-py-to-exe ,a project by Brent Vollebregt we can easily create our own executable Python applications. Underneath the GUI is PyInstaller, a terminal based application to create Python executables for Windows, Mac and Linux. Veteran Pythonistas will be familiar with how PyInstaller works, but with auto-py-to-exe any user can easily create a single Python executable for their system.

In this how to, we are going to create a GUI Python application using EasyGUI, and then use auto-py-to-exe to create a standalone application that will run on any Microsoft Windows system, including systems without Python installed. Linux and Mac users will need to use the underlying PyInstaller command line tool. A simple app can be created using a single line instruction. By adding more arguments we can include icons, packaged libraries etc.

For example here is the code to create a onefile application using app.py as the project code.

pyinstaller --onefile app.py

Where auto-py-to-exe differs is that we have an easier means to create an application using a GUI tool.

How to Install auto-py-to-exe

1. Open a Command Prompt by searching for CMD.

2. Use the Python package manager pip to install auto-py-to-exe.

pip install auto-py-to-exe

Create a Test Script

Our example application is a simple GUI to launch one of three applications. We use the EasyGUI Python library as it abstracts the complexities of creating a GUI application. All we need to provide is the logic that drives the application.

1. Open a PowerShell by right clicking on the Windows icon and selecting PowerShell.

2. Install EasyGUI using pip.

pip install easygui

3. Open a text editor to write the Python test script. We chose to use Notepad++, but you are free to use your favorite editor.

4. Import two Python modules, easygui and os. Easygui creates the GUI application and OS enables the code to interact with the operating system.

import easyguiimport os

5. Create two variables, one for a message (msg) to the user while the other becomes the application title.

msg = "Load application..."title="Tom's Hardware Application Starter"

6. Create a list, choices, and inside store three values which are the application names. Lists are Python’s arrays. Objects that can store multiple items. Each item has a numerical index, starting from zero.

choices = ["Google Chrome","Slack","PuTTY"]

7. Create an object, reply, to ask the user a question. In this case we use a button box from EasyGUI, each button is an option from the choices list. The chosen application is stored in the reply object.

reply = easygui.buttonbox(msg, title,  choices=choices)

8. Use a conditional statement to read the value stored in reply and compare it to three conditions. The first checks reply to see if it contains “Google Chrome” if so it will open the Google Chrome browser. The startfile function requires the use of a full file path to the application. We need to use double \\ in the path as Python uses \ to insert illegal characters into a string.

if reply == "Google Chrome":   os.startfile("C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe")

9. Use another conditional statement to check reply for slack.

elif reply == "Slack":   os.startfile("C:\\Users\\lespo\\AppData\\Local\\slack\\slack.exe")

10. Add another conditional statement to load PuTTY. Note that for PuTTY we use the os.system function as PuTTY is a registered app with the Windows path.

elif reply == "PuTTY":   os.system("putty")

11. Close the conditional test with an else condition to catch any other input.

else:   print("Done")

12. Save the file as app.py to the Desktop. If you are using an image in the application ensure that the image is also on the Desktop.

Complete Example Code Listing

import easyguiimport osmsg = "Load application..."title="Tom's Hardware Application Starter"choices = ["Google Chrome","Slack","PuTTY"]reply = easygui.buttonbox(msg, title , choices=choices)if reply == "Google Chrome":    os.startfile("C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe")elif reply == "Slack":    os.startfile("C:\\Users\\lespo\\AppData\\Local\\slack\\slack.exe")elif reply == "PuTTY":    os.system("putty")else:    print("Done")

Using auto-py-to-exe

 1. Open a Command Prompt by searching for CMD.

2. Run auto-py-to-exe from the prompt.

auto-py-to-exe

3. Click on Browse and navigate to our example Python file.

4. Set the application to use one file. This will condense the application and the supporting Python libraries into a single executable file.

5. Set the application to be Console Based. By doing this we will see any errors outputted to the Command Prompt. Once we are confident that the app works correctly, we can set this to Window Based.

6. Click on the Icon drop down and select an icon for your application. This is an optional step but it adds an extra level of quality to your application. Icons must be .ico files and we used a 64x64 pixel image as an icon.

7. Click on Advanced and, under –name, enter the name of your application. We chose App Launcher.

8. Scroll down and click on CONVERT .PY to .EXE to start the process. This will take a couple of minutes.

9. Click on Open Output Folder to open the folder containing the application.

10. Double click on the icon to run your application.

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

The Adafruit blog has published an announcement confirming over 300 boards now officially support CircuitPython. These microcontrollers can be used for tons of cool projects and CircuitPython adds a new level of accessibility that makes programming modules, including the Raspberry Pi, in many ways much easier.

CircuitPython is a barebones programming language that simplifies coding by eliminating unecessary bloat and focusing only on what’s needed. To get a better idea of what it’s capable of, check out our guides on how to use CircuitPython on the Raspberry Pi and on the Raspbery Pi Pico RP2040 board.

According to Adafruit, the 300+ boards supporting CircuitPython include both official and third-party creations from companies as well as open source projects made by members of the Raspberry Pi community. There are tons of microcontrollers out there to take advantage of for your projects and some of the best ones around are RP2040 boards.

Adafruit provides a complete list of officially supported boards on the CircuitPython website. Examples include most any RP2040 board, NXP, Nordic, Espressif boards and plenty more. Check out the complete list to see if the board you want to use will work or to find alternatives for your project that support CircuitPython.

It’s not enough to support CircuitPython, special libraries are created to absolve much of the hard work and so far over 350 are available to download. There is a complete list of libraries available on the CircuitPython website including a package that bundles many of them together. If you want to see what these libraries are capable of, check out our tutortial on how to create a Simon Says game using the Raspberry Pi Pico along with the aid of CircuitPython.

The best Raspberry Pi projects are the ones you can make at home and CircuitPython easily bridges the learning gap with microelectronics. With over 300 boards now officially supported, there’s plenty of hardware to choose from and tons of inspiration from the community to help bring your project to fruition.