This post quickly covers how I disabled (removed) the IR LEDs on several Tapo C110 cameras I own. This was to use them behind a window without the IR LEDs’ glare ruining the video. The Tapo C110 is an excellent small WiFi security camera, boasting up to 2K resolution, local continuous SD card recording, and two local RSTP streams. Most importantly, it works perfectly fine without an internet connection once configured, fitting my use-case. A significant drawback of the camera is the need to completely disable the night vision mode to turn off the IR LEDs. This means you can’t use the night vision mode while the camera is behind a window. Thankfully its easy to disable Tapo camera IR LEDs!

The Official (lack of a) Solution

A discussion has been ongoing since 2021 on the TP-Link forum regarding this issue. The official TP-Link support recommends disabling night vision mode entirely. Meanwhile, the most popular suggestion among forum users involves covering the LEDs with tape. However, this is often ineffective due to light leaking around and through the tape since the LEDs are inset. My guess for why this hasn’t been addressed with a straightforward firmware update is that the camera’s design links the digital output controlling the IR filter to the IR LEDs. As a result, they cannot be independently deactivated, representing a significant design flaw if true!

Opening the Camera

Opening the camera is just a matter of using a prying tool along the front edge of the camera and the front plate will pop off — there are four clips, one along each side. It’s okay to use a bit of force, you won’t break it (don’t quote me on that). Conveniently, the LEDs are on a daughter board that connects to the PCB.

The Simple (slightly broken) Solution to Disable Tapo Camera IR LEDs

If you don’t mind losing the microphone and indicator LED you can simply remove the daughter board PCB entirely and the camera will still function. This allows the use of night vision mode without the IR LEDs causing reflections on the glass.

The Less Simple (more functional) Solution to Disable Tapo Camera IR LEDs

A more comprehensive approach involves desoldering the IR LEDs. This is relatively straightforward with tools like a hot air tool, heat gun, toaster oven, or even a stove and pan. I wouldn’t recommend using a soldering iron; the PCB’s heat sink properties mean that the LEDs may be damaged before the solder melts enough. I used a hot air tool on the PCB’s rear, directly behind an LED, and gently pulled on the LED with tweezers. The LEDs detached after a few seconds of heating. KEEP THE LEDs!

There are two hardware versions of the C110. Version 1 has three LEDs, while version 2 has two. I have one of each version, and found the LEDs in both easy to remove.

Reversing the Changes

If you decide to reverse these modifications, you can easily solder the LEDs back on or reattach the PCB. I ultimately reversed this change for all my cameras once they were no longer needed for window surveillance. Resoldering the LEDs is doable without extra solder, but I suggest using at least a bit of flux for better results. I personally applied a small dab of solder paste. For the resoldering process, I used a hot plate. It’s crucial to align the pads on the PCB with that on the LED by size to ensure correct polarity.

The post Disable TP-Link Tapo Camera IR LEDs appeared first on Paul Bupe Jr, PhD.

This tutorial covers setting up a pretty painless Raspberry Pi Pico C / C++ SDK development workflow on Windows using the Windows Subsystem for Linux (WSL) and Visual Studio Code (VS Code) with IntelliSense code completion!

With the Raspberry Pi Pico microcontroller being so new the current C / C++ SDK development process on Windows is a bit cumbersome. This tutorial should hopefully give you some ideas on how to go about programming the Raspberry Pi Pico the easy way with WSL and VS Code.

Note: This is not a beginner tutorial and assumes some minimal development experience.

The Raspberry Pi Pico is an exciting new microcontroller board launched on January 21, 2021. It’s based on the RP2040 microcontroller (by the Raspberry Pi Foundation) sporting a dual-core ARM Cortex-M0+ running at 133 MHz. The most exciting feature is the Programmable I/O, or PIO, that has 8 independent processors (simple state machines). This is huge for robotics where there’s a need to ingest real-time sensor data in the background while performing other tasks. Keep an eye out for my tutorial on reading multiple DC motor quadrature encoders at the same time without messing with lots of timers and interrupts using the PIO!

Prerequisites

