Forem: dev_neil_a

How To Auto Update and Upgrade Homebrew

dev_neil_a — Thu, 12 Mar 2026 12:02:00 +0000

Introduction
YouTube Video
Warning
Installing autoupdate
Configuring autoupdate
Logs
Changing Autoupdate Settings
Conclusion

Introduction

Hi there. In this article, I'm going to cover how you can automate the updating of Homebrew and the upgrading of packages that were installed using brew.

The process is relatively simple to do, but there is a caveat with the upgrading of casks (macOS apps), which I'll cover as well.

YouTube Video

If you would prefer to see this article in video form, there is a YouTube video available below:

Warning

Before I get started, I just wanted to add a bit of a warning about doing this. As this will upgrade packages and casks to newer versions, it could cause some compatibility issues, depending upon what it is.

For example, Python may get upgraded and break compatibility with some libraries that you use that haven't been updated to work with the newer version.

If you are ok with this, then you are ok to continue but I just wanted to make you aware of that before proceeding any further.

Now, With that said, let's begin.

Installing autoupdate

First, open your terminal of choice. Any will work just fine.

Then, run brew update to update homebrew. This needs to be done before we go any further so that the latest version of Homebrew is installed and the package database is up-to-date.

With that done, the next step is to install an extension to homebrew called autoupdate. This is done by using the tap command in Homebrew. This allows you to add additional repositories to Homebrew. For this, we need the autoupdate extension. To install that, run:

brew tap domt4/autoupdate

I'm recommending using the version from the domt4 repo as the one that is in the official homebrew repo has been taken out and moved back to the domt4 repo so it could be out of date.

Configuring autoupdate

Now that autoupdate is installed, let's check the status of it by running:

brew autoupdate status

As you can see, it is not setup or running. To start it, run:

brew autoupdate start

Once it has started, it will check for updates to homebrew every 24 hours from when it was started, or when the system booted up. It runs as a launchd service in the background and you’ll get a notification appear to let you know it is now running in the background.

Now, what it won't do by default, is upgrade any packages or casks that are installed. It will only do the equivalent of running brew update.

To get it to do an upgrade as well as update, some additional settings need to be set to the brew autoupdate start command and an additional package needs to be installed.

Before doing this, stop the autoupdate service by running:

brew autoupdate delete

You can also use brew autoupdate stop but I prefer to delete the config, just to be sure.

Next, install the package called pinentry-mac by running:

brew install pinentry-mac

This is required to handle any casks that require admin permissions to install an app into the Applications folder. If this wasn't installed, when brew does an upgrade, any casks that require admin rights will be ignored and not updated. With it installed, when a cask requires admin rights, a normal macOS prompt will appear asking you for a username and password to use that has admin rights to the Applications folder on your Mac.

This was the caveat I was alluding to earlier.

With that installed, let's reenable autoupdate with the additional settings by running:

brew autoupdate start 86400 --ac-only --cleanup --immediate --sudo --upgrade

The order the settings are in does not matter, except for the time, which I believe must go first.

To go over what these settings or switches do:

86400 sets autoupdate to run every 24 hours from when the Mac was last powered on or when the command was started. You can change this to a longer or shorter interval if you prefer. The time is in seconds.
--ac-only will only allow autoupdate to perform an update and upgrade when your Mac is plugged into mains power. If it's on battery or UPS battery power, it won't run.
--Cleanup is the same as running brew cleanup, which cleans up Homebrew's cache.
--Immediate will run autoupdate immediately and when the system starts up from being powered on or rebooted.
--Sudo will allow autoupdate to install casks that require admin rights to the Applications folder. This requires the pinentry-mac package that was previously installed to work.
--Upgrade will perform the equivalent of brew upgrade.

You don't have to use all of them if you don't want to. For example immediate and ac-only are not required but prefer to have them on.

Once the command is run, the notification will appear again and another one will also be shown to indicate that you may get alerts. You can do with that as you want.

And that's it for setting it up.

Now, when an update that runs in the background is completed, you will get a notification indicating that an update was run and some of the output from the logs.

Logs

Speaking of logs. If you want to know what was installed when autoupdate ran, you can examine the logs by running:

brew autoupdate logs

For reference, the log files are stored in ~/Library/Logs/com.github.domt4.homebrew-autoupdate.

Changing Autoupdate Settings

If you need to change the settings for autoupdate, you will need to run brew autoupdate delete, which will delete the schedule, the settings that were previously set and the log files.

You can then rerun brew autoupdate start with the settings you want.

Uninstalling Autoupdate

The last thing I want to cover is removing autoupdate. To do this, make sure it isn't running and delete the running configuration by running:

brew autoupdate delete

After that, run:

brew uninstall pinentry-mac

This is optional in case you need it for something else.

Finally, to uninstall autoupdate, run:

brew untap domt4/autoupdate

Optionally, you can run brew cleanup to clear out any cached Homebrew data.

If I try running brew autoupdate start again, I get the error indicating it's not a valid command.

Conclusion

And that is it for this article.

Thank you for reading and have a nice day!

How To Set Up a UPS on Windows 11

dev_neil_a — Wed, 18 Feb 2026 13:00:00 +0000

Introduction
YouTube Video
Connecting the UPS
Checking the UPS has been detected
Configuring
What Happens When Mains Power is Lost

Introduction

Hi there. In this article, I'm going to guide you though how to setup a UPS on Windows 11. I'll be doing this with an APC UPS but the process will be similar for other UPS's, although some may require additional software to be installed. Please check with your UPS manufacturer if any is needed.

YouTube Video

If you would prefer to see a video of this article, there is a YouTube video available below:

Connecting the UPS

To set the UPS up with Windows 11, you need to connect up the signal cable to a USB port on your PC and the other end needs to go into the data port on the UPS.

Checking the UPS has been detected

Once it is connected, you'll see the battery indicator appear in the bottom left of the taskbar.

When you click on it, it shows the UPS's battery level in bottom left.

Click on that and it'll go to the Power & Battery settings.

You can see the power mode for the system is balanced by default.

Under battery usage, there is a graph that would show the usage over time. This one isn't populated on mine as my PChas not had the UPS connected before.

Close Settings and then open up control panel. Then, check that the battery is showing as a UPS, by opening Device Manager and then expanding Batteries. If it has "UPS" in the description, it's showing correctly. Close Device Manager.

Next, open up Power Options.

Configuring

First, click on Create a new power plan. I did try using the Balanced one but it wouldn't hibernate for some reason.

Select high performance and then give it a name. Leave everything as is and click create.

Once it's created, click on Change plan settings and then change advanced power settings.

Scroll to the bottom and expand Battery.

Expand low battery action. Both should be set to do nothing. Leave those as they are.

Low battery notification should be on.

Critical battery action will need to be set to hibernate or shutdown for battery and do nothing for plugged in.

Critical battery notifications should both be on.

Now, low battery level and critical battery level can be left as they are but I would recommend changing these to higher values. The reason is that 5% might not offer enough runtime to hibernate or shutdown the system gracefully. What I would go for is 40-50% for low battery level.

When that point is reached, You'll get a notification to say "the battery is low and you should plug in your PC to mains power". The verbiage could do with some changes as this is a UPS, rather than a laptop battery.

For critical battery level, go for 20 - 30%. When this is reached, the PC will hibernate or shutdown, depending on what was set. In my case, I set it to hibernate.

When that is done, click Ok and you're done. There are nothing further you need to do.

What Happens When Mains Power is Lost

To give you an example of what will happen, I'll adjust the low battery level to 64% and the critical battery level to 60. Don't change this.

I'll open the battery settings up again. You'll see the icon at the side of the percentage remaining indicates it's on mains power.

Now, I'll turn the UPS off at the wall. Most UPS's will produce an audible alarm.

The icon should change to just a battery.

There is the low power warning.

It dropped to 57% and then went into hibernate.

Before you turn your PC back on, make sure that mains power is back on first. When I logged back in, the Notepad document I had open before was still there, indicating the PC hibernated correctly.

I hope that was of use to you. Thanks for reading and have a nice day!

How To Use A Raspberry Pi Pico 2 With A Light Sensor

dev_neil_a — Wed, 21 Jan 2026 12:05:00 +0000

Introduction
YouTube Video
What You'll Need
Connecting the Pico 2 to the Light Sensor
Creating the Program

Introduction

Hi there. In this tutorial, I'll go over how you can use an ambient light sensor board with a Pico 2 and MicroPython. This project will get the current light level and then turn on the LED onboard the Pico 2 when the light is low.

This project will also work on the original Pico.

YouTube Video

If you would prefer to see a video of this article, there is a YouTube video available below:

What You'll Need

Let's start by going over what's needed for this project. In terms of hardware, you'll need:

A Pico or a Pico 2, with or without Wi-Fi & Bluetooth
A USB-A or USB-C to Micro-B cable
A breadboard
A VEML7700 based ambient light sensor. The one I have is an Adafruit VEML7700 Lux Sensor
And lastly, suitable wires to connect the Pico to the light sensor board. I used 4 dupont male to male cables to go from the Pico 2 to the breadboard and a STEMMA QT / Qwiic JST-SH 4-pin to 4 Male dupont wires to go from the sensor to the breadboard.

As for software, you'll need:

MicroPython installed on the Pico
Python installed on your local computer
Visual Studio Code with the Python and Raspberry Pi Pico extensions installed. You can use Thonny instead if you prefer.

Connecting the Pico 2 to the Light Sensor

After inserting the Pico 2 into the breadboard, the cabling of the light sensor to the Pico 2 is done by using the GPIO pins for I2C bus 0 and 3.3v power & ground.

Coming from the Pico 2, the 3.3v power (the red wire) is connected from pin 36 and ground (the black wire) is coming from pin 33.

The i2C connections are from pin 1 for SDA (the blue wire) and pin 2 for SCL (the yellow wire). Again, I2C bus 0 was what I used for this build but you can use another if you would like.

As for the VEML7700 sensor, I plugged the Stemma QT cable into the right-side connector and then simply matched each wire with the same coloured wire from the Pico 2.

Creating the Program

Before you get started, make sure to download the source code from my GitHub repository as there are custom modules in there.

Oh, a quick shout out to palouf34 on GitHub for the veml7700.py module that I found which worked on the Pico. The one from Adafruit wouldn't work as MicroPython didn't include some of the libraries that were needed.

To begin with, connect the Pico or Pico 2 to your computer.

Next, open VS Code. Click on "Create Pico Project".

Select MicroPython from the drop down menu.

Give the project a name and specify a location to save it to. Leave everything else as is and then click on create.

Once the new window is open and the files appear in explorer, delete blink.py. Leave the .vscode folder and .micropico file as alone as they are required for the Pico extension to work.

Create a new folder called modules. In that folder, create a file called init.py and close it if it opens.

Next, create a new folder in the modules folder called light_sensor. In that folder, create another new file called init.py. Again, close it if it opens.

Next, put the veml.py and veml7700.py files in the light_sensor folder open veml.py. The folder structure at this point should look like this:

Now, open veml.py. The code should look like this:

from machine import I2C, Pin
from .veml7700 import VEML7700


def veml_setup(i2c_bus:int = 0, sda_pin:int = 0, 
               scl_pin:int = 1, address = 0x10, 
               freq:int = 400000) -> VEML7700:

    """_summary_
    This function setups the connection to the light sensor.

    args:
        i2c_bus (int, optional): The I2C bus number to use. Defaults to 0.
        sda_pin (int, optional): The SDA pin to use. Defaults to 0.
        scl_pin (int, optional): The SCL pin to use. Defaults to 1.
        address (int, optional): The light sensors i2c address. Defaults to 0x10.
        freq (int, optional): The frequency to use. Defaults to 400000.

    returns:
        VEML7700: An object for interacting with the light sensor.
    """

    # --- 1. Create the i2c interface:
    sda = Pin(sda_pin)
    scl = Pin(scl_pin)

    i2c = I2C(i2c_bus, sda = sda, scl = scl, freq = freq)

    # --- 2. Instantiate the sensor:
    try:
        veml = VEML7700(address = address, i2c = i2c, 
                        it = 100, gain = 1/8)
    except:
        raise Exception("Sensor not found. Check the sensor is connected and the i2c settings are correct.")

    return veml

Let's go over what this module does:

First, there's the library and modules that need to be imported. I2C and Pin are used for interacting with the i2c bus. VEML7700 is used for interacting with the light sensor.
Next, there is a function called veml_setup that has parameters that are required for setting up the i2c bus. This includes the bus number, GPIO pins and frequency to use. All of these have default values which match the wiring diagram and the i2c address on the back of the sensor board.
Once the i2c bus is setup, the function will then attempt to connect to the light sensor. If it is successful, the function will return a VEML7700 object back to the caller. If not, it will raise an exception and terminate the program.

Close the file down.

In the root of the project, copy the main.py file. The final folder structure should look like this:

Open main.py if it doesn't automatically open.

The code should look like this:

# --- Import required libraries / modules:
from machine import Pin
from utime import sleep

from modules.light_sensor.veml import veml_setup


def main() -> None:
    """_summary_
    This is the main function of the program.

    returns:
        Nothing is returned.
    """

    # --- 1. Attempt to instantiate a VEML7700 light sensor:
    light_sensor = veml_setup()

    # --- 2. Attempt to setup the onboard LED:
    try:
        led_gpio = Pin("LED", Pin.OUT)
    except:
        raise Exception("LED not present. Please check your Pico board.")

    # --- 3. Display the ambient light brightness value:
    while True:

        # --- 4. Attempt to get a reading from the VEML7700 light sensor:
        try:
            light_level = light_sensor.read_lux()

        except:
            raise Exception("Unable to get reading. Check the sensor is connected.")

        print(light_level)

        # --- 38 or above for light level:
        try:
            if light_level < 39:
                led_gpio.on()
            else:
                led_gpio.off()
        except:
            raise Exception("Cannot change LED state. Please check your Pico board.")

        sleep(1)