1. Enable Windows Subsystem for Linux and install the latest Ubuntu image (20); follow the “Manual Installation” steps. WSL is a built-in feature of Windows 10 and brings most of the power of developing on a Linux machine natively into Windows! Be sure to install Windows Terminal for an even better experience (instructions towards the end of the link above).
2. Install Visual Studio Code and install the following extensions: Remote – WSL, C/C++, and CMake Tools. You can search for these extensions by name directly in VS Code.

Configure WSL

Setup Script

If you are in a bit of a rush I’ve created a setup script that will perform all the WSL configuration tasks for you. Just open up WSL, run the following commands, then skip to setting up Visual Studio Code!

cd ~
git clone https://github.com/74ls04/pico-wsl-setup.git
cd pico-wsl-setup
./pico_wsl_setup.sh

This script will install the SDK in ~/pico and also installs a few Pico extras from the Raspberry Pi Pico repos.

Install Dependencies

Note: I’m using Ubuntu 18 for this demo but if you’re starting from scratch use 20 to avoid issues with CMake compatibility.

First, open up the WSL Ubuntu terminal and go to the home directory.

cd ~

Then install the required build dependencies

sudo apt update
sudo apt install git cmake gcc-arm-none-eabi libnewlib-arm-none-eabi build-essential

That’s all there is for dependencies!

Install the Raspberry Pi Pico C / C++ SDK

While still in the home directory create a directory called pico and go into the pico directory

mkdir pico
cd pico

After that clone the SDK and examples git repositories.

git clone -b master https://github.com/raspberrypi/pico-sdk.git
cd pico-sdk
git submodule update --init
cd ..
git clone -b master https://github.com/raspberrypi/pico-examples.git

The git submodule command basically pulls in a separate Raspberry Pi repository from https://github.com/raspberrypi/tinyusb.git and downloads those files.

Here is what all the commands look like after execution.

Configure and Build with Visual Studio Code

Now we’re going to configure VS Code and build the following “blink” example.

#include "pico/stdlib.h"

int main() {
    const uint LED_PIN = 25;
    gpio_init(LED_PIN);
    gpio_set_dir(LED_PIN, GPIO_OUT);
    while (true) {
        gpio_put(LED_PIN, 1);
        sleep_ms(250);
        gpio_put(LED_PIN, 0);
        sleep_ms(250);
    }
}

So far you should have the following directories:

~/pico
~/pico/pico-sdk
~/pico/pico-examples

Move into the pico-examples directory

cd pico-examples

Now here is where the integration of VS Code and WSL really shines. Open VS Code into this directory

code .

This command will launch VS Code and automatically link it to the WSL instance. You should see a green connection label in the bottom left. This process also creates a hidden .vscode sub-directory that will hold the VS Code configuration for this workspace.

If this is your first time using VS Code with WSL follow these quick instructions to make sure the three extensions mentioned at the top are also installed in WSL. At this point you may see a notification asking if you would like to configure the project — click on “Not now” as we need to set up a few things first.

Configure CMake Extension

Click the gear icon in the bottom left and select Settings.

Expand the Extensions tree, select CMake Tools configuration, and then click Add Item under “Cmake: Build Environment” to add the SDK path as shown below. If you followed the directory structure in this tutorial your PICO_SDK_PATH will be /home/$USER/pico/pico-sdk where $USER is your WSL username. In this case my tutorial username is “main.”

Configure IntelliSense (Code Completions)

Open the Command Palette, Ctrl+Shift+P, and start typing “C/C++” then select C/C++: Edit Configurations (JSON).

This will create the following file:

 /home/$USER/pico/pico-examples/.vscode/c_cpp_properties.json

Change the file to match the following settings. Keep in mind that these settings are purely for code-completion and have nothing to do with the actual compiling.