# --- Start the program:
if __name__ == "__main__":
    main()

To go through what this will do:

First, it imports the libraries and the custom veml module.
Then there's a main function. Inside it:
1. There is a variable to instantiate the light sensor. If all is well, that will be assigned a VEML7700 object that can be used to interact with the light sensor. If not, an exception will be raised in the veml module and terminate the program.
2. After that, an attempt to setup the onboard LED on the Pico is made. Again, if it fails, an exception will be raised.
3. Next, a while loop is used to continuously read the sensor every so many seconds and print out the result to the terminal.
4. Following on from that, an attempt to read the light level from the sensor is made. If it can't be read for whatever reason, perhaps due to a hardware failure, an exception will be raised.
5. If the sensor reading is under 39, the program will try to turn the LED on. If it is over 39, it will turn off. If there is an issue interacting with the LED, an exception will be raised.
6. The sleep of one second is just for demonstration purposes. A much higher number, such as 60 or more would be more reasonable.
The last part of the file is to call the main function when the program starts.

Save the file, if needed, but don't close it.

Now, right-click on a blank space in explorer and select "upload project to pico".

Once that is done, right click on an empty space in the main.py file and select "run current file on pico".

You can now see the output from the sensor.

If the sensor is covered over, the number should go below 39 and the LED turns on. Uncover it and the LED goes off.

Now, whilst it's running, disconnect the sensor from the Pico. It now gives the expected exception error, indicating it can't read the sensor.

Running the program again with the sensor disconnected will show the exception error that implies it cannot setup the sensor on the i2c bus. Those errors are expected for the two scenarios.

Once the sensor is plugged back in and the program is run again, it will work as expected.

Now, what this project covered is pretty simple in terms of it just turning on the LED on the Pico, but it can be useful in other ways. For example, making a call to an API or a web hook to turn on or off a smart light or a smart power socket to turn a lamp on that doesn't have smart capabilities. It could also work with Home Assistant to do some other home automation function.

The choice is up to you, but that concludes this project.

If you want some other Pico project ideas, there is a playlist at the bottom of this article with some other Pico starter projects I've done.

But for now, thanks for reading and have a nice day.

How to Set Up a UPS on macOS 26 Tahoe

dev_neil_a — Wed, 07 Jan 2026 18:00:00 +0000

Introduction
YouTube Video
Connecting the UPS
Checking the UPS has been detected
Configuring

Introduction

Hi there. In this article, I'm going to go over how you can setup a UPS (Uninterruptible Power Supply) on macOS. I'll be doing this with an APC UPS on macOS 26, but the process will be similar for other UPS's, although some vendors may require additional software to be installed to get their UPS to work with macOS.

YouTube Video

If you would prefer to see a video of this article, there is a YouTube video available below:

Connecting the UPS

The first thing you need to do is to connect the signal cable to a USB port on your mac and the other end into the data / signal port on your UPS.

Checking the UPS has been detected

If you're on a Desktop Mac, You'll see the battery icon appear on the right-side of the menu bar. This would normally be there if your on a MacBook.

Clicking on it will show that there is a UPS connected and the battery level.

After that, the UPS should then appear in system information under both Power and USB.

Configuring

With the UPS showing up correctly, the UPS settings are configured in the Energy Settings in System Settings.

Once you are in Energy Settings, you can see the UPS level at the top and a button to configure the UPS options.

Clicking on UPS Options, there are three settings you can configure in there.

Which one you use is up to you. Personally, I opted for shutting down when the UPS level is below 25%. This will give me more than enough time to save everything and shut down my Mac.

To confirm the change, click done.

That's all there is to setting up a UPS on a Mac, assuming it doesn't require additional software from the UPS vendor to make it work!

Now, in terms of what will happen when the UPS loses mains power. The first thing you'll notice is that the UPS will beep. After that, a warning message will appear on the screen, indicating that the system is now on UPS battery power and that you should save your documents and shutdown.

This will be the only visual warning you will get.

Once the UPS battery is below 25%, or whatever threshold you set, the system will shutdown.

I hope that was of use to you. Thanks for reading and have a nice day!

How To Install & Use Homebrew on macOS

dev_neil_a — Tue, 09 Dec 2025 13:00:00 +0000

Introduction
YouTube Video
What is Homebrew?
Installing Homebrew
Updating Homebrew
Searching for Packages
Getting Information About Packages
Installing Packages
See What Packages are Installed
Exporting the List of Installed Packages To a File
Upgrading Apps
Clearing Cache
Removing Packages
Checking for Homebrew Issues
Installing Packages from a Brewfile
Conclusion

Introduction

Hi there! In this article, I'll be going over how to install and use Homebrew on macOS, including how to install it, install & upgrade software with it and more

This article will be covering how to use it on macOS 26 but it also works on other versions of macOS as well.

YouTube Video

If you would prefer to see a video of this article, there is a video version available on YouTube below:

What is Homebrew?

So what is Homebrew and why should you use it?

Homebrew is an open-source package manager that allows you to install and update software that you install via Homebrew. If you have ever used apt or def on Linux before, or Chocolatey and winget on Windows, it is essentially a macOS equivalent of those.

You can install software like command line tools, audio & video codecs, macOS desktop apps and more. It can also install apps from the Mac App Store but that is not something I'll be covering.

It is useful for developers, system administrators and pretty much anyone that needs a single source to install and manage updates to software on their system.

It isn't built-into macOS so it will need to be installed.

Now, let's install Homebrew!

Installing Homebrew

First, you'll need to open up the terminal application on your Mac. You can do this via spotlight and search for terminal and then open it. Alternatively, you can find it in the Utilities folder in the Applications folder. If you want to use another terminal app, such as iTerm2, you can as everything will be the same.

The first thing that needs to be installed is the Command Line Tools for Xcode. This is a dependency that Homebrew requires. To install it, run:

xcode-select --install

A new window will appear. Click on Install and then Agree. This will take some time to download and install.

Click Done when it's finished.

Next, go back to the terminal and run:

sudo xcodebuild -license

When prompted, accept the license terms by typing agree. Press enter to finish.

Next, open your web browser and go to https://brew.sh/. Towards the top of the page, under Install Homebrew, copy the command and then paste it into the terminal and press enter.

Enter your password, if required.

Press enter to create the directories.

This may take a while to do depending upon the speed of your internet connection.

Lastly, under next steps, run each of those commands. You can copy and paste all of them and press enter after.

Close your terminal window and open a new one so that those changes take effect.

Updating Homebrew

Now that Homebrew is installed, the first thing I typically do is to update Homebrew. Even tough it has just been installed, I do this to ensure the most recent version of Homebrew is installed. It also updates its database of packages that are available.

To perform the update, run:

brew update

Again, this may take a while.

Searching for Packages

Now that it's updated, let's have a look at how you can check if a package is available in Homebrew.

The command you use is brew search, followed by the package name. For example, run:

brew search htop

This will check to see if the htop (a system resource monitoring) utility is available to install via Homebrew.

As you can see, it is available as a formula. There are some casks that mention htop in their name but those are not what will be getting installed.

Getting Information About Packages

Now that we know htop is available to install via Homebrew, let's have a look at some information about it To do that, run:

brew info htop

At the top, there is some information about what htop does, along with the current version, along with where it is downloaded from and the dependences it has.

There is also some usage information under caveats, and lastly, some analytics about how many times it has been installed.

Let's do one more but this time, let’s use a cask instead. There is no difference in the command to run, only the name of what it is. In this example, let’s check pgAdmin 4 by running brew info pgadmin4.

The output is similar but there are some differences, with the main one being that under Artefacts, it shows the pgAdmin 4.app. This is the only contents of the package. Typically, casks don't have dependencies as they should be bundled in with the macOS app.

Installing Packages

Now, let’s install htop. Run:

brew install htop

If you want to install multiple packages, you can by adding a space and then the name of the package.

Once it's installed, run htop in the terminal and as you can see, it's running as expected.

Press q to quit out of it.

Next, lets’s install a cask, a.k.a a desktop app. Most apps are available but for this example, I’ll go with pgAdmin4, which is used to manage PostgreSQL databases. Don't worry about what it does, this is just showing you the process.

There are two ways to install a cask. First, you can just run brew install pgadmin4 but if there is a package with the same name, it will conflict and not install anything. In this case, run

brew install --cask pgadmin4

Using --cask narrows it down to only casks.

Casks usually take a while to install and may ask you for your password so that it can install it into the Applications folder.

Now that it's installed, in the Applications folder, pgAdmin 4 is now installed.

See What Packages are Installed

Now that there is something installed, you can check what you have installed by running brew list.

As you can see, there is htop and another package that were installed. This was likely a dependency for htop.

There is also pgAdmin4 under the casks section as well.

If you want to see details of just one package, run brew list and then the name of the package. I'll do it for htop to show you what the output is like:

brew list htop

This will show you where htop is installed.

Exporting the List of Installed Packages To a File

Before I go over this part, I just wanted to let you know that I have installed some additional packages, mostly because I need them.

Okay, once you have all of the packages and casks installed, you can create a file, or a dump, of what has been installed via Homebrew to allow you to then reinstall them quickly on a new Mac. To do this, run:

brew bundle dump

By default, the file will be called Brewfile and it will be stored in the directory you are currently in. In my case, it is in the root of my home directory.

Let's have a look at the contents of the file in nano.

As you can see, it has a list of brew formulae / packages that have been installed, the casks and because Visual Studio Code was installed via homebrew, it also tracked the extensions that have been installed. The next time visual studio code is installed, homebrew will also install those extensions.

I'll come back to how you can use the Brewfile later.

Next, let's look at upgrading formulae and casks.

Upgrading Apps

To install the most recent version of a package or cask, the process is called upgrading. This is not to be confused with updating as that is what is used for updating homebrew itself.

To begin, run brew update. You should always do an update before an upgrade to make sure that Homebrew has the most recent version of itself installed, along with the most up-to-date package information.

As you can see, it has highlighted that there are new formulae and casks available that you can install, along with two outdated formulae that can be upgraded.

If you want to see the names and the version numbers that are installed and what they can be upgraded to, run:

brew outdated

To perform the upgrade run:

brew upgrade

Both of them have now been upgraded. Any casks that homebrew is responsible for will also be upgraded, if there are any so you won't have to run an upgrade just for those.

If you want to update only specific packages or casks, just add the names of the packages after brew upgrade with a space between each package name.

Now, some casks, may or may not be upgraded. The reason for this is that some apps have built-in update tools so, in those cases, Homebrew is only used to install them. After that, the app will update itself. This is set in the cask settings.

For example, Google Chrome, Firefox and Visual Studio Code will update themselves, rather than via Homebrew. pgAdmin 4 on the other hand does not update itself so the cask specifies that Homebrew will track the installed version and upgrade when required.

Clearing Cache

Homebrew maintains a cache for downloads and previous versions that were later upgraded. It's a good idea to manually clear the cache from time-to-time, if only to free up some storage.

To do that, run:

brew cleanup

The cache will then be emptied and a summary of how much space was freed up will be shown, if there is any.

The first time I ran it, it gave no output, which indicates there is nothing to clear. I did run it again a few days later after some upgrades were done and this is what it would look like if there was some cache to clear.

Removing Packages

Removing packages is very simple to do. Simply use brew uninstall, followed by the package name. For example, to remove htop, run:

brew uninstall htop

When I try to run it, it can't be found as it was removed.

If you want to uninstall a cask, simply delete the app from the Applications folder as normal.

Checking for Homebrew Issues

If you encounter any issues with Homebrew, you can run brew doctor which will help diagnose any issues it detects and can make recommendations on how to resolve them.

It does indicate that there is a warning about some unbrewed dylibs. I'm not going to worry about that for now but it does give you an idea of what issues it can pick up and sometimes how to resolve them.

If it doesn't find any issues but you are having trouble with something, well, it's off to Google or A.I to find a solution to the problem 🙂.

Installing Packages from a Brewfile

The last thing to cover off is how to use the Brewfile that was created earlier to do a bulk install of formulae and casks.

You can use that Brewfile on other Macs with Homebrew installed to install the same formulae and casks, or perhaps you may have reinstalled macOS and need to install everything again.

The first thing to do is make sure you are in the directory where the Brewfile is located. You can then install everything that is listed in that file by using:

brew bundle install

Previously, htop was uninstalled and because it was listed in the Brewfile, it was installed again. Everything else was skipped as they were already installed.

When trying to run htop again, it now works.

Conclusion

That concludes this introduction of how you can use Homebrew to install and manage apps on a Mac.

Now, there are other capabilities within Homebrew that haven't been covered but it did cover most of what you would typically use it for.

Thanks for reading. Have a nice day.

How To Create A macOS 26 Tahoe USB Installation Drive

dev_neil_a — Fri, 07 Nov 2025 12:55:00 +0000

Hi there. In this article, I'll be going over the process of how you can create a macOS 26 Tahoe USB bootable installation drive.

YouTube Video

If you would prefer to see a video of this article, there is a video version available on YouTube below:

Requirements

To do this, you'll need macOS 10.15 or above (I used macOS 15) and a 32GB USB stick or higher to create the installation drive.

Before you start, make sure to backup any data that is on the USB stick as the USB stick will be erased as part of the process.

Downloading the macOS 26 Tahoe Installer

Unlike previous versions of macOS, macOS 26 Tahoe is not available in the App store. It can only be downloaded via the command line for the full version that is used to create an installation disk.

To begin with, you'll need to open the terminal application. To this, use spotlight by pressing command and space together. Then, type terminal and hover over to the terminal application. It looks like a black box with a white arrow. Left click on it to open the application.

Your terminal may look different to mine but don't worry.

You can also get to it by opening a Finder window, going to Applications, then Utilities and then double clicking on Terminal.

First, you need to determine what the latest version of Tahoe is. There are two ways to do this. First, you can use this webpage, which shows it is being 26.1 at the time of writing this article.

The second method is to run the following command in the terminal:

softwareupdate --list-full-installers

The latest version is at the top, which again is 26.1.

The next step is to download the installer for macOS 26.1. To do that, run the following command. If a newer version is available, replace 26.1 with that version, if you want to:

softwareupdate --fetch-full-installer --full-installer-version 26.1

It will now download the installer. This will take some time.

Creating the USB Installation Drive

Now that the installer has finished downloading, you should be able to see it in the Applications folder in Finder.

The next step is to make the USB installation drive. First, make sure your USB stick is connected to your Mac.

Mine is connected and it's called usbstick.

I would recommend renaming your USB stick to a name that has no spaces to make it easier.

Once again, remember to backup anything that is on the USB stick that you want to keep.

When you are ready, run the following command in the terminal. Replace usbstick with the name of your USB stick.

sudo /Applications/Install\ macOS\ Tahoe.app/Contents/Resources/createinstallmedia --volume /Volumes/usbstick

Press enter and then type in your password, or the username and password for an administrator account if your account doesn't have that level of permission.

When it asks you to confirm the USB stick can be erased, press y and then enter.

Your USB stick will disappear from Finder and then come back with the name of Install macOS Tahoe. This is normal.

The progress will be shown on the screen.

Once it has completed, the terminal will look like the below image.

You can now use that to boot from and install, or reinstall macOS 26 Tahoe on a supported Mac.

Thanks for reading and have a nice day!

How To Build a Currency Converter App With Python

dev_neil_a — Mon, 17 Mar 2025 13:00:00 +0000

Introduction
YouTube Video
Source Code
Requirements
Building the App Modules
Main File

Introduction

In this article, I'm going to show you how you can build a currency converter GUI app using Python and customTKinter.

The goal of the app is very simple: take a value, along with a currency to convert from and to and then show how much the converted currency is worth against the source currency.

YouTube Video

If you would prefer to see a video of this article, there is a video version available on YouTube below:

Source Code

If you would like a copy of the source code, it is available here on GitHub.

Requirements

To build this app, you will need to have Python installed (I used version 3.12), along with TKinter, which may or may not be installed with the version of Python you have. Also, an IDE or text editor of your choice.

The last thing you'll need is an API key from https://freecurrencyapi.com. I opted for this site as their free-tier was quite good and offered what I needed (at the time of writing). I was not sponsored by them; I just found them when I was looking for a free API to use.

Building the App Modules

To begin, you'll need to create a new virtual environment for the app. If you aren't familiar with Python virtual environments, I have an article that goes over them here.

To create a virtual environment, run:

For macOS / Linux:

python -m venv venv

For Windows:

py -m venv venv

This will create a new virtual environment called venv.

Next, activate the virtual environment:

For macOS / Linux:

source ./venv/bin/activate

For Windows (make sure your PowerShell script execution policy allows for running scripts):

.\venv\Scripts\activate

With that setup, it's time to install some packages. To do that, simply run:

pip install customtkinter freecurrencyapi pillow python-dotenv

Next, create the following folders and files:

.
├── images
│   ├── header.png
│   └── icon.png
├── modules
│   ├── currency
│   │   ├── __init__.py
│   │   ├── convert.py
│   │   └── currency_list.py
│   ├── env
│   │   ├── __init__.py
│   │   ├── .env
│   │   └── env_vars.py
│   └── image_check
│       ├── __init__.py
│       └── image_check.py
├── main.py
└── requirements.txt

With that done, let's take a quick look at the folder structure:

images: This has an image for the apps icon and the header of the app.
modules: This has some custom modules that have been built for the app. I'll go over these when we get to the code.
venv: This is the virtual environment.

Before any code can be added, download the two images that stored in here on GitHub. One is an icon for the app and the second is a header for the top section of the app where the title till be shown.

Now let's go through the code for the app, starting with the modules/env folder.

First, open the .env file, paste in the below and save it.

API_KEY="change-me"

This contains a single environment variable that will be used to store the API key from freecurrencyapi. You just need to put it in between the parenthesis and save it.

Next open the env_vars.py file. Paste in the below code and save it.

# --- Import the required libraries / modules:
from dotenv import load_dotenv    
from tkinter import messagebox
import os


def load_env_vars() -> None:
    """_summary_
    This function is used to load the environment variables that are stored in the .env file
    in the same folder as this file.

    Returns:
        None: Nothing is returned.
    """

    # --- Load environment variables from .env file:
    try:
        # load_dotenv(dotenv_path = f"{BASE_DIR}/modules/env/.env", verbose=False)
        load_dotenv(dotenv_path = f"{os.path.abspath(os.path.join(os.path.dirname(__file__)))}/.env", 
                    verbose=False)

    except OSError as error:
        message = "Could not locate the .env file. Please check that the file is present."
        messagebox.showerror("Error", message)
        raise Exception(message)

    # --- Check to see if one of the environment variables is present. If not, raise an exception:
    if os.getenv("API_KEY") == None:
        message = "No environment variables were loaded. Please check the .env file exists."
        messagebox.showerror("Error", message)
        raise Exception(message)

This has a single function that will load the environment variable stored in the .env file and check that it loaded as expected, meaning if the value of the environment variable named API_KEY is anything but None, it is done. Also, if the .env file cannot be found, it will also raise an error in the form of a message box.

Next, open the image_check.py in the modules/image_check folder. Paste in the below code and save it.

# --- Import the required libraries / modules:
from PIL import Image, ImageTk
from tkinter import messagebox


def check_image_present(image_path: str, error_message: str) -> ImageTk:
    """_summary_
    This function will check if a file is present in the specified directory.
    Args:
        image_path (str): The full path and file name to check.
        error_message (str): The error that needs to be displayed.

    Raises:
        Exception: Raise an exception if the file is not present.

    Returns:
        ImageTk: The image.
    """
    try:
        image_file = Image.open(image_path)

    except FileNotFoundError as error:
        messagebox.showerror("Error", f"{error}.\n\n{error_message}")
        raise Exception(error)

    return image_file

This again has a single function which will check to see if an image is present and if so, it will load the image and return the image back to what called it. If it cannot be found, it will raise a message box with an error.

Now onto the final module, that being the modules/currency folder, which contains
two files.

First open the currency_list.py file. Paste in the below and save the file.

currencies: list = [
    'EUR - Euro (€)', 
    'USD - US Dollar ($)',
    'GBP - British Pound Sterling (£)',
    'JPY - Japanese Yen (¥)',
    'CNY - Chinese Yuan (CN¥)',
    'HKD - Hong Kong Dollar (HK$)',
    'CAD - Canadian Dollar (CA$)',
    'AUD - Australian Dollar (AU$)',
    'BGN - Bulgarian Lev (BGN)',
    'CZK - Czech Republic Koruna (Kč)',
    'DKK - Danish Krone (Dkr)',
    'HUF - Hungarian Forint (Ft)',
    'PLN - Polish Zloty (zł)',
    'RON - Romanian Leu (RON)',
    'SEK - Swedish Krona (Skr)',
    'CHF - Swiss Franc (CHF)',
    'ISK - Icelandic Króna (Ikr)',
    'NOK - Norwegian Krone (Nkr)',
    'HRK - Croatian Kuna (kn)',
    'RUB - Russian Ruble (RUB)',
    'TRY - Turkish Lira (TL)',
    'BRL - Brazilian Real (R$)',
    'IDR - Indonesian Rupiah (Rp)',
    'ILS - Israeli New Sheqel (₪)',
    'INR - Indian Rupee (Rs)',
    'KRW - South Korean Won (₩)',
    'MXN - Mexican Peso (MX$)',
    'MYR - Malaysian Ringgit (RM)',
    'NZD - New Zealand Dollar (NZ$)',
    'PHP - Philippine Peso (₱)',
    'SGD - Singapore Dollar (S$)',
    'THB - Thai Baht (฿)',
    'ZAR - South African Rand (R)'
]

This is a single Python list variable that contains a collection of currencies. This will be used to build the combo boxes that I'll cover later on.

Now, open the convert.py file. Paste in the below code and save the file.

# --- Import the required libraries / modules:
from decimal import *
from tkinter import messagebox

import freecurrencyapi
import os
import re


def check_value_is_numeric(value: str) -> bool | object:
    """_summary_
    This function takes a string value and attempts to convert it to a Decimal value.

    Args:
        value (str): The value that needs to be converted from a string to a Decimal.

    Returns:
        bool | object: If the value can be converted, it will return it as an object (Decimal). If not, it will return a bool.
    """

    # --- Check if the value is a string:
    if not isinstance(value, str):
        return False

    # --- Check if the value has a value:
    if not value:
        return False

    # --- Check for mathematical symbols
    if re.search(r'[+\-*/]', value):
        return False

    # --- Attempt to convert the value to a decimal number:
    try:
        convert_value = float(value)

    except ValueError:
        return False

    # --- Check if the value is over 0:
    if convert_value <= 0:
        return False

    # --- Return the converted value if all checks pass:
    return Decimal(convert_value).quantize(Decimal('.0001'), rounding=ROUND_DOWN)


def get_exchange_rate(from_currency: str, to_currency: str) -> object:
    """_summary_
    This function will get the current exchange rate for 1 of the from_currency and how much it will be in the to_currency.

    Args:
        from_currency (str): the currency to convert from.
        to_currency (str): The currency to convert to.

    Raises:
        Exception: Raise an exception if either currency is not valid.

    Returns:
        object: Returns a Decimal object with the value of the converted currency.
    """

    client = freecurrencyapi.Client(api_key = os.getenv("API_KEY"))

    try:
        result = client.latest(base_currency = from_currency, currencies = [to_currency])
    except:
        messagebox.showerror("Error", "Please check the currencies list as one of the symbols was not recognised. Also, check to see if the API key is entered correctly.")
        raise Exception

    return Decimal(result["data"][to_currency]).quantize(Decimal('.0001'), rounding=ROUND_DOWN)


def convert_currency(from_currency: str, to_currency: str, value: object) -> object:
    """_summary_
    This function will convert a value from one currency to another and return the converted value.

    Args:
        from_currency (str): The currency code to convert from.
        to_currency (str): The currency code to convert to.
        value (float, optional): The value to convert from.

    Returns:
        object: The converted value as a Decimal.
    """

    from_currency_code = from_currency.split(sep = " ")[0]
    to_currency_code = to_currency.split(sep = " ")[0]

    exchange_rate = get_exchange_rate(from_currency = from_currency_code, to_currency = to_currency_code)

    return Decimal(value * exchange_rate).quantize(Decimal('.0001'), rounding=ROUND_DOWN)

There are three functions. The first one, check_value_is_numeric will take a string, check if the value contains any mathematical operators and then attempt to convert the string to a float. If either of these fails, it will return False to the caller. More on that later. If all goes well, the returned value will be a Decimal object with the value to convert in it.

The next function, get_exchange_rate will take the currency to convert from and to, attempt to call the API for a unit of 1 for the from currency and get the converted amount back. If it fails, a message box will appear. If the value is numeric, it will be converted to a float and then to a Decimal object that is returned to the caller.

The last function, convert_currency will take the value to convert, along with the currency to convert from and to. It will then take the first three digits of the from and to currencies and set them as variables to be used. The next part will then call the get_exchange_rate function to set the exchange_rate variable. Lastly, it will return the converted amount, which is set to four decimal places and rounded down.

Main File

With the modules covered, the last file for the app is the main.py file at the root of the app. This will tie it all together and build the user interface.

Open the main.py and paste in the below code and then save it.

# --- Import the required libraries / modules:
from customtkinter import *
from PIL import ImageTk
from tkinter import messagebox

from modules.env.env_vars import load_env_vars
from modules.currency.currency_list import currencies
from modules.currency.convert import convert_currency, check_value_is_numeric
from modules.image_check.image_check import check_image_present

import os