{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}/**",
                "/home/$USER/projects/pico/pico-sdk/**",
                "/usr/lib/gcc/arm-none-eabi/**"
            ],
            "defines": [],
            "compilerPath": "arm-none-eabi-gcc",
            "cStandard": "c11",
            "cppStandard": "c++17",
            "intelliSenseMode": "gcc-arm",
            "configurationProvider": "ms-vscode.cmake-tools"
        }
    ],
    "version": 4
}

Replace $USER with your WSL username under “includePath”!

Close VS Code and relaunch it again from the terminal with

code .

This time when CMake asks whether you’d like to configure the project select “Yes” and wait for it to finish configuring.

Configure Compiler and Build

Tell VS Code which compiler to use by clicking the “No Kit Selected” text at the bottom

Then selecting GCC for arm-none-eabi... If using Ubuntu 20 your compiler version will be different since I’m using 18.

Open up the “blink.c” example file using the explorer menu on the left, CTRL+SHIFT+E. You should see no errors highlighted in the file and code hints should be working as well.

Tell CMake which project to build by clicking on [all] at the bottom

Then scroll until you see “blink.”

You should now see [blink] instead of [all]. Click on “Build” to build the project!

VS Code will automatically create a build directory and spit out the project binaries into that directory.

Keep in mind this built the debug configuration, you can change it to release by clicking on CMake: [Debug]: Ready at the bottom.

Upload to Raspberry Pi Pico

Uploading the binary to the Pico is just a matter of dragging the .uf2 file into the folder that opens when you plug in the Pico while holding down the BOOTSEL button.

The file to transfer is:

/home/main/pico/pico-examples/build/blink/blink.uf2

To open the directory you can either right clock on the directory name in VS Code then click “Reveal in Explorer” or just type

explorer.exe .

in the WSL terminal to open that directory in Windows Explorer. That’s one of the most useful WSL commands!

Plug in the Raspberry Pi Pico while holding down the BOOTSEL button and then drag over the .uf2 file to the Pico folder.

It will automatically disconnect after transferring and immediately start running the program!

It’s also pretty easy to configure VS Code to automatically move the file after building but for the sake of keeping this short I’ll save that for another time.

More to come!

This should hopefully give you an idea of how the current development process is for the Raspberry Pi Pico. My goal is to create another robotics-focused Pico tutorial in the coming months starting from scratch and using the PIO — maybe in conjunction with a Raspberry Pi!

Feel free to ask any questions or offer suggestions in the comments!

Updated: 2/11/2021

The post Easy Raspberry Pi Pico Microcontroller C / C++ Programming on Windows appeared first on Paul Bupe Jr, PhD.

It’s not very well known that the Raspberry Pi has a built-in serial console that provides a fully working Linux terminal over serial. This allows for network-free headless access, including the absolutely necessary tab auto-complete! This feature is extremely useful for those projects that don’t use a screen or need network access. It’s also quite necessary when you are using a Pi as a wireless access point for a LAN without internet sharing.

Quick disclaimer: This article assumes basic familiarity with the Raspberry Pi and the basics of interfacing with serial devices. I’m using Windows to demonstrate but this works equally well on Linux and Mac.

Hardware

You’ll need a Raspberry Pi (of course) and a USB -to-Serial device (like this one from Adafruit).

Firstly, connect the RX of the USB-to-Serial device to Pin 8 of the Pi (physical Pin 8, not the GPIO pin number) and TX of the USB-to-Serial device to Pin 10 of the Pi.

Remember, for UART communication you do not match up TX <–> TX and RX <–> RX, it’s the opposite (TX –> RX and RX <– TX) since one device transmits and the other receives.

Finally, connect the ground of the USB-to-Serial device to Pin 6 of the Pi (ground).

NOTE: Do NOT connect the 5V power wire from the USB-to-Serial adapter to the 5V power pin of the Pi. This can backpower the Pi and destroy it. All that’s necessary is that the USB-to-Serial adapter and Pi share the same ground reference. Using the Adafruit adapter, the connections look like the picture at the top of the page.

Software

To enable the serial console just add the line:

enable_uart=1

to /boot/config.txt on the Pi. /boot/ is also mounted automatically on Windows so you can do this on a fresh image immediately after burning to the SD card (you may need to take it out and re-insert it first).

After connecting the USB-to-Serial adapter you can figure out the serial COM port using device manager.

The serial port needs to be configured with the settings below. Generally everything below but the baud rate are the default on most systems so that’s all you need to specify.

    Speed (baud rate): 115200
    Bits: 8
    Parity: None
    Stop Bits: 1
    Flow Control: None

In this case I’m using PuTTY to connect to the Pi as shown:

After connecting you should be met with a blank screen, simply press ENTER to send a character and you’ll see the familiar login prompt. Enter the login credentials and you’re in, just like you SSH’d in!

To demonstrate that this is a fully working terminal you can even launch the “graphical” raspi-config utility.

That’s it!

This should hopefully be a useful bit of info for the more advanced projects that don’t use the Pi with a screen and mouse/keyboard connected.

The post Raspberry Pi Headless Access Using Built-in Serial Console appeared first on Paul Bupe Jr, PhD.

I recently needed to build Python 3.6 from source on the BeagleBone Black for a robotics project and discovered that the build would always fail after running out of memory. Who could have figured that 512MB of RAM wasn’t enough to build Python from source?! While I could have set up cross-compilation and performed the heavy lifting on my computer with more resources, I figured this was a perfect problem to solve by adding swap memory to the BeagleBone Black.

What is a swap space?

At a very high level, a swap space (usually in the form of a partition) allows the system to move some of the “lower priority” memory pages (blocks of memory) to the partition or file so that higher priority tasks can use the memory. The combined size of the physical memory and swap space is called virtual memory. Gary Sims has a great primer on swap spaces over at linux.com

In this case, the BeagleBone Black only has 512MB of RAM so I’ll be adding ~1GB of swap space to my SD card in the form of a swap file. This will allow it to perform more memory-intensive tasks without running out of memory (at a cost of slower access times).

Creating a swap file

Creating a swap space is a fairly simple process that involves creating a file (and filling it with zeros) then telling the system to use that file as a swap space. Finally, the system has to be configured to load that file on startup.

Check if you already have a swap file

sudo swapon -s

In my case I already created the file so it’s shown. The assumptions is that you’re performing these steps because you don’t have a swap space.

Create the swap file

Use the dd utility to create a file with a fixed size and fill it with “zeroes”. In this case I’m moving 1000 “zeroes” from /dev/zero in block sizes of 1024k (1MB) into my file at /var/cache/swap/swapfile. This will result in a swap file of around 1 gigabyte. Keep in mind that the swap file is actually named “swapfile” with no extension.

sudo dd if=/dev/zero of=/var/cache/swap/swapfile bs=1024k count=1000

use chmod to change the file permissions of the new swap file.

sudo chmod 0600 /var/cache/swap/swapfile

Use the mkswap  command to create the swap area using our newly created swap file.

sudo mkswap /var/cache/swap/swapfile

Finally, enable the swap area with the swapon command

sudo swapon /var/cache/swap/swapfile

Configure the swap file to automatically mount on boot

Open up the /etc/fstab file with the nano editor.

sudo nano /etc/fstab

Append the following line to the file:

/var/cache/swap/swapfile    none   swap   sw   0   0

That is all there is to it for this specific case – adding swap memory to the BeagleBone Black is pretty straightforward!

The post Adding Swap Memory to the Beaglebone Black appeared first on Paul Bupe Jr, PhD.

By default Cloud9 launches a workspace at /usr/lib/cloud9, which has useful examples and scripts for all sorts of applications. I want it to point, instead, to my personal projects folder so I’ll change the default Cloud9 workspace on the BeagleBone Black to /home/debian/projects.

Override systemd Service

Cloud9 is launched by /lib/systemd/system/cloud.service which explicitly starts the server pointing to /var/ib/cloud9.

In order to change this, we simply need to override the service with one that points to our desired directory. Packages generally install services in /lib/systemd/system while our new override will reside in /etc/systemd/system.

Step 1:

systemctl edit cloud9

This creates our override in /etc/systemd/system/cloud9.service.d/override.conf and opens up the file for editing. Then we simply clear ExecStart (since it is additive) and provide the new directory in that file.

[Service]
ExecStart=
ExecStart=/usr/bin/nodejs server.js --packed -w /home/debian/projects

Step 2:

Perform a daemon reload and restart the cloud9 service

systemctl daemon-reload
systemctl restart cloud9

Step 3:

Restart the browser. The new folder should now be the default workspace!

View my tutorial on setting up internet over USB on the BeagleBone Black.

The post Change the Default Cloud9 Workspace on the BeagleBone Black appeared first on Paul Bupe Jr, PhD.

Connecting a BeagleBone Black (BBB) to the internet over USB is a simple process thanks to the internet sharing capabilities of Windows. This is extremely convenient when developing because it allows your BeagleBone Black to have an internet connection as long as your computer or laptop has one, no matter the network, and SSH access over a single USB cable.

Windows Configuration

These instructions assume you have already installed an image on your BBB and can connect to the web interface. If not, the official documentation is extremely thorough and easy to follow.

Step 1: Configure your primary network interface for sharing.

Open the Run prompt (Win+R) and enter ncpa.cpl to open Network Connections.

You should see (in addition to your regular network connection) a new connection with a description that starts with “Linux USB Ethernet” or something similar. This is your BBB’s connection.

Right click on the internet connection your want to share (not on the BBB connection) and click on Properties. In the properties window click on the Sharing tab and check the box that says Allow other network users to connect through this computer’s Internet connection. Select the BBB’s connection under the Home networking connection: dropdown then click OK to save.

Double click on the BBB’s connection and click on Internet Protocol Version 4 (TCP/IPv4) to highlight it then click on Properties. Alternatively you can just double click on the text (not the checkbox).

Fill in the IP address and DNS information as shown in the image. The BBB will expect the computer to have an IP address of 192.168.7.1 and it will use the computer as a gateway to the internet.

That’s all the setup needed on the Windows machine!

Step 2: BeagleBone Black Configuration

All of the configuration needed on the BBB is in a single file. Interestingly, all the tutorials I’ve seen on this topic don’t show the proper way of configuring the network so that the changes are persistent.

SSH Access

The first step is to connect to the BBB via SSH. PuTTY is the de facto SSH client on Windows and I highly recommend it. Open up PuTTy and enter the BBB’s default IP address (192.169.7.2) then press Open. You may see a warning sign pop up if it’s the first time connecting to the IP but just click Yes and continue.

You’ll be asked for a login. The default credentials are:

login: debian
pass: temppwd

Be sure to change the password!

Note: When typing in the password, you will not see anything happening. That’s a security feature — just press enter when you enter the full password. 

Configuration

We will be editing the interfaces file, which is used to configure the network interfaces on the system as the name suggests. Enter the following command to open up the file for editing:

sudo nano /etc/network/interfaces

sudo ( originally called “superuser do”) temporarily elevates the security privileges of the debian user to the superuser so that it can modify system files. You will be asked to enter the user password which is temppwd in the default case. nano is a simple text editor that’s present on most Linux systems.

Once in the file, use the down arrow key or Page Down key to go to the bottom of the file where you should see entries for the usb0 interface. Enter the following information:

iface usb0 inet static
    address 192.168.7.2
    netmask 255.255.255.252
    network 192.168.7.0
    gateway 192.168.7.1
    dns-nameservers 8.8.8.8
    post-up route add default gw 192.168.7.1

When the system starts up, the system runs a configuration script located at /opt/scripts/boot/autoconfigure_usb0.sh
that reads this /etc/network/interfaces file and sets the IP address and netmask for the usb0 interface.

The configuration script also reads the dns-nameservers value and writes it to /etc/resolv.conf. Lastly, the script executes the post-up value line after the network interface is up (thus the name) in order to add the default gateway (which is the IP address we set on the Windows machine) to the route.

After making the changes, press CTRL+O to save the changes then CTRL+X to close the file. Reboot the system with:

sudo reboot

After the reboot is complete, connect to the system again (you can just right-click anywhere on the PuTTy window and click on Restart session).

The route command will show you if the gateway is set.

route

The /etc/resolv.conf file should also contain the nameserver entry.

cat /etc/resolv.conf

That’s all the configuration needed to get internet over USB working! You can test it out by pinging Google with ping google.com. You can press CTRL+C to stop the ping command.

The post Connecting a BeagleBone Black to the Internet over USB appeared first on Paul Bupe Jr, PhD.