def main() -> None:
    """_summary_
    This is the main function for the application
    """

    # --- Load the environment variables:
    load_env_vars()

    # --- Get the absolute path for main.py:
    BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__)))

    # --- Check to see if the icon image is present and apply it if so:
    icon_check = check_image_present(image_path = f"{BASE_DIR}/images/icon.png", 
                                     error_message = f"Check that the icon file exists in that directory with the name icon.png.\n\nPress Ok to close.")

    header_check = check_image_present(image_path = f"{BASE_DIR}/images/header.png", 
                                       error_message = f"Check that the header image file exists in that directory with the name icon.png.\n\nPress Ok to close.")

    # --- Set the name and defaults for the app:
    app_name: str = "Currency Converter"
    default_font_size: int = 24

    # --- Setup the application and window:
    app = CTk()
    app.title(app_name)
    app.geometry(geometry_string = "450x840")
    app.resizable(width = False, height = False)

    # --- Set the icon for the app:    
    icon = ImageTk.PhotoImage(icon_check)
    app.wm_iconphoto(True, icon)

    # --- Set icon for Windows 10 / 11:
    app.wm_iconbitmap()

    # --- Define the variables to store the combo boxes values:
    from_currency: StringVar = StringVar()
    to_currency: StringVar = StringVar()

    # --- Build the UI --- #

    # --- 1. The header for the app with the name:
    header_image = CTkImage(light_image = header_check, 
                            dark_image = header_check, 
                            size = (450, 160))

    header_label = CTkLabel(master = app, width = 450, height = 160, 
                            text = app_name, font=("", 38),image = header_image,
                            text_color = "white")
    header_label.grid(row = 0, column = 0)


    # --- 2. The frame and entry box for the value to convert:
    value_frame = CTkFrame(master = app, width = 400, height = 150)
    value_frame.grid(row = 1, column = 0, padx = 10, pady = 10, sticky = "nesw")

    value_label = CTkLabel(text = "Convert:", master = value_frame, width = 413, 
                           font=("", default_font_size), anchor = "w")
    value_label.grid(row = 0, column = 0, padx = 10, pady = 10)

    value_entry = CTkEntry(master = value_frame, width = 413, 
                           placeholder_text = "Enter a number to convert", 
                           font=("", default_font_size), justify = CENTER)
    value_entry.grid(row = 1, column = 0, padx = 10, pady = 5)


    # --- 3. The frame and combo box for the currency to convert from:
    convert_from_frame = CTkFrame(master = app)
    convert_from_frame.grid(row = 2, column = 0, padx = 10, pady = 10, sticky = "nesw")    

    from_currency_label = CTkLabel(text = "From:", master = convert_from_frame, width = 413, 
                                   font=("", default_font_size), anchor = "w")
    from_currency_label.grid(row = 0, column = 0, padx = 10, pady = 10)

    from_currency_code = CTkComboBox(master = convert_from_frame, width = 413, values = currencies, 
                                     font=("", default_font_size), justify = LEFT, 
                                     variable = from_currency, state = "readonly")
    from_currency_code.grid(row = 1, column = 0, padx = 10, pady = 5)       
    from_currency_code.set(currencies[0])


    # --- 4. The frame and combo box for the currency to convert to:
    convert_to_frame = CTkFrame(master = app)
    convert_to_frame.grid(row = 3, column = 0, padx = 10, pady = 10, sticky = "nesw")

    to_currency_label = CTkLabel(text = "To:", master = convert_to_frame, width = 413, 
                                 font=("", default_font_size), anchor = "w")
    to_currency_label.grid(row = 0, column = 0, padx = 10, pady = 10)

    to_currency_code = CTkComboBox(master = convert_to_frame, width = 413, values = currencies, 
                                   font=("", default_font_size), justify = LEFT, 
                                   variable = to_currency, state = "readonly")
    to_currency_code.grid(row = 1, column = 0, padx = 10, pady = 5)
    to_currency_code.set(currencies[1])


    # --- 5. The frame and label for the converted amount to be shown in. No value initially is shown:
    to_currency_value = CTkLabel(master = app, width = 413, height = 260, 
                                 text = "The converted amount\nwill be shown here.", 
                                 font=("", default_font_size), justify = CENTER)
    to_currency_value.grid(row = 4, column = 0, padx = 10, pady = 5)


    # --- 6a. The function that is used by the convert button to perform the currency conversion:
    def convert_currency_button_command() -> None:
        """_summary_
        This function will check that the value to convert is valid (numeric and > 0). If so, it will then convert it.

        Raises:
            Exception: If a boolean is returned, an error message will be shown indicating that the value entered is not valid.
        """

        # --- 1. Check that the from and to currencies are not the same:
        if from_currency.get() == to_currency.get():
            messagebox.showinfo("Info", f"Both the from and to currencies are the same. Please specify a different one for one of the two currencies.")
            raise Exception()

        # --- 2. Check that the value is numeric:
        convert_from_value = check_value_is_numeric(value = value_entry.get())

        if convert_from_value == False:
            messagebox.showerror("Error", f"Please check the value you entered is a number and it is higher than 0.")
            raise Exception()

        # --- 3. If so, perform conversion:
        converted_value = convert_currency(from_currency = str(from_currency.get()), 
                                           to_currency = str(to_currency.get()), 
                                           value = convert_from_value)

        # --- 4. Update the to_currency_value label with the original and converted currencies:
        to_currency_value.configure(text = f'{convert_from_value} {str(from_currency.get()).split(sep = " ")[0]}\n=\n{converted_value} {str(to_currency.get()).split(sep = " ")[0]}')


    # --- 6b. The button to execute the conversion and update the to_currency_value label:
    convert_button = CTkButton(master = app, text = "Convert", font=("", default_font_size), 
                               fg_color="green", hover_color=("#38B215"), 
                               height = 50, command = convert_currency_button_command)
    convert_button.grid(row = 5, column = 0, padx = 10, pady = 10, sticky = "nesw")


    # --- Keep the window active until it is closed:
    app.mainloop()


if __name__ == "__main__":    
    main()

To cover the main points:

First, there are the libraries and modules that need to be imported
Next, there is a main function that contains the code to bring the app together. This includes:
- Loading the environment variables (load_env_vars)
- Get the base directory for the main.py file
- Check to see if the app icon image is present (icon_check). If not, a message box with an error will appear
- Do the same again but for the header image (header_check).
- After that, set some defaults for the app (app_name and default_font_size)
- Then, instantiate the app and set the window size. Also, set it so that it cannot be resized.
- Next, set the icon for the app. This will be shown in the dock or task bar.
- Then, define two variables that will store the from and to currencies.
- Now to build the user interface:
- First, there is the header image, along with a label to show the apps name
- Next, a frame, label and entry field that is used by the user to enter the amount they want to convert
- Then there is a similar layout for the from currency but instead of an entry field, there is a combo box. The combo box gets its values from the currencies Python list in the currencies_list file that was imported
- Below that, there is the same but for the to currency instead
- Next, there is a label that will show the amount from and to once a conversion is done. Otherwise, it will just show The converted amount will be shown here
- After that, there is a function that is used to perform a number of actions when the convert button is clicked. These are:
  - Checking that the from and to currencies are not the same. If so, show a message box asking the user to change one
  - Check if the value is numeric. If not, show a message box asking the user to change the value to a number
  - Perform the conversion if all of the above are good
  - Update the to_currency_value text to show the from and to currency values
- The last part of the UI is the convert button that will call the convert_currency_button_command when clicked
- And lastly for the main function, keep the window open until the user closes the app
The last part of the main.py file will call the main function if the name is main.

With that all done, you can run the app by running:

For macOS / Linux:

python main.py

For Windows:

py main.py

Here is an example of what the app will look like:

And there we have it. A currency converter, made with customTKinter that uses an API to get the conversion rate and then presents the converted amount to the user.

I hope you found that to be of interest. Thanks for reading and have a nice day!

Working With Dates And Times In Python

dev_neil_a — Fri, 15 Nov 2024 12:30:00 +0000

Introduction
YouTube Video
Using The datetime Python Library
- Displaying The Current Date And Time
- Displaying The Current Date
- Displaying The Current Time
- Calculate The Difference Between Two Dates
- Calculate The Difference Between Two Times
- Calculate The Difference Between Two Dates And Times
- Converting Between Date Formats
- Working With Dates / Times In Different Timezones
Conclusion
References

Introduction

Working with dates and times is something that comes up frequently when building solutions with any programming language. Most languages, including Python, will have a library built-in that can be used to work with dates and time.

For Python, there is a built-in library called datetime that can be used to simplify working with dates and time based data.

If you would like a copy of the code examples for this article, the files are available on my GitHub page.

YouTube Video

If you would prefer to watch a video of this article, there is a video available on YouTube below:

Using The datetime Python Library

As the datetime library is built-into Python, there is nothing, other than Python, to install. Let us look at some examples of how to use the datetime library.

Displaying The Current Date And Time

First, let's get the current date and time:

from datetime import date, datetime, time, timedelta


# --- Get the current date and time:
print(f"Date & Time: {datetime.now()}\n")

Output:

Date & Time: 2024-11-12 17:29:29.030497

Using datetime.now() provides both the current date and time of the system it was run on.

By default, the date is formatted as year-month-day. This is known as the ISO 8601 standard date format.

Displaying The Current Date

Now let's get just the current date:

# --- Get just the current date:
print(f"Date: {datetime.now().date()}\n")

Output:

Date: 2024-11-12

The syntax is very much the same as getting the date and time but adding .date() to the end will display only the date.

Displaying The Current Time

Next, let's get just the current time:

# --- Get just the current time:
print(f"Time: {datetime.now().time()}\n")

Output:

Time: 17:29:29.030522

This is basically the same as getting just the date but instead of adding .date() to the end, adding .time() returns just the time.

Calculate The Difference Between Two Dates

Working out the difference between two dates and / or times is something that is done frequently. First, let's look at an example of how to work out the time difference between two dates:

# --- Show the difference between two dates:
date_one = date(year=2024, month=11, day=7)
date_two = date(year=2023, month=11, day=6)

print(f"The first time difference is: {date_one - date_two}\n")

Output:

The first time difference is: 367 days, 0:00:00

For each of the two date variables, a date is specified using the datetime.date() method, with a year, month and day specified for each.

From there, a simple subtraction of one from the other is performed to work out the difference. You can also use addition as well.

Calculate The Difference Between Two Times

Now, let's look at another example but instead of showing the difference between two dates, show the difference between two times:

# --- Show the difference between two times:
time_one = timedelta(hours = 15, minutes = 52)
time_two = timedelta(hours = 13, minutes = 58)

Output:

The second time difference is: 1:54:00

This is very similar to the previous date example but it uses timedelta() to set the time. Using time() is not an option as it doesn't allow for mathematical operations to be performed against it.

Calculate The Difference Between Two Dates And Times

To wrap up working out the differences between dates or times, let's take a look at an example of how to work out the difference between two dates and times:

# --- Show the difference between two dates and times:
date_time_one = datetime(year = 2023, month = 4, day = 22, 
                         hour = 11, minute = 52, second = 25)

date_time_two = datetime(year = 2022, month = 3, day = 22, 
                         hour = 13, minute = 58, second = 57)

print(f"The third time difference is: {date_time_one - date_time_two}\n")

Output:

The third time difference is: 395 days, 21:53:28

This method basically uses the same method as working out the difference between two dates or times with additional arguments being passed for the hours, minutes and seconds. Milliseconds can also be passed, if needed.

Converting Between Date Formats

Working with different formatted dates is another common occurrence. There are three main date formats that are typically used:

Year, Month, Day (ISO standard, which is Python's default format)
Day, Month, Year (European standard)
Month, Day, Year (U.S.A standard)

Converting between these formats in Python is easy to do with the datetime library. The following example will show how to convert from the ISO format to both the European and U.S.A standard formats:

# --- Convert to European and U.S.A based date formats (dd-mm-yyyy / mm-dd-yyyy):
current_date = datetime.now()

print(f"Default Date Format: {current_date.date()}")
print(f"Current Time: {current_date.strftime('%H:%M:%S')}\n")
print(f"U.S.A Date Format: {current_date.strftime('%m/%d/%Y')}")
print(f"U.K Date Format: {current_date.strftime('%d/%m/%Y')}\n")

Output:

Default Date Format: 2024-11-12
Current Time: 17:29:29

U.S Date Format: 11/12/2024
U.K Date Format: 12/11/2024

The above example sets the current_date variable to the current date and time. That is then used to convert the date using the strftime() method to the format that is required.

To explain what the %m/%d/%Y and %d/%m/%Y mean inside the strftime() method:

%m is the month as a number
%d is the day
%Y is the full year (2023 for example)
/ is used as the separator. It can be anything but it is best to use / or a -

If the month needs to be the full name, rather than a number, change it from %m to %B.

The date would then be 22/April/2023 or April/22/2023. This output format doesn't look ideal so change the output format to %d %B, %Y (22 April, 2023) or %B %d, %Y (April 22, 2023), both of which are more standard formats.

As for the Current time shown:

%H is for the hours
%M is for the minutes
%S is for the seconds
: is the separator

Working With Dates / Times In Different Timezones

Last but not least, let's take a quick look at working with different timezones.

Now, up until Python 3.9, I typically would have used the third-party library called pytz but as of Python 3.9, is has pretty much been deprecated. The reason is that there is now a library in the standard Python library collection called zoneinfo that does most of what pytz provided.

Let's take a look at some examples.

First, let's see what timezones are available in the zoneinfo library:

# --- Import the required libraries / modules:
from datetime import datetime
from zoneinfo import available_timezones, ZoneInfo


# --- Show all of the available timezones:
print(available_timezones())

The output is far too long to show but all of the options in the (Python) set it produces can be used to take a date and time and convert it to the appropriate timezone. It won't however though convert the date format to the region of that timezone so that will need to be done manually, if required.

If you would like to see the list of timezones in a spreadsheet, there is one in the GitHub repository I linked at the beginning of this article.

First, define a format for the output of the date, time and timezone to be in and show an example:

# --- Set the format for the date, time and timezone to be shown:
datetime_format = '%d/%m/%Y, %H:%M:%S %Z (%z)'


# --- Get the local time (U.K in my case)
local_date_time = datetime.now()


# --- Display the local date, time and timezone:
print(f"Local Time: {local_date_time.strftime(datetime_format)}\n")

Output:

Local Time: 12/11/2024, 15:28:16  ()

A couple of points to observe here. First, in the datetime_format = '%d/%m/%Y, %H:%M:%S %Z (%z)' variable, the %Z indicates the name of the timezone to display and the %z will display the time difference in hours.

Lastly, the Local Time output has a set of parentheses (()) at the end of it with nothing inside. The reason is because when datetime.now() is used on its own, it doesn't include the timezone. To add the timezone to that, there are two ways to do it:

Use tz='name-of-timezone' in the parentheses of datetime.now(). For example: datetime.now(tz = ZoneInfo("Europe/London")). This would ensure that it works with the Europe/London timezone no matter what it is run on.
Alternatively, use datetime.now().astimezone() to use the current timezone of the system it is running on.

For example:

# --- Get the local time (U.K in my case)
# --- Method one, hard coding the timezone:
local_date_time = datetime.now(tz = ZoneInfo("Europe/London")) # not adding tz does not show timezone for uk

# --- Or

# --- Method two, getting the current timezone from the system:
local_date_time = datetime.now().astimezone() # This method gets the current system tz instead of hard coding as above


# --- Display the local date, time and timezone:
print(f"Local Time: {local_date_time.strftime(datetime_format)}\n")

Local Time: 12/11/2024, 15:28:16  ()
Local Time: 12/11/2024, 15:28:16 GMT (+0000)

Lastly, the following example will show a number of timezone conversions for different timezones in different regions / continents in the date format used in the U.K which will build on what has been done so far:

# --- List all of the timezones to use:
locations = [
    {
        "location": "Paris",
        "timezone": "Europe/Paris"
    },
    {
        "location": "Washington D.C",
        "timezone": "US/Eastern"
    },
    {
        "location": "Canberra",
        "timezone": "Australia/Canberra"
    }
]


# --- Display the local date, time and timezone:
print(f"Local Time: {local_date_time.strftime(datetime_format)}\n")


# --- Display the date, time and timezone from the list:
for location in locations:
    print(f"{location['location']} Time: {local_date_time.astimezone(tz = ZoneInfo(location['timezone'])).strftime(datetime_format)}")

Output:

Local Time: 12/11/2024, 15:28:16  ()

Local Time: 12/11/2024, 15:28:16 GMT (+0000)

Paris Time: 12/11/2024, 16:28:16 CET (+0100)
Washington D.C Time: 12/11/2024, 10:28:16 EST (-0500)
Canberra Time: 13/11/2024, 02:28:16 AEDT (+1100)

There is also the option to use UTC time instead but that is out of the scope of this article.

Conclusion

Working with dates and times is something that is done a lot in Python (along with other languages). The examples shown are some of the most common tasks that I do the most often, outside of using Pandas.

There are many other options for working and manipulating date and time data so feel free to look at the documentation in the references section.

In closing, I hope this article was useful and have a nice day!

References

Documentation for the datetime library:

https://docs.python.org/3/library/datetime.html

Documentation for the timezone library:

ttps://docs.python.org/3/library/zoneinfo.html

Creating and Using Python Virtual Environments

dev_neil_a — Tue, 05 Nov 2024 12:06:17 +0000

YouTube Video
Introduction
What is a Python Virtual Environment
When to use a Virtual Environment with Python
Setting up a Python Virtual Environment
- Prerequisites
- Checking the Current Package List
- Creating a Project
- Creating a Virtual Environment
- Activate and Deactivate a Virtual Environment
- Install a Package in a Virtual Environment
- Remove a Package in a Virtual Environment
- Python Example Program
- Pip Freeze and the Requirements.txt File
- Deploying to a New Folder
References

YouTube Video

If you would prefer to watch a video of this article, there is a video available on YouTube below:

Introduction

Hello and welcome. In this article I'll be going over how to setup a Python virtual environment for a project on Linux or macOS.

By the end of this article, the topics that will be covered are:

What a virtual environment is
Setting up a virtual environment with Python
Creating a simple Python program in a virtual environment that makes an HTTP request to a web page and displays the raw contents of the page

What is a Python Virtual Environment

So what is a virtual environment in the Python world? Well, Typically, with a Python project,
there are a set of dependencies in the form of packages that a developer would need to install and use.

Some of these are included with Python and others are installed with a tool such as pip.

A virtual environment is mainly used to:

Isolate dependencies that are used in a project
Removes the possibility of conflicts with programs that were developed with an older version of a package
Make the project transportable between different systems
- A list of packages can be exported to a file to make setting it up on another system very easy
Specify a particular version of Python and / or a package to use

Now, Why would you need to specify a version of Python to use you may ask? The reason is that some packages may only work with certain versions of Python.

For example, say a new version of Python is released and is installed on a system. A package may not work on that version as it may not have been updated to work with it and as a result, could cause unexpected issues.

I've had that happen a few times so always check that the package is supported. The easiest way to check is to search for the package on PyPi (a Python package repository) and look at the the tags in the description of the package which version is the highest supported.

For example, if you search for the requests package on PyPi, in the description (shown below in red) you can see it requires Python 3.8 or above and the highest supported version being 3.12 (as of November 2024).

Another reason is that a vendor may state that a particular version of Python is required for their solution to run and the system it will be running on may have multiple versions of Python installed for different products or projects.

When to use a Virtual Environment with Python

It is recommended to use a virtual environment for every project. Now, there are some cases where this would be a waste of time, such as print("Hello World!") but they are few and far between.

Setting up a Python Virtual Environment

Prerequisites

Before you can use Python virtual environments, you'll need:

A version of Python 3 installed, along with the pip command
A terminal application, such as the one built into your O/S or a third-party one

For reference, in this article, the version of Python used was 3.12.7 and iTerm2 was the terminal application used on macOS.

Checking the Current Package List

The first thing to do is to see what packages are currently installed at the operating system / global level. What this means is what Python packages are installed that can be used without the use of a virtual environment.

To see what packages are installed, run:

pip list

The output will be similar to the below (your list will likely be different)

Package      Version
------------ ---------
certifi      2024.8.30
cffi         1.17.1
cryptography 43.0.3
packaging    24.1
pip          24.2
pycparser    2.22
wheel        0.44.0

This is the list of installed packages that are available at the global level.

Creating a Project

Before a virtual environment can be created, a folder for storing all the files for the project needs to be created. For this project, create a folder in the Downloads folder called example and change to that directory. To do this, run:

cd Downloads
mkdir example
cd example

With the project folder setup, a virtual environment can now be created.

Creating a Virtual Environment

To create a virtual environment, there are two ways to do it. The first is with the virtualenv package and the second is to use the built-in venv module in Python. For this project, the venv module method will be used.

Next, run the following command:

python3 -m venv venv

To go over what the command does:

python3 is the python 3 program to use
-m indicates a module is to be run
The first venv is the name of the module
The second venv is the name of the folder that will be used for the virtual environment

Run the ls -lha command to see the newly created venv folder.

By default, the virtual environment will use the version of Python that is the default on your operating system. If you wish to use a different version, specify that version instead. For example, use python3.11 instead of python3 to use Python 3.11.

If you use the project on another system, you will need to ensure it has the same version of Python installed and you specify that version when you recreate the virtual environment if it isn't the default on that system.

Activate and Deactivate a Virtual Environment

Once the virtual environment has been created, it now needs to be activated. If it isn't activated it will install any packages at the system / global level.

To activate it, run the following command in the folder for the project:

source ./venv/bin/activate

Now, depending upon how (or if) you have customised your terminal, you should see venv show up on your command prompt. On a default bash or zsh terminal, it should look like the below.

bash:

(venv) bash-5.1$

zsh:

(venv) user@My-MacBook-Pro project

The virtual environment is now active. To check this, you can run the pip list command again. You will notice that the list is different from before.

If you need to exit the virtual environment, run deactivate at the command line. You will see that (venv) is no longer shown in your command prompt. You can reactivate it by running the the source ./venv/bin/activate command again.

Also, if you close the terminal, this will also deactivate the virtual environment.

For now, please ensure the virtual environment is active.

Install a Package in a Virtual Environment

To install a package into a Python virtual environment, it is no different than installing it at the global level using pip.

For this project, install the requests and zipp packages using pip by running:

pip install requests zipp

Once the installation is finished, run pip list again and you should see the two packages installed, along with some others that were installed as dependencies for the requests and zipp packages. It should look similar to the below:

(venv) bash-5.2$ pip list
Package            Version
------------------ ---------
certifi            2024.8.30
charset-normalizer 3.4.0
idna               3.10
pip                24.2
requests           2.32.3
setuptools         74.1.2
urllib3            2.2.3
zipp               3.20.2

The packages that are listed above will be isolated from the any other Python virtual environment and the system. This means that if you didn't use the virtual environment and tried to use the requests package / library, it will not work unless you install it into that environment.

Remove a Package in a Virtual Environment

Removing a package is very much the same as installing a package but you need to use uninstall instead. Run the following command to uninstall the zipp package as it will not be used:

pip uninstall zipp

Once the uninstall is finished, run pip list again and you should see the zipp package in no longer listed.

Package            Version
------------------ ---------
certifi            2024.8.30
charset-normalizer 3.4.0
idna               3.10
pip                24.2
requests           2.32.3
setuptools         74.1.2
urllib3            2.2.3

Python Example Program

Now that the requests package is installed, let's use it. But what does it do?

The requests package, if you haven't used it before, is used to make HTTP / HTTPS requests to a website and bring back the contents of the page as raw HTML. It can do a number of other things but for this project, it will be used for making a simple HTTP / HTTPS request and reading the contents of the response.

First, run the nano text editor and create a file called main.py:

nano main.py

Once nano is opened, copy and paste the below (you can change the contents of the url variable to a different site if you want):

# --- Import the required modules / libraries:
from requests import request
from pprint import pprint


# --- Define the variables used
url = "https://www.mirrorservice.org/"
get_request = request(url=url, method="GET")


# --- Show the HTML of the page
pprint(get_request.text)


# --- Show the status code of the request (200 is OK)
print(f"\nHTTP Response Code Is: {get_request.status_code}")

Next, save the file by pressing CTRL+x and then press y when asked about saving the buffer. Press enter when asked for the file name.

This will now take you out of nano and back to the command prompt.

To see what the application does, run the following command:

python3 main.py

The result should be a bunch of HTML and a line at the bottom that states HTTP Response Code Is: 200.

If the program was run without the virtual environment being active, it would throw a Module not found error as requests is not installed at the global level.

Pip Freeze and the Requirements.txt File

The next step is to begin making the program transportable to another system.

To start with, a list of all the packages that are installed in the virtual environment needs to be catalogued into a file that can be used to reinstall the packages.

The reason for doing this is that we don't copy the virtual environment. Instead you recreate it on the destination system. One reason is that adding a large number of packages can take a long time to push up to GitHub and can also cause capacity limit warnings when pushing to GitHub or another source control providers.

To get the list of installed packages and put them into a text file, use the pip freeze command in the following way:

pip freeze > requirements.txt

Run ls -lha and a new file called requirements.txt is now present. To view the contents, run more requirements.txt. It will look similar to the below:

certifi==2024.8.30
charset-normalizer==3.4.0
idna==3.10
requests==2.32.3
urllib3==2.2.3

The file contains the name and the exact version of each package that is installed in the virtual environment. This will allow for project to be deployed to another system and use those exact same versions of the packages when you install them.

During a projects development, you may need to add additional packages after you have created the requirements.txt file. As a good practice, I'd recommended that the requirements.txt file be recreated when a new package is installed so that there are no missing dependencies later on.

Deploying to a New Folder

For the final step, let's perform a mock deployment to another system by using a different folder on you computer. The steps to do this are basically what you have already done with some minor tweaks:

Open a new terminal tab or window
Go to the location where you want to store the project files
Create a new folder. Name it what you want
Go into that folder
Copy the main.py and requirements.txt file into that folder
Create a new virtual environment the same way as you did before
Activate the new virtual environment the same way as you did before

The only difference this time is rather than using pip install {package-1} {package-2} {package-3} to install the packages, use the requirements.txt file instead to bulk-install them at the same version was to develop the project with. To do this, run the below command:

pip install -r requirements.txt

The -r switch implies that pip needs to read the contents of the requirements.txt file to get a list of the packages to install.

If you then run pip list, you will see all the packages installed as they were previously. You can then run python3 main.py again, with the results being the same (although the page may have been updated by the site maintainer).

If you were deploying to another system, the only thing you would do differently is to first connect to the system, typically via SSH on Linux and then do the above steps. Make sure that you have the version of Python installed on that system that was used to develop the project.

This concludes how to setup and use a virtual environments with Python.

References

References used for parts of this article:

Building A Weather Station with a Raspberry Pi and Python - Part Two

dev_neil_a — Tue, 29 Oct 2024 13:01:00 +0000

Table of Contents
YouTube Video
Introduction
Creating The Modules Folders
Setting Up the Logging Module
Setting Up the Environment Variables Module
Setting Up the Sensors Module
Setting Up the Displays Module
Bringing the Program Together
Error Log Examples
Wrapping-up Part Two Plus What's Next

YouTube Video

If you would prefer to watch a video of this article, there is a video available on YouTube below:

Introduction

Hello and welcome. In this second part of a three-part series of articles on building a weather station with a Raspberry Pi, were going to be making the code base more modular. In addition, environment variables will be added to the program to make it easier to configure for different hardware configurations.

Lastly, logging will be added to the program so that it logs any errors incurred to a log file to help with making diagnosing issues easier.

With that said, let's crack on.

Creating The Modules Folders

To start, rename the main.py file to main-part-one.py and create a new file named main.py. The reason for this is that due to the number of changes that will be made, it will be easier to start with a new file, but a good amount of what was done in part one will be used again.

Next, create a new folder at the root of the project folder called modules. In that folder, create four new folders called:

displays
env
logging
sensors

Next, in each of those four folders, create a file named __init__.py. Close each file when they open as there will be no changes to be made to them. These files are used by Python to indicate the folder contains a module.

With the folders created, let's get started with building the first module.

Setting Up the Logging Module

The first module that will need to be setup is the logging module. This will allow the program to record any errors that are encountered in the program to a file so that in the event of an error occurring, it can be used to diagnose what caused the error and why.

First, create a new file in the logging folder called log_config.py and open it if it doesn't do so automatically.

In the file, paste in the following code:

# --- Import the required libraries / modules:
import logging
import os


def load_logging():
    """_summary_
    This function will setup the logging facility for the program.

    Returns:
        None: Nothing is returned.
    """

    # --- Get the root folder path that the app is stored in:
    LOG_FOLDER_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..", "logs"))

    # --- Check if the log folder exists. If not, create it:
    if os.path.exists(LOG_FOLDER_PATH) == False:
        os.mkdir(path = LOG_FOLDER_PATH)

    # --- Setup the logging:    
    log_file = f"{LOG_FOLDER_PATH}/error.log"

    # --- Define the configuration for the logging:
    logging.basicConfig(filename = log_file, 
                        encoding = "utf-8", 
                        level = logging.ERROR,
                        format='%(levelname)s:%(asctime)s:%(name)s:%(message)s')

Now, let's review what was put into the file:

First, there are the modules that need to be imported for this module
Next, there is a function called load_logging. In that function, it will:
- Create a variable called LOG_FOLDER_PATH that points to a folder in the root of the project called logs
- After that, if the “logs” folder does not exist, it will be created
- Then, a variable called log_file is defined for the location, along with the name of the log file to use
- Lastly, some additional settings for the logging are defined. These are:
  - Where to store the logs
  - The text encoding format to use
  - The starting level for capturing logs (in this case, error or above) and
  - The format for each log entry. In this case it will be:
    - The level (error for example)
    - The date and time
    - The name of the module that caused the error and finally
    - The error message

Save the file and close it.

With the logging module created, let's move onto setting up the environment variables module.

Setting Up the Environment Variables Module

For this module, there is an additional library that needs to be installed called python-dotenv. This is used to create environment variables from within a Python program. To install it, run the below in the terminal:

pip3 install python-dotenv

Next, In the env folder, create a new file called .env. This file will contain the environment variables that will be used in the program. Open the file if it didn’t open automatically and paste in the below:

OUTPUT_TO_CONSOLE="true"
LCD_SCREEN_CONNECTED="true"
LCD_SCREEN_TYPE="20x4"
ENV_SENSOR_TYPE="bme280"

The four environment variables are self-explanatory in what they are used for.

Save .env and close the file.

Next, create a new file called env_vars.py in the env folder. Once the file is open, paste in the below code:

# --- Import the required libraries / modules:
from dotenv import load_dotenv    

import os
import logging


# --- Get the currently active logger:
log = logging.getLogger(__name__)


def load_env_vars() -> None:
    """_summary_
    This function is used to load the environment variables that are stored in the .env file
    in the same folder as this file.

    Returns:
        None: Nothing is returned.
    """

    # --- Load environment variables from .env file:
    try:
        # load_dotenv(dotenv_path = f"{BASE_DIR}/modules/env/.env", verbose=False)
        load_dotenv(dotenv_path = f"{os.path.abspath(os.path.join(os.path.dirname(__file__)))}/.env", 
                    verbose=False)
    except OSError as error:
        message = "Could not locate the .env file. Please check that the file is present."
        log.error(message)
        raise Exception(message)

    # --- Check to see if one of the environment variables is present. If not, raise an exception:
    if os.getenv("LCD_SCREEN_CONNECTED") == None:
        message = "No environment variables were loaded. Please check the .env file exists."
        log.error(message)
        raise Exception(message)

Now, let's review what was put into the file:

First, there are the modules that need to be imported for this module
Then, there is a variable called log that will be used to interact with the logger that is running. That will be setup in the main.py file later
After that, there is a function named load_env_vars which will be called when the program runs to setup all the environment variable in the .env file. In this function, it will:
- Attempt to load the environment variables and if it can't, it will write an error to the log file and exit the program.
- If the environment variables do get loaded, it will then check one to see if it loaded and if it has a value. If that value is None, again, a log entry will be written, and the program will close.

Save the file and close it.

That covers setting up the environment variables module. Next up is the sensor's module.

Setting Up the Sensors Module

The sensors module will be a little different from the previous two, in that it has two functions in the file, rather than just one. I will add each function one-by-one and then go over them.

To start with, create a new file in the sensors folder called sensors.py and open it if it didn’t do so automatically.

First, copy and paste the below code. It will be the modules and libraries that are required for all functions in this file, along with the code for the first function named initialise_sensor.

# --- Import the required libraries / modules:
from adafruit_bme280 import basic as adafruit_bme280

import board
import logging


# --- Get the currently active logger:
log = logging.getLogger(__name__)


# --- Attempt to initialise the sensor on the i2c bus using the default values:
def initialise_sensor() -> object:
    """_summary_
    This function provides the application with the methods required to
    interact with an Adafruit bme280 sensor.

    Returns:
        class: An object that contains the methods for interacting with 
               an Adafruit bme280 sensor.
    """

    # --- Initialise the i2c interface for the sensor:
    try:
        i2c = board.I2C()  # --- uses board.SCL and board.SDA. Add i2c interface number.
    except OSError as error:
        message = "Unable to connect to the i2c interface. Please check that it is enabled."
        log.error(message)
        raise Exception(message)
    except ValueError as error:
        message = "Unable to connect to the i2c interface. Please check that it is enabled."
        log.error(message)
        raise Exception(message)

    # --- Initialise the bme280 sensor:
    try:
        sensor = adafruit_bme280.Adafruit_BME280_I2C(i2c)
    except OSError as error:
        message = "No sensor board was found. Please check that it is connected."
        log.critical(message)
        raise Exception(message)
    except ValueError as error:
        message = "No sensor board was found. Please check that it is connected."
        log.critical(message)
        raise Exception(message)

    # --- change this to match the location's pressure (hPa) at sea level.
    sensor.sea_level_pressure = 1027

    return sensor

Let's go over what was put in the file.

First, there is the libraries and modules needed for the contents of the file, along with the log variable again.

Then there is the first function. The purpose for this one is to initialise the sensor and return an object with all the settings to work with the sensor back to the caller. Most of the code you may remember seeing in part one as it is mostly the same but summarise it:

The first try block will attempt to initialise the i2c interface on the Raspberry Pi. If it can't, it will write an error to the log file and exit the program
The last try block will attempt to initialise the sensor board on the i2c interface. If it can't, it will write an error to the log file and exit the program
If all is well, then the sea level pressure is set on the sensor object and
Finally, the sensor object is returned to the caller

Add three empty lines and then paste in the below code:

def get_readings(sensor: object) -> dict:
    """_summary_
    This function will make a call to the sensor to get the current sensor readings and
    store them in a dictionary that will be returned to the caller.

    Args:
        sensor (object): This is the object containing the initialised sensor object.

    Returns:
        dict: Returns a dictionary with the keys / values for the temperature, 
              humidity, pressure and altitude. All values are floats, rounded to
              two decimal places.
    """

    try:
        readings = {
            "temperature": round(float(sensor.temperature), 2),
            "humidity": round(float(sensor.humidity), 2),
            "pressure": round(float(sensor.pressure), 2),
            "altitude": round(float(sensor.altitude), 2)
        }
    except OSError as error:
        message = f"Unable to get readings from the sensor. Please check the sensor is connected and active."
        log.error(message)
        raise Exception(message)

    return readings

This final sensor function is very simple in that it will take a sensor object as an argument and uses that to get the readings from the sensor board. The readings are stored in a dictionary and then that is returned to the caller.

If, for whatever reason it can't get the readings, such as a defective sensor board, it will write an error to the log file and exit the program.

Save the file and close it.

With that done, it's time to move on to the displays module.

Setting Up the Displays Module

With the logging, environment variables and sensors modules setup, the last module to create is the displays module.

Just as before in the sensor's module, there will be multiple functions.

First, create a new file in the displays folder called config.json and open it.

Next, paste in the below:

{
    "20x4": {
        "i2c_expander": "PCF8574",
        "address": "0x27",
        "port": 1,
        "cols": 20,
        "rows": 4,
        "dotsize": 8
    },
    "16x2": {
        "i2c_expander": "PCF8574",
        "address": "0x27",
        "port": 1,
        "cols": 16,
        "rows": 2,
        "dotsize": 8
    }
}

The purpose of this file is to list the settings for each display size. As you can see, there is an entry for a 20x4 screen and another for a 16x2 with each having the relevant settings for that screen.

Save the file and close it.

Next, create a file called displays.py and open it.

Paste in the below code:

# --- Import the required libraries / modules:
from datetime import datetime as dt
from RPLCD.i2c import CharLCD

import json
import logging
import os


# --- Get currently active logger:
log = logging.getLogger(__name__)


def initialise_lcd():
    """_summary_
    This function will attempt to initialise the LCD screen that is attached to the system.

    _Arguments_
    No arguments are required.

    Returns:
        class: A class called lcd that has the settings for an initialised LCD display.
    """

    # --- Specify the path to the display’s config file:
    config_file_path = f"{os.path.abspath(os.path.join(os.path.dirname(__file__)))}/config.json"

    # --- Check if the config.json file is present:
    if os.path.exists(config_file_path) == False:
        message = f"The config.json file was not found. Please check that this file exists."
        log.error(message)
        raise Exception(message)

    # --- Load the config file to a dictionary:
    with open(config_file_path) as config_file:
        config = json.load(config_file)

    # --- Get the screen type:
    screen_type = os.getenv("LCD_SCREEN_TYPE")

    # --- If the screen_type matches an entry in config (config.json), initialise the display
    # --- Otherwise, raise an error:
    if screen_type in config.keys():

        # --- Create a screen object:
        try:
            lcd = CharLCD(i2c_expander = config[screen_type]["i2c_expander"], 
                        address = int(config[screen_type]["address"], 0),
                        port = config[screen_type]["port"], 
                        cols = config[screen_type]["cols"], 
                        rows = config[screen_type]["rows"], 
                        dotsize = config[screen_type]["dotsize"])

        except OSError as error:
            message = f"Display could not be found. Please check the display is connected."
            log.error(message)
            raise Exception(message)

        except NotImplementedError as error:
            message = f"The display expander is not supported. Please check the display configuration."
            log.error(message)
            raise Exception(message)

    else:
        message = f"Display could not be found. Please check the display is connected."
        log.error(message)
        raise Exception(message)

    return lcd

Ok, so to go over it, there is the usual sections for importing modules / libraries and getting the active logger.

After that, there is the first function called initialise_lcd. The purpose of this function, when called, is to setup a configuration for a display that is specified in the LCD_SCREEN_TYPE environment variable. For example, 20x4.

To cover off what the function does:

First, specify where the config.json file is located and assign it to a variable named config_file_path. This is in the same directory as displays.py
Check to ensure that the config.json file exists in the config_file_path. If not, write an error to the log and raise an exception to exit the program
All being well, the contents of config.json are loaded into a variable named config. This will contain a Python dictionary
Next, get the value of the LCD_SCREEN_TYPE environment variable and assign it to a variable called screen_type
Then, check the value of screen_type matches a key in the config variable. In this case, does it match either “20x4” or “16x2”
If it matches, it will create a new object called lcd that has the configuration for the LCD screen and then return it
If it doesn't match, you guessed it, write an error to the log file and then exit the program.

Paste in the below code on a new line below the end initialise_lcd function. Don't paste it into that function:

def output_to_lcd(readings: dict, display: object) -> None:
    """_summary_

    Args:
        temperature (float): The temperature to display.
        humidity (float): The humidity to display.
        pressure (float): The pressure to display.
        altitude (float): The altitude to display.
        display (_type_): The display settings to use.
    Returns:
        None: Nothing is returned.
    """
    try:   
        display.clear()

        if display.lcd.cols == 20 and display.lcd.rows == 4:
            display.write_string(f"Temp:     {readings['temperature']}{chr(223)}C\r\n")
            display.write_string(f"Humidity: {readings['humidity']}%\r\n")
            display.write_string(f"Pressure: {readings['pressure']}hpa\r\n")
            display.write_string(f"Altitude: {readings['altitude']}m")
        else:
            display.write_string(f"Temp: {readings['temperature']}{chr(223)}C\r\n")
            display.write_string(f"Humi: {readings['humidity']}%\r\n")
    except OSError as error:
        message = f"Display could not be found. Please check the display is connected."
        log.error(message)
        raise Exception(message)


def output_to_console(readings: dict) -> None:
    """_summary_
    This function will display the readings of the sensor to the console.

    Args:
        readings (dict): The dictionary containing the readings from the sensor

    Returns:
        None: Nothing is returned.
    """

    # --- Clear the output on the terminal console:
    os.system('clear')

    # --- Display the values to the terminal console:
    print(dt.now().strftime("%d/%m/%Y, %H:%M:%S\n"))
    print(f"Temperature: {readings['temperature']}°C")
    print(f"Humidity: {readings['humidity']}%")
    print(f"Pressure: {readings['pressure']}hPa")
    print(f"Altitude: {readings['altitude']}m")

There are two functions in this block of code, both of which are very simple.

First, output_to_lcd will take two arguments, the first being readings in the form of a Python dictionary, along with the display settings. After that, it will attempt to display the relevant text on the screen and if it can't, for example the screen became disconnected, it will write an error to the log and then exit the program.

Lastly, there is the output_to_console function.

This function is very simple. It takes a single argument called readings, which again, is the dictionary containing the sensor readings. It then uses those readings to output to the console / terminal from where the program was run. Nice and simple.

Save the file.

That is all the modules created. The next and final file to setup is the main.py that will bring all the modules together and get the program working.

Bringing the Program Together

Now onto the final file!

Open main.py that was created at the start and paste in the below code:

# --- Import the required libraries / modules:
from time import sleep

from modules.displays.displays import initialise_lcd, output_to_lcd, output_to_console
from modules.env.env_vars import load_env_vars
from modules.logging.log_config import load_logging
from modules.sensors.sensors import initialise_sensor, get_readings

import logging
import os


def main() -> None:
    """_summary_
    This is the main function that controls the execution flow of the program.

    Returns:
        None: Nothing is returned.
    """

    # --- Load the environment variables:
    load_env_vars()

    # --- Create a sensor object:
    sensor = initialise_sensor()

    # --- Determine if LCD screen output is required:
    if os.getenv("LCD_SCREEN_CONNECTED") in ["True", "true", "TRUE", "1"]:
        OUTPUT_TO_LCD_REQUIRED: bool = True

        # --- Initialise the LCD screen:
        lcd_screen = initialise_lcd()
    else:
        OUTPUT_TO_LCD_REQUIRED: bool = False

    # --- Determine if console output is required:
    if os.getenv("OUTPUT_TO_CONSOLE") in ["True", "true", "TRUE", "1"]:
        OUTPUT_TO_CONSOLE_REQUIRED: bool = True
    else:
        OUTPUT_TO_CONSOLE_REQUIRED: bool = False

    # --- Show the results on the displays (if set to do so):
    if OUTPUT_TO_LCD_REQUIRED == True or OUTPUT_TO_CONSOLE_REQUIRED == True:
        while True:
            # --- Get a new set of readings from the sensor:
            readings: dict = get_readings(sensor = sensor)

            # --- If console output is required, output the values to the console:
            if OUTPUT_TO_CONSOLE_REQUIRED == True:
                output_to_console(readings = readings)

            # --- If LCD screen output is required, output the values to the LCD screen:
            if OUTPUT_TO_LCD_REQUIRED == True:
                # --- Pass the values of the sensor to the output_to_lcd function:
                output_to_lcd(readings = readings,
                              display = lcd_screen)

            sleep(3)

This new main.py file will control the flow of the program, rather than have all the code implemented inside of it, like was done in part one. Instead, it will import the code from the modules and their functions that have been created.

Now, let's now go over the code to outline what it will do:

First, there is the modules and libraries that need to be imported for this program to work. Unlike the other files this one will import all the custom modules that were previously created in the modules folder
Next, there is a function called main. This is where the flow logic for the program is placed. The steps it performs are:
- Load the environment variables by calling the load_env_vars function
- Next, create a sensor object by calling the initialise_sensor function. It is then assigned to a variable called sensor
- Next, check if the LCD_SCREEN_CONNECTED environment variable is set to true. If so, it will set OUTPUT_TO_LCD_REQUIRED to True. It will then call the initialise_lcd() function and assign it to a variable called lcd_screen
- The same applies to the OUTPUT_TO_CONSOLE environment variable but there's no further function calls
- After that, a check to see if either OUTPUT_TO_LCD_REQUIRED or OUTPUT_TO_LCD_REQUIRED are set to True. If neither are set to True, there will be no output to either. If one of them is set to True then a while loop is run, and the following happens:
  - A call to the get_readings function is made and the returned dictionary is assigned to the readings variable
  - The next two blocks work the same by checking if an output to the LCD screen and / or the console is needed. If so, call the relevant function do so.
  - Lastly, sleep for 3 seconds
- It will keep running until the program is manually stopped by pressing CTRL+C in the console / terminal.

Now, if the main.py file is run, nothing will happen as the main function is not being called.

An additional block of code needs to be added to call the main function. Paste in the below code after the main function. Again, make sure that the code isn't in the main function:

# --- Start the program:
if __name__ == "__main__":
    # --- Initialise logging:
    load_logging()

    # --- Get the currently active logger:
    log = logging.getLogger(__name__)

    # --- Attempt to run the main function:
    try:
        main()
    except NameError:
        message = "Unable to locate or run main function. Please check the program is setup correctly."
        log.critical(message)
        raise Exception(message)

This is a typical way that Python uses to execute a main function. It checks if the name is main and then it calls the main function.

Now, this does that but prior to that it calls the load_logging function to setup logging and gets the logger, just like in the modules. It then calls the main function and the program runs.

The below image provides a sample of the output to both the terminal / console and to a 20x4 LCD Screen:

Error Log Examples

After running the program a few times and caused some deliberate errors, the below shows an example of some of the errors recorded by the program:

ERROR:2024-10-24 18:56:07,718:modules.displays.displays:Display could not be found. Please check the display is connected.
ERROR:2024-10-24 18:56:34,885:modules.sensors.sensors:Unable to get readings from the sensor. Please check the sensor is connected and active.
ERROR:2024-10-24 18:57:00,059:modules.displays.displays:The config.json file was not found. Please check that this file exists.
ERROR:2024-10-24 18:58:03,472:modules.env.env_vars:No environment variables were loaded. Please check the .env file exists.
CRITICAL:2024-10-24 18:58:29,347:__main__:Unable to locate or run main function. Please check the program is setup correctly.
ERROR:2024-10-24 19:02:47,685:modules.sensors.sensors:No sensor board was found. Please check that it is connected.

As you can see, there is a mixture of errors, including:

The log level (ERROR or CRITICAL)
The date and time
Which module caused the issue
The message that was recorded

Wrapping-up Part Two Plus What's Next

This completes part two of this project. There were a lot of changes to make from part one, but I hope that you can see that the program is much more modular, easier to switch between configurations using the .env and config.json files and that the error logging will be useful for diagnosing any issues encountered.

In the next part, a SQL database will be added to the program so that all the readings can be stored for further analysis. This will be an additional module so you can see the benefits of the code being modular.

In addition, a simple Python-based web server program will be added that will display the ten most recent entries in the database and provide an option to download all the entries to a CSV / Excel file.

Building A Weather Station with a Raspberry Pi and Python - Part One

dev_neil_a — Wed, 09 Oct 2024 13:51:02 +0000

Building a Raspberry Pi Environment Sensor

YouTube Video
Introduction
Required Hardware
Required Software
Wiring Up The Equipment
Updating Raspberry Pi OS
Detecting The Sensor and LCD Screen
Setup VS Code
Using Python with The Sensor and a 16x2 LCD Screen
Using Python with the 20 x 4 Screen
Conclusion
References

YouTube Video

If you would prefer to watch a video of this article, there is a video version available on YouTube below:

Introduction

I recently decided I wanted to have a play around with a Raspberry Pi and came up with a few project ideas that I could put together with a Pi.

For this particular project, I’ll be putting together a Raspberry Pi with an environmental sensor board, along with an LCD Screen. The aim is to have the values that the sensor collects show up on the LCD screen and on the monitor as well. I will be demonstrating two LCD screen options, one being a 16 column by two rows, and another with 20 columns and 4 rows.

This project will be split up over three articles, with this part covering the initial “getting it working” part. The second will look at tidying up the code and adding logging to the program, along with using some environment variables for config settings.

The last part will include setting up a SQL database to store the readings and adding a basic web server to show the last 10 readings and an option to download all the readings to a CSV file.

With that said, let’s move on and look at what hardware and software that will be used for this project.

Required Hardware

For this project, I used the following hardware:

1 x Raspberry Pi 3 B+ 1GB. You can use either a Pi 4 or 5 instead
1 x 128GB SanDisk MicroSD Card. Again, you can use any, but I would recommend a card of at least 64GB or higher
1 x Power Adapter
1 x Adafruit BME280 Sensor which collects temperature, humidity and pressure
1 x LCD Screen. Both of the following will be used, one at a time:
- 1 x 16x2 LCD Screen with a PCF8574 expander board
- 1 x 20x4 LCD Screen with a PCF8574 expander board
Wires
- 10 x Male to female jumper / Dupont wires
- 2 x red (for 5v power)
- 1 x orange (for 3v power)
- 2 x black (for ground)
- 2 x yellow (for i2c SDA)
- 2 x blue (for i2c SCL)
- 1 x STEMMA QT / Qwiic JST SH 4-pin to 4-pin male jumper / Dupont wires
1 x Breadboard

Here is a photo of the hardware:

Required Software

On the software side, the project will make use of:

The Raspberry Pi Imager tool
Raspberry Pi OS Lite (on the MicroSD card). This is a version of Raspberry Pi OS that doesn’t have a desktop environment as I needed to free up memory
A terminal emulator – iTerm2 is what I use on macOS, but you can use whichever you like
Microsoft Visual Studio Code
Python 3.11 (newer versions may work as well)

Wiring Up The Equipment

The wiring for this project is simple. Use the below diagram to cable up the Pi, sensor and the LCD screen to the breadboard.

After the wiring is done, install the microSD card into the Pi.

Updating Raspberry Pi OS

With the hardware all setup, the first thing to do is to check for any updates for Pi OS. As this is a new install, there will be some to install.

Open a terminal SSH to the Pi by running:

ssh username@ip-address

Once logged in, update the list of repositories by running:

sudo apt update

After that, install any updates by running:

sudo apt upgrade -y

With all the updates installed, some additional packages need to be installed. To install them, run:

sudo apt install i2c-tools virtualenv python3-virtualenv -y

To go over what the packages are, the first one is i2c-tools, which is a collection of tools that are used for interacting with the i2c interface that the sensor and LCD screen are connected to.

The last two, virtualenv and python3-virtualenv, allow for easy creation of virtual environments for Python. I had issues with another method, so I opted to use virtualenv instead.

After those have been installed, reboot the Pi using:

sudo reboot

Rebooting isn’t really needed but I would recommend doing it, especially with a fresh Pi OS install.

The system will end the SSH session and restart the Pi. Wait for a minute or two and then run SSH again.

Detecting The Sensor and LCD Screen

Now that Pi OS has been updated, the next step is to check to make sure the sensor module and LCD screen have been detected on the i2c interface.

First, the i2c interface on the Pi needs to be enabled as by default, it’s disabled on Pi OS. To enable it, run:

sudo raspi-config

Once the menu appears, go to Interface Options > I2C > Yes.

Exit out of raspi-config.

Next, to see if the board and LCD screen have been detected, run:

i2cdetect -y 1

The output should look like the below:

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:                         -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- 27 -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- 77

There are two numbers showing, 27 and 77. 27 is the i2c address for the LCD screen and 77 is the i2c address for the sensor board, which you can check by looking at the back of the sensor board as it’s printed on there.

This indicates that both are detected and good to go.

If one or both don’t appear, double check the cabling and that the i2c interface is enabled.

Setup VS Code

Now that the sensor and LCD screen are working, it’s time to start putting together the code.

First, if you haven’t already, download and install VS Code for your operating system.

Next, click on open a remote window using the icon in the very bottom left of the status bar in VS Code. If you don’t see it, check that the Remote Development extension is installed.

It will ask you how to connect. Select ‘Connect to host’ and then select ‘Add new SSH host’. Enter your username and ip address of the pi as yourusername@ip-address-of-the-pi.

Save the settings to the top file when asked.

Next, click connect and enter the password for the user on the Pi.

If it asks you to install VS Code remote server, do so.

Now that VS Code server is installed, install the Python extensions from Microsoft to make working with Python easier. You can do this by going to Extensions, and then typing Python. Select the option that is from Microsoft, which is usually at the top and install it to the SSH system.

Next, open a new terminal in VS Code (Terminal > New Window in the menu) if one is not already present.

In the terminal, create a new folder called ‘project’ by running:

mkdir project

Next, run cd project to go into that folder.

With that done, click on Open Folder in the Explorer tab and select the project folder.

Next, a Python virtual environment will need to be created so that the projects packages can be isolated from the global Python environment. To do this, run:

virtualenv -p /usr/bin/python3 venv

This will create a virtual environment called venv.

Next, the virtual environment needs to be activated, which is done by running:

source ./venv/bin/activate.

With the virtual environment now active, several Python libraries need to be installed using the pip or pip3 command to allow Python to work with the sensor board and LCD screen. To install these, run:

pip3 install adafruit-circuitpython-bme280 RPLCD smbus2

Using Python with The Sensor and a 16x2 LCD Screen

First, create a new file called main.py in the project folder. That file will automatically open.

Next, copy and paste the following code into this file:

# --- Import the required libraries / modules:
from adafruit_bme280 import basic as adafruit_bme280
from datetime import datetime as dt
from RPLCD.i2c import CharLCD
from time import sleep

import board


# ======== Part 1: Get the sensor working: ========

# --- Attempt to create a board object, using the board's default I2C interface:
try:
    i2c = board.I2C()  # --- uses board.SCL and board.SDA
except OSError as error:
    raise Exception(f"Critical: {error}")
except ValueError as error:
    raise Exception(f"Critical: {error}")


# --- Attempt to initialise the sensor on the i2c interface using the default values:
try:
    bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c)
except OSError as error:
    raise Exception(f"Critical: {error}")
except ValueError as error:
    raise Exception(f"Critical: {error}")


# --- change this to match the location's pressure (hPa) at sea level.
# --- See references section for a website to get your sea level:
bme280.sea_level_pressure = 1013.25


# ======== Part 2: Get the LCD scree output working: ========
try:
    lcd = CharLCD(i2c_expander="PCF8574", 
                  address=0x27,
                  port=1, 
                  cols=16, 
                  rows=2, 
                  dotsize=8)

except OSError:
    raise Exception("Display could not be detected. Please check the display is connected and the I2C port and / or address are correct.")

except NotImplementedError:
    raise Exception("The display expander is not supported. Please check the display configuration.")


# --- Show the results on the console and the LCD screen:
update_output = True


while update_output == True:
    # --- Set variables for all four measurements:
    temperature = bme280.temperature
    humidity = bme280.relative_humidity
    pressure = bme280.pressure
    altitude = bme280.altitude

    # --- Show the values on the console:
    print(dt.now().strftime("%d/%m/%Y, %H:%M:%S\n"))
    print("Temperature: %0.2f°C" % temperature)
    print("Humidity: %0.2f %%" % humidity)
    print("Pressure: %0.2f hPa" % pressure)
    print("Altitude: %0.2f meters" % altitude)       

    # --- Clear the current contents of the LCD screen:
    lcd.clear()

    # --- Output values to the LCD screen:
    lcd.write_string(f"Temp: %0.2f{chr(223)}C\r\n" % temperature)
    lcd.write_string(f"Humi: %0.2f%%" % humidity)

    # --- Sleep for three seconds
    sleep(3)

The \r\n that is at the end of a lcd.write_string line indicates a new line (\n) and return to the beginning of that line (\r).

Also, if you are wondering what chr(223) means, it is the ASCII code for the degreesymbol .

Right-click in a blank space around the code and go to Run Python -> Run Python File in Terminal.

The five lines for the date & time, temperature, humidity, pressure and altitude will show up in the VS Code terminal and the temp and humi lines on the LCD screen. Both will update every three seconds with the latest reading.

To stop the program, use ctrl-c in the console as there is no way to stop the while loop with the way the program is built.

NOTE: Change the value of bme280.sea_level_pressure to match where you are. There is a link in the references section to help you get the right sea level number.

Using Python with the 20 x 4 Screen

To use a 20 x 4 LCD screen instead of a 16 x 2 LCD screen, the code is the same, but there are some changes that need to be made to it.

First, the wiring on the display is the same as the 16 x 2 so there is nothing different there, at least for the two screens I used.

Next, before making any changes, run i2cdetect -y 1. The response will be the same (27 for the address) as the screens use the same expander board.

Moving onto the code changes. First, change the lcd arguments to cols=20 and rows=4 from 16 and 2 respectively. It should now look like the below:

lcd = CharLCD(i2c_expander="PCF8574", 
                  address=0x27,
                  port=1, 
                  cols=20, 
                  rows=4, 
                  dotsize=8)

Lastly, replace the lcd.write_string lines with the below to show the pressure and altitude on the LCD screen, along with the temperature and humidity:

lcd.write_string(f"Temp: %0.2f{chr(223)}C\r\n" % temperature)
lcd.write_string(f"Humi: %0.2f%%\r\n" % humidity)
lcd.write_string(f"Pres: %0.2fhpa\r\n" % pressure)
lcd.write_string(f"Alti: %0.2fm" % altitude)

The complete code now looks like this:

# --- Import the required libraries / modules:
from adafruit_bme280 import basic as adafruit_bme280
from datetime import datetime as dt
from RPLCD.i2c import CharLCD
from time import sleep

import board


# ======== Part 1: Get the sensor working: ========

# --- Attempt to create a board object, using the board's default I2C interface:
try:
    i2c = board.I2C()  # --- uses board.SCL and board.SDA
except OSError as error:
    raise Exception(f"Critical: {error}")
except ValueError as error:
    raise Exception(f"Critical: {error}")


# --- Attempt to initialise the sensor on the i2c interface using the default values:
try:
    bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c)
except OSError as error:
    raise Exception(f"Critical: {error}")
except ValueError as error:
    raise Exception(f"Critical: {error}")


# --- change this to match the location's pressure (hPa) at sea level.
# --- See references section for a website to get your sea level:
bme280.sea_level_pressure = 1013.25


# ======== Part 2: Get the LCD scree output working: ========
try:
    lcd = CharLCD(i2c_expander="PCF8574", 
                  address=0x27,
                  port=1, 
                  cols=20, 
                  rows=4, 
                  dotsize=8)

except OSError:
    raise Exception("Display could not be detected. Please check the display is connected and the I2C port and / or address are correct.")

except NotImplementedError:
    raise Exception("The display expander is not supported. Please check the display configuration.")


# --- Show the results on the console and the LCD screen:
update_output = True


while update_output == True:
    # --- Set variables for all four measurements:
    temperature = bme280.temperature
    humidity = bme280.relative_humidity
    pressure = bme280.pressure
    altitude = bme280.altitude

    # --- Show the values on the console:
    print(dt.now().strftime("%d/%m/%Y, %H:%M:%S\n"))
    print("Temperature: %0.2f°C" % temperature)
    print("Humidity: %0.2f %%" % humidity)
    print("Pressure: %0.2f hPa" % pressure)
    print("Altitude: %0.2f meters" % altitude)       

    # --- Clear the current contents of the LCD screen:
    lcd.clear()

    # --- Output values to the LCD screen:
    lcd.write_string(f"Temp: %0.2f{chr(223)}C\r\n" % temperature)
    lcd.write_string(f"Humi: %0.2f%%\r\n" % humidity)
    lcd.write_string(f"Pres: %0.2fhpa\r\n" % pressure)
    lcd.write_string(f"Alti: %0.2fm" % altitude)

    # --- Sleep for three seconds
    sleep(3)

Run the program again. There will be five lines shown in the console (print) and four lines on the LCD screen (lcd.write_string).

Again, to close the program, press ctrl+c in the console window.

Conclusion

That completes this part of the project. In the next part, I’m going to split up the code into modules for the LCD screen and the sensor, along with adding some logging to help store any errors that are encountered along the way.

I will also be adding some environment variables to the program to make it more configurable. For example, include a file that indicates if an LCD screen is connected and if so, what type it is. For example, is it a 16x2 or a 20x4 screen.

References

BME280 Tutorial:

https://learn.adafruit.com/adafruit-bme280-humidity-barometric-pressure-temperature-sensor-breakout/pinouts

Determine your see level:

https://meteologix.com/uk/observations/united-kingdom/pressure-qnh/20240823-1000z.html

Setup a RTC Module with Ubuntu 24.04 on a Raspberry Pi 4

dev_neil_a — Thu, 01 Aug 2024 12:00:00 +0000

YouTube Video
Introduction
Equipment Used
Installing The RTC Module
Connecting to the Pi Over SSH
Install Required Software
Check the Current Date and Time
Detect the RTC Module
Set the RTC Modules Date and Time
Optional: Disable the Timesyncd Service
Conclusion

YouTube Video

If you would prefer to watch a video of this article, there is a video version available on YouTube below:

Introduction

Recently, I upgraded my Raspberry Pi 4 B 8GB to Ubuntu 24.04 Server and as part of the build, I needed to setup an RTC (real time clock) module that I previously had installed and configured with Ubuntu 20.04 Server to keep the date and time if it couldn’t get it from a NTP (network time protocol) server.

To no one’s surprise, some changes have been made over the years which meant the previous article I wrote that covered the setup of an RTC module in Ubuntu 20.04 would no longer work.

As such, I figured I would put together a new article that covered the steps needed.

The steps in this guide should also work on a Raspberry Pi 3 B+ but only on the server edition of Ubuntu 24.04. That is mostly due to memory requirements for Ubuntu 24.04.

Equipment Used

Here is the hardware and software I used for this project:

A Raspberry Pi 4 B 8GB model
A FLIRC Case
A Raspberry Pi 4 power adapter
A SanDisk 128GB MicroSD card with Ubuntu 24.04 installed
A MicroSD to SD-Card adapter
A SD-Card reader
A GPIO-based RTC Battery Module with a DS1307 chipset
A CAT 6a / 7 Ethernet cable
The Raspberry Pi Imager application
Ubuntu Server 24.04 64-bit for Raspberry Pi (downloaded via the Raspberry Pi Imager tool).

Installing The RTC Module

To begin with, you will need to check which chipset is on your RTC module. You should be able to find this by looking at the text on the module or you can find it from the vendors description from where you bought it, which might be easier.

You can then proceed to install the module onto the GPIO pins on the Pi. For my RTC module, I needed to install it onto pins 1, 3, 5, 7 and 9 but yours might be different.

I placed a bit of electric tape over the RTC module as it was going into an aluminium case which it shouldn't come into to contact with, but I figured it's better to be safe than sorry.

You can then install the MicroSD card and connect the Ethernet cable and power adapter to the Pi.

Connecting to the Pi Over SSH

SSH is used to remotely connect to Ubuntu (or Linux in general) to allow you to run terminal commands. You will need to use a terminal application to use SSH. Which application you use depends on your computers Operating System. Some examples that are available include:

Linux: Terminal, X-Term or the console screen if you have no GUI installed
macOS: Terminal (built-in) or iTerm2 (download)
Windows: Putty or PowerShell SSH (Needs to be enabled in Windows 10).

As part of the Raspberry Pi Imager setup, you specified a username and password to use. You will need to use those credentials with the following command:

ssh username@ip_address

Replace username with the username you specified in the Raspberry Pi Imager
Replace ip_address with the IP address the Raspberry Pi obtained from your DHCP server (typically, this would be your Router). It should look something like 192.168.0.11.

Once connected, you should then be prompted for a password. This is the password you previously set in the Raspberry Pi Imager. Once you have successfully logged in, you should see a prompt like the below:

pi@pi4-server:~$ _

pi: This is your username
pi4-server: This is the hostname of the Raspberry Pi you are connected to.

Install Required Software

There are two dependencies that need to be installed to complete the setup. These are:

i2c-tools – This package contains tools for working with the i2c bus on the Raspberry Pi
util-linux-extra – This package contains a bunch of tools but the one that is needed in here is hwclock. This is used to interact with a hardware clock, such as an RTC module. Previously, hwclock was installed by default in Ubuntu 20.04 but at some point, they removed it as part of the base installation.

To install the two packages, run:

sudo apt install -y i2c-tools util-linux-extra

Check the Current Date and Time

Before we begin setting up the RTC module, let’s check the current date and time of the system. This will not come from the RTC module at this point. Instead, it will be set using the systemd timesyncd service that is run when the Raspberry Pi is booting up.

Run the following to get the current system date and time:

date

The date and time should be the current date, time and time zone for where you are. For example:

Mon Jul 22 16:20:14 BST 2024

If it isn’t, you may need to check your Raspberry Pi’s network and internet connection settings.

Detect the RTC Module

To detect the RTC module, use the i2cdetect command to locate the module on the i2c bus. At the terminal, enter the following command:

sudo i2cdetect -y 1

The output should look like the below:

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:                         -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- 68 -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

In the above, all the fields are the same, except for the field at position 60x8. This is where the RTC module has been detected. This is typical for most RTC modules that are installed on a Raspberry Pi but yours may come back in a different field.

If the output of the command is like the below, you may need to check that the RTC battery is installed correctly:

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:                         -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

Now, although the RTC module has been detected, it is currently not accessible as Ubuntu has not enabled it. To enable it, run the following commands (NOTE: change ds3231 on the echo command to the chipset of your RTC module. Also, if you use a ds3231 module, it will use the ds1307 module driver as they share similar commands so if you see ds1307 mentioned later, that is why):

sudo su
echo dtoverlay=i2c-rtc,ds3231 >> /boot/firmware/config.txt
exit

Once the above has been done, you will need to reboot your system. Run:

sudo reboot

Once the system is rebooted, SSH back to it.

The module should now be active. To check, run the following command:

sudo i2cdetect -y 1

The output should look like the below:

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- UU -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

If you look at 60x8 again, instead of showing 68 as it did before, it now should be UU. This indicates that the module is now active and can be used by Ubuntu.

If it is 68 or --, something went wrong. You can check to see what happened during bootup by running the following command:

sudo dmesg | grep rtc-

This indicates the status of the RTC module during bootup. If it loads correctly, it should look like the below:

[    3.616265] rtc-ds1307 1-0068: registered as rtc0
[    3.622081] rtc-ds1307 1-0068: setting system clock to 2024-07-22T11:41:49 UTC (1721648509)

If you don’t see that output (or whatever matches your RTC modules chipset) and you get an error instead, check the error to see what went wrong. It may also not return anything.

One potential cause is that the chipset on the RTC module is different to what was specified in the prior echo command. Double check that first. If that isn’t the case, you will need to troubleshoot using the error message provided.

Set the RTC Modules Date and Time

Up until this point, the RTC modules date and time will (potentially) be different to the current date and time if it is the first time that the module has been used. To access the contents of the RTC module, the hwclock command is used.

To start with, let’s look at the date and time that is stored on the RTC module. To do this, run the following command (-r indicates that we want to read the contents of the RTC module):

sudo hwclock -r

The output will be like the below with the date and time being different:

2000-01-01 16:17:57.927712+01:00

To update the date and time on the RTC module, the current date and time from the system needs to be written to the RTC module. To do this, run the following command (-w indicates that the RTC module will have the current system time written to it):

sudo hwclock -w
sudo hwclock -r

The output will now be the current date and time. For example:

2024-06-25 13:02:26.825937+01:00

That is all the steps needed to get an RTC module up and running on Ubuntu 24.04 running on a Raspberry Pi 4.

Optional: Disable the Timesyncd Service

If you are deploying the Raspberry Pi to a location where it will have no internet connection, or you just want to use the time and date from the RTC module, you can disable the timesyncd service.

To do this, run the following command:

sudo systemctl disable systemd-timesyncd.service

When the system is next booted or rebooted, the only source of the date and time for the system will be the RTC module.

Conclusion

I hope that this article was useful.

Thank you for reading and have a nice day!