I like boards like this for compact projects. If a Raspberry Pi Pico feels too long for your enclosure or breadboard layout, the RP2040-Zero is a nice alternative. The tradeoff is that the pin labels are tighter, some pins are on small pads, and the onboard LED is not a normal single-color LED. But once you know those details, it is quite easy to use.

In this tutorial, we will look at the RP2040-Zero features, pinout, Arduino IDE setup, boot mode, and a simple RGB LED blink program.

RP2040-Zero Features

The RP2040-Zero uses the RP2040 microcontroller, which has a dual-core Arm Cortex-M0+ processor running up to 133 MHz and 264 kB of SRAM. Waveshare’s RP2040-Zero board adds 2 MB of onboard flash, USB-C, castellated edges, and brings out 29 GPIO pins, although only some are available through the main pin headers.

Here are the main features:

https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

pico

Raspberry Pi Pico/RP2040 by Earle F. Philhower, III

Adafruit NeoPixel

#include <Adafruit_NeoPixel.h>

#define RGB_LED_PIN 16
#define NUM_LEDS 1

Adafruit_NeoPixel pixel(NUM_LEDS, RGB_LED_PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  pixel.begin();
  pixel.setBrightness(30);  // Keep it low so it is not too bright
  pixel.clear();
  pixel.show();
}

void loop() {
  // Red
  pixel.setPixelColor(0, pixel.Color(255, 0, 0));
  pixel.show();
  delay(500);

  // Green
  pixel.setPixelColor(0, pixel.Color(0, 255, 0));
  pixel.show();
  delay(500);

  // Blue
  pixel.setPixelColor(0, pixel.Color(0, 0, 255));
  pixel.show();
  delay(500);

  // Off
  pixel.clear();
  pixel.show();
  delay(500);
}

#define LED_PIN 0

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(500);

  digitalWrite(LED_PIN, LOW);
  delay(500);
}

#define POT_PIN 26

void setup() {
  Serial.begin(115200);
}

void loop() {
  int value = analogRead(POT_PIN);

  Serial.print("ADC value: ");
  Serial.println(value);

  delay(300);
}

The post RP2040-Zero Getting Started Guide: Pinout, Arduino IDE Setup, and RGB LED Blink appeared first on Microcontroller Tutorials.

That is where the L298N motor driver module comes in. In this tutorial, you will learn how to connect an L298N to a Raspberry Pi 5 and control one or two DC motors using Python.

We will cover the wiring, power supply setup, GPIO pin connections, Python code, motor direction control, PWM speed control, and common troubleshooting tips.

Why Use an L298N with Raspberry Pi 5?

The Raspberry Pi 5 GPIO pins are for logic signals, not motor power. A GPIO pin can switch between LOW and HIGH, but it cannot safely supply the current needed by a DC motor.

The L298N module acts as a bridge between the Raspberry Pi 5 and the motor. The Raspberry Pi sends control signals to the L298N, and the L298N handles the higher motor voltage and current.

With an L298N module, you can:

• Control the direction of a DC motor
• Control the speed of a DC motor using PWM
• Drive two DC motors independently
• Build a simple Raspberry Pi robot car
• Control small pumps, fans, gear motors, or other DC loads

Parts Needed

For this project, you will need:

• Raspberry Pi 5
• L298N motor driver module
• One or two DC motors
• External motor power supply, such as a 6V, 7.4V, 9V, or 12V battery pack
• Jumper wires
• Breadboard or screw terminals
• Raspberry Pi OS installed on your Raspberry Pi 5

Do not power the motors directly from the Raspberry Pi 5 GPIO pins. Use a separate motor power supply connected to the L298N module.

L298N Motor Driver Pinout

Most L298N modules have the following pins:

The actual label may vary depending on your L298N module. Some boards label the motor supply as +12V, even though the module can be used with other motor voltages within its supported range.

Important Power Warning

The L298N has separate power paths:

1. Motor power — connected to the L298N +12V or VIN terminal
2. Logic power — used by the L298N control circuit
3. GPIO signals — sent from the Raspberry Pi 5 to IN1, IN2, IN3, IN4, ENA, and ENB

For most beginner L298N modules, if the onboard 5V regulator jumper is installed and your motor supply is around 7V to 12V, the module can power its own logic circuit from the motor supply.

However, do not use the L298N 5V pin to power the Raspberry Pi 5. The Raspberry Pi 5 should be powered through its USB-C power input using a proper Raspberry Pi 5 power supply.

Also, the Raspberry Pi 5 and L298N must share a common ground. Without a common ground, the L298N may not correctly understand the GPIO signals from the Raspberry Pi.

Raspberry Pi 5 GPIO Pins Used

In this tutorial, we will use BCM GPIO numbering.

This pin selection avoids the Raspberry Pi 5 power pins and keeps the wiring simple.

Wiring One DC Motor to Raspberry Pi 5 and L298N

For one motor, connect Motor A only.

Motor A Wiring

If your L298N module has a jumper on ENA, remove it if you want to control motor speed using PWM from the Raspberry Pi. If the ENA jumper stays installed, Motor A will be enabled all the time, and you can only control direction using IN1 and IN2.

Wiring Two DC Motors

To control two motors, connect Motor B as well.

Remove the ENB jumper if you want PWM speed control for Motor B.

L298N Direction Logic

The L298N controls motor direction by changing the logic levels on its input pins.

Motor A Direction Table

Motor B works the same way, using IN3 and IN4.

Install GPIO Zero

On Raspberry Pi OS Bookworm, GPIO Zero is the recommended beginner-friendly Python library for GPIO control.

Open a terminal and run:

sudo apt update
sudo apt install python3-gpiozero python3-lgpio

GPIO Zero provides a simple way to control motors, LEDs, buttons, and PWM outputs from Python.

Python Code for One Motor

Create a new file:

nano l298n_one_motor.py

Paste this code:

from gpiozero import Motor
from time import sleep


# BCM GPIO numbering
# Motor A:
# IN1 = GPIO17
# IN2 = GPIO27
# ENA = GPIO22


motor_a = Motor(forward=17, backward=27, enable=22, pwm=True)


try:
    print("Motor forward")
    motor_a.forward(speed=0.7)
    sleep(2)


    print("Motor stop")
    motor_a.stop()
    sleep(1)


    print("Motor reverse")
    motor_a.backward(speed=0.7)
    sleep(2)


    print("Motor stop")
    motor_a.stop()


except KeyboardInterrupt:
    motor_a.stop()
    print("Stopped")

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

Run the program:

python3 l298n_one_motor.py

The motor should spin forward, stop, spin in reverse, and stop again.

If the motor spins in the opposite direction from what you expect, swap the motor wires connected to OUT1 and OUT2, or swap the GPIO assignments for forward and backward in the code.

Python Code for Two Motors

For a simple robot car, you can use both L298N channels.

Create a new file:

nano l298n_two_motors.py

Paste this code:

from gpiozero import Motor
from time import sleep


# Motor A
# IN1 = GPIO17
# IN2 = GPIO27
# ENA = GPIO22
left_motor = Motor(forward=17, backward=27, enable=22, pwm=True)


# Motor B
# IN3 = GPIO23
# IN4 = GPIO24
# ENB = GPIO25
right_motor = Motor(forward=23, backward=24, enable=25, pwm=True)


def stop():
    left_motor.stop()
    right_motor.stop()


try:
    print("Forward")
    left_motor.forward(speed=0.7)
    right_motor.forward(speed=0.7)
    sleep(2)


    print("Backward")
    left_motor.backward(speed=0.7)
    right_motor.backward(speed=0.7)
    sleep(2)


    print("Turn left")
    left_motor.backward(speed=0.6)
    right_motor.forward(speed=0.6)
    sleep(1)


    print("Turn right")
    left_motor.forward(speed=0.6)
    right_motor.backward(speed=0.6)
    sleep(1)


    print("Stop")
    stop()


except KeyboardInterrupt:
    stop()
    print("Stopped")

Run it:

python3 l298n_two_motors.py

This code moves both motors forward, backward, then turns left and right by spinning the motors in opposite directions.

Controlling Motor Speed

The speed value in GPIO Zero can be set from 0 to 1.

For example:

motor_a.forward(speed=0.3)  # slow
motor_a.forward(speed=0.7)  # medium
motor_a.forward(speed=1.0)  # full speed

If the motor does not move at very low speed values, that is normal. DC motors need enough voltage and current to overcome friction and start rotating. Try increasing the speed value until the motor starts moving reliably.

Why the Motor Supply Should Be Separate

A common beginner mistake is trying to power the motor from the Raspberry Pi 5. This is not recommended.

Motors draw much more current than GPIO pins can provide. They also create voltage dips and electrical noise when starting, stopping, or changing direction. These dips can cause the Raspberry Pi to reboot, freeze, or behave unpredictably.

Use a separate battery pack or DC power supply for the motor side of the L298N. Then connect the grounds:

Raspberry Pi GND ---- L298N GND ---- Battery negative

This common ground gives the GPIO signals a shared voltage reference.

Can the Raspberry Pi 5 GPIO Control the L298N Directly?

Yes. The Raspberry Pi 5 uses 3.3V GPIO logic, while the L298N accepts TTL-style logic input levels. In typical use, a Raspberry Pi HIGH signal is enough for the L298N input pins.

However, never feed 5V signals into the Raspberry Pi 5 GPIO pins. The Raspberry Pi GPIO pins are not 5V tolerant. The control direction should be from the Raspberry Pi GPIO pins to the L298N inputs, not the other way around.

Troubleshooting

Motor does not spin

Check the following:

• Is the external motor power supply connected?
• Is the L298N GND connected to Raspberry Pi GND?
• Are the motor wires connected to OUT1 and OUT2?
• Is the ENA jumper removed if you are using GPIO PWM?
• Is the Python code using the correct BCM GPIO numbers?
• Is the motor power supply strong enough for the motor?

Motor only runs at full speed

The ENA jumper may still be installed. Remove the ENA jumper and connect ENA to the Raspberry Pi PWM GPIO pin used in the code.

Raspberry Pi reboots when motor starts

The motor may be pulling too much current or causing a voltage drop. Use a separate motor power supply and do not power the motor from the Raspberry Pi. Also make sure your Raspberry Pi 5 power supply is strong enough.

Motor direction is reversed

Swap the two motor wires, or swap the forward and backward GPIO pins in the Python code.

Python GPIO code does not work on Raspberry Pi 5

Many older Raspberry Pi tutorials use RPi.GPIO. On Raspberry Pi 5, it is better to use GPIO Zero with a compatible backend such as lgpio. Install the needed packages using:

sudo apt install python3-gpiozero python3-lgpio

Final Thoughts

Connecting an L298N to a Raspberry Pi 5 is a useful starting point for robot cars, motorized mechanisms, pumps, fans, and other DC motor projects. The most important thing to remember is that the Raspberry Pi controls the L298N with GPIO signals, but the motor itself must be powered separately.

Once you have the basic wiring working, you can expand this project by adding buttons, distance sensors, line sensors, camera-based object detection, or web-based motor control from a Raspberry Pi 5 dashboard.

The post Connect L298N to Raspberry Pi 5: Control DC Motors with Python appeared first on Microcontroller Tutorials.

By the end of this guide, you’ll have a Raspberry-Pi-powered device that:

• Listens for your voice
• Converts your speech into text
• Sends that text to an LLM
• Converts the LLM’s response into natural speech
• Speaks it aloud

It feels surprisingly close to a commercial smart assistant—just without the Amazon ecosystem behind it.

Why I Chose Raspberry Pi 5 for My Voice Assistant

The Raspberry Pi 5 is powerful enough to handle:

• Live audio recording
• Streaming data to an LLM
• Playing back voice responses
• Handling wake-word models like Porcupine

Its quad-core CPU and USB 3.0 bandwidth make it perfect for a responsive, low-latency voice assistant.

What You Need

Hardware

• Raspberry Pi 5 (4GB or 8GB recommended)
• USB microphone (Blue Snowball, Fifine, or any generic USB mic)
• Speakers or a USB sound card with speakers
• Raspberry Pi OS (Bookworm), fully updated
• Internet connection (Wi-Fi or Ethernet)

Software & APIs

• Python 3.11+ (pre-installed on Pi OS)
• OpenAI Realtime API (or any LLM with STT + TTS endpoints)
• Picovoice Porcupine (optional wake-word detection)
• Python libraries: sounddevice, pyaudio, websockets, requests

Step 1 — Updating My Raspberry Pi 5

I always begin by updating the Pi:

Then install required audio tools:

Step 2 — Setting Up My USB Microphone

I plugged in my mic and checked if the Pi detected it:

To test recording:

If I heard my voice, the microphone and speaker were good to go.

Step 3 — Installing Python Libraries

I installed everything I needed for recording audio, playing audio, and talking to the LLM:

If I planned to add a wake word:

Step 4 — Setting Up the LLM (OpenAI Realtime)

To get real-time conversational audio, I used the OpenAI Realtime WebSocket endpoint.
This gives me:

• Streaming speech-to-text
• Streaming conversation
• Streaming text-to-speech

All in one pipeline.

I simply created an API key in my OpenAI account and stored it:

Step 5 — Creating My Simple Push-to-Talk Voice Assistant (MVP)

Before getting fancy with wake words, I built a press-Enter-to-talk version.

This script:

1. Records my voice
2. Sends audio to Whisper STT
3. Sends text to an LLM
4. Converts reply text to speech
5. Plays the audio

Create the file:

Paste this:

import sounddevice as sd
import numpy as np
import requests
import json
import subprocess
import tempfile

OPENAI_KEY = open("/home/pi/.openai_key").read().strip()

# Record function
def record_audio(duration=4, fs=16000):
    print("🎙 Speak now...")
    audio = sd.rec(int(duration * fs), samplerate=fs, channels=1, dtype='int16')
    sd.wait()
    print("⏹ Recording stopped")
    return audio.tobytes()

# Send audio -> STT
def speech_to_text(audio_bytes):
    response = requests.post(
        "https://api.openai.com/v1/audio/transcriptions",
        headers={"Authorization": f"Bearer {OPENAI_KEY}"},
        files={"file": ("speech.wav", audio_bytes, "audio/wav")},
        data={"model": "gpt-4o-mini-transcribe"}
    )

    return response.json()["text"]

# LLM call
def ask_llm(text):
    payload = {
        "model": "gpt-4o-mini",
        "messages": [{"role": "user", "content": text}]
    }

    response = requests.post(
        "https://api.openai.com/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {OPENAI_KEY}",
            "Content-Type": "application/json"
        },
        data=json.dumps(payload)
    )

    return response.json()["choices"][0]["message"]["content"]

# Text-to-speech
def tts(text):
    response = requests.post(
        "https://api.openai.com/v1/audio/speech",
        headers={
            "Authorization": f"Bearer {OPENAI_KEY}"
        },
        json={
            "model": "gpt-4o-mini-tts",
            "voice": "alloy",
            "input": text
        }
    )

    return response.content

# Play sound
def play_audio(audio_bytes):
    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as f:
        f.write(audio_bytes)
        f.flush()
        subprocess.run(["ffplay", "-nodisp", "-autoexit", f.name])

# Main loop
while True:
    input("\n👉 Press Enter to talk...")
    audio = record_audio()
    text = speech_to_text(audio)
    print("🗣 You said:", text)

    reply = ask_llm(text)
    print("🤖 Assistant:", reply)

    audio_reply = tts(reply)
    play_audio(audio_reply)

Run it:

I now had a functional voice AI that:

• Listens when I press Enter
• Understands what I say
• Responds using natural speech

Step 6 — Adding Wake-Word Detection (Optional Upgrade)

To get that Alexa-like "always listening" experience, I added Porcupine.

Install the engine:

I then created a second script,

wake_assistant.py

• Continuously listens for the wake word (e.g., “Jarvis”)
• When triggered, runs the same record → STT → LLM → TTS pipeline

(Want me to include the full wake-word script? I can add it.)

Step 7 — (Optional) Using OpenAI Realtime for Streaming Audio

For true Alexa behavior—interrupting, barge-in, low latency—I can give you the Realtime WebSocket version too. It allows:

• Speaking to the Pi without waiting for a stop signal
• The LLM to start responding while I'm still talking
• Beautifully fluid conversation

Just tell me if you want the full Realtime streaming version.

Step 8 — Autostarting My Voice Assistant on Boot

I made my AI device boot straight into “always listening” mode using systemd:

Service file:

[Unit]
Description=Raspberry Pi Voice Assistant
After=network.target

[Service]
ExecStart=/usr/bin/python3 /home/pi/assistant.py
WorkingDirectory=/home/pi
Restart=always
User=pi

[Install]
WantedBy=multi-user.target

Enable it:

Now my Pi automatically behaves like a smart speaker.

Final Thoughts

Building my own Alexa-style voice assistant on the Raspberry Pi 5 turned out to be:

• Easier than expected
• Surprisingly powerful
• Fully customizable
• Not locked into any ecosystem

I can choose any wake word, any personality, any LLM, and I fully own the device.

If you want to extend this project, here are ideas:

• Add home automation (MQTT, Home Assistant)
• Display responses on a small touchscreen
• Allow multi-room audio
• Build a custom housing with 3D printing
• Add LED rings like Alexa Echo

The post How I Built an Alexa-Like Voice Assistant Using Raspberry Pi 5 and an LLM appeared first on Microcontroller Tutorials.

Prerequisites

Hardware

Software

Flash MicroPython Firmware with HID Support

By default, the official MicroPython firmware does not include HID functionality. We will use a custom MicroPython firmware that supports HID.

1. Download the MicroPython firmware with HID support from a trusted source (e.g., https://github.com/adafruit/circuitpython).
2. Put the Pico in bootloader mode by holding the BOOTSEL button while plugging it into your computer via USB.
3. Drag and drop the downloaded .uf2 file onto the mounted RPI-RP2 drive.

Once the Pico restarts, it is ready to run MicroPython.

Install Required Libraries

To use the HID functions, you need to install the usb_hid library.

1. Open Thonny IDE.
2. Connect your Pico and open a new script.
3. Import the necessary libraries:

<span>import time
import usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode
from adafruit_hid.mouse import Mouse</span>

Emulating a Keyboard

The following code sends a "Hello, World!" message when the Pico is connected:

<span>kbd = Keyboard(usb_hid.devices)
time.sleep(1)  # Allow time for HID initialization

kbd.send(Keycode.H, Keycode.E, Keycode.L, Keycode.L, Keycode.O, Keycode.COMMA, Keycode.SPACE,
         Keycode.W, Keycode.O, Keycode.R, Keycode.L, Keycode.D, Keycode.EXCLAMATION)</span>

This script mimics pressing the keys HELLO, WORLD! on a standard keyboard.

Controlling Mouse Movements

To control the mouse, use the Mouse class:

<span>mouse = Mouse(usb_hid.devices)
time.sleep(1)

# Move the mouse to the right
mouse.move(x=50)
time.sleep(1)

# Move the mouse down
mouse.move(y=50)
time.sleep(1)

# Perform a left-click
mouse.click(Mouse.LEFT_BUTTON)</span>

This code moves the mouse cursor and performs a left-click action.

Automating Keyboard and Mouse Actions

You can create automation scripts, such as making the Pico send keystrokes when a button is pressed. Here’s an example:

<span>import machine
button = machine.Pin(2, machine.Pin.IN, machine.Pin.PULL_UP)

while True:
    if not button.value():  # When button is pressed
        kbd.send(Keycode.A)  # Simulate pressing 'A'
        time.sleep(0.5)  # Prevent spamming</span>

Conclusion

With these steps, you can turn your Raspberry Pi Pico into a powerful HID device. You can use it for automation, accessibility solutions, or even creative input devices. Experiment with different key sequences and mouse movements to build your custom HID solutions!

The post Using Raspberry Pi Pico as an HID to Control Mouse Movements and Keyboard Strokes appeared first on Microcontroller Tutorials.

Step 1: Set Up Raspberry Pi OS

Before turning your Raspberry Pi into a WiFi repeater, you need a working operating system. Raspberry Pi OS is lightweight and optimized for the Pi, making it ideal for this project.

Install Raspberry Pi OS:

Download the latest Raspberry Pi OS Lite (or Desktop) from the official website.

Flash the OS to your microSD card using a tool like Raspberry Pi Imager or Balena Etcher.

Enable SSH:

SSH allows you to remotely access your Raspberry Pi’s terminal. This is especially useful if you’re running the Lite version (headless) without a graphical interface.

Create an empty file named ssh (no extension) in the boot partition of the microSD card to enable SSH.

Boot the Raspberry Pi:

Insert the microSD card into the Raspberry Pi, connect it to power, and boot it up.

Connect to the Raspberry Pi:

Use SSH to connect to your Raspberry Pi. If you’re using the desktop version, you can also use the terminal directly.

ssh pi@raspberrypi.local

The default password is raspberry.

Update the system:

Updating the system ensures that you have the latest security patches and software updates.

sudo apt update
sudo apt upgrade -y

Step 2: Install Required Software

 To create a WiFi repeater, you need software to manage the access point (hostapd) and handle DHCP assignments (dnsmasq).

Install the necessary packages:

sudo apt install hostapd dnsmasq -y

hostapd: Creates a wireless access point.

dnsmasq: Manages DHCP and DNS services for the devices connecting to your repeater.

Stop the services for now:

sudo systemctl stop hostapd
sudo systemctl stop dnsmasq

We stop the services temporarily to configure them properly before starting them again.

Step 3: Configure the WiFi Interfaces

 The Raspberry Pi needs to know how to handle its WiFi interfaces. We configure one interface (wlan0) to act as the access point and another (wlan1, if available) to connect to the main WiFi network.

Identify your WiFi interfaces:

Run the following command to see your wireless interfaces:

iwconfig

Typically, the built-in WiFi interface is named wlan0.

Edit the network interfaces file:

Open the network interfaces configuration file:

sudo nano /etc/network/interfaces

Add the following lines to configure wlan0:

auto wlan0
iface wlan0 inet static
    address 192.168.42.1
    netmask 255.255.255.0

This assigns a static IP address to wlan0, which will act as the access point.

Save and exit (Ctrl+X, then Y, then Enter).

Step 4: Configure hostapd

hostapd is responsible for creating the WiFi access point. We configure it to broadcast a WiFi network with a specific SSID and password.

Create a configuration file for hostapd:

sudo nano /etc/hostapd/hostapd.conf

Add the following configuration (adjust the SSID and password as needed):

interface=wlan0
driver=nl80211
ssid=MyRPiRepeater
hw_mode=g
channel=6
wmm_enabled=0
macaddr_acl=0
auth_algs=1
ignore_broadcast_ssid=0
wpa=2
wpa_passphrase=MySecurePassword
wpa_key_mgmt=WPA-PSK
rsn_pairwise=CCMP

interface=wlan0: Specifies the WiFi interface to use.

ssid=MyRPiRepeater: The name of the WiFi network.

wpa_passphrase=MySecurePassword: The password for the WiFi network.

Point hostapd to the configuration file:

sudo nano /etc/default/hostapd

Find the line #DAEMON_CONF="" and replace it with:

DAEMON_CONF="/etc/hostapd/hostapd.conf"

This tells hostapd where to find its configuration file.

Step 5: Configure dnsmasq

 dnsmasq assigns IP addresses to devices connecting to your repeater and handles DNS requests.

Edit the dnsmasq configuration file:

sudo nano /etc/dnsmasq.conf

Add the following lines:

interface=wlan0
dhcp-range=192.168.42.10,192.168.42.100,255.255.255.0,24h

interface=wlan0: Specifies the interface to manage.

dhcp-range: Defines the range of IP addresses to assign to connected devices.

Step 6: Enable IP Forwarding

IP forwarding allows the Raspberry Pi to route traffic between the WiFi repeater and the main network.

Enable IP forwarding by editing the sysctl.conf file:

sudo nano /etc/sysctl.conf

Uncomment or add the following line:

net.ipv4.ip_forward=1

This enables IP forwarding at the kernel level.

Apply the changes:

sudo sh -c "echo 1 > /proc/sys/net/ipv4/ip_forward"

Set up NAT (Network Address Translation):

sudo iptables -t nat -A POSTROUTING -o wlan1 -j MASQUERADE
sudo sh -c "iptables-save > /etc/iptables.ipv4.nat"

NAT allows devices connected to the repeater to access the internet through the main network.

Make the iptables rule persistent:

Edit the rc.local file:

sudo nano /etc/rc.local

Add the following line before exit 0:

iptables-restore < /etc/iptables.ipv4.nat

This ensures the NAT rule is applied on boot.

Step 7: Start the Services

 Starting hostapd and dnsmasq activates the WiFi repeater functionality.

Start and enable hostapd and dnsmasq:

sudo systemctl unmask hostapd
sudo systemctl enable hostapd
sudo systemctl start hostapd
sudo systemctl start dnsmasq

Reboot the Raspberry Pi:

sudo reboot

Step 8: Connect to Your WiFi Repeater

 Once the Raspberry Pi is set up, you need to connect your devices to the new WiFi network.

After the Raspberry Pi reboots, it will act as a WiFi repeater.

Search for the SSID you configured (e.g., MyRPiRepeater) on your devices and connect using the password you set.

Optional: Automate the Process

If you want the Raspberry Pi to automatically connect to your main WiFi network and extend it, you can configure wpa_supplicant.

Edit the wpa_supplicant configuration:

sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

Add the following lines (replace YourMainSSID and YourMainPassword with your network details):

network={
    ssid="YourMainSSID"
    psk="YourMainPassword"
}

Reboot the Raspberry Pi to apply the changes.

Conclusion

By following these steps, you’ve turned your Raspberry Pi into a WiFi repeater/extender. Each step is designed to configure the necessary components (access point, DHCP, IP forwarding, etc.) to ensure seamless operation. If you encounter issues, double-check the configuration files and ensure all services are running properly. Enjoy your extended WiFi coverage!

The post How to Turn a Raspberry Pi into a WiFi Repeater/Extender appeared first on Microcontroller Tutorials.

What You'll Need

Step 1: Understand the Rotary Encoder

A rotary encoder typically has:

1. Two outputs (A and B) that produce pulses as the encoder shaft rotates. The phase difference between these pulses determines the rotation direction.
2. A push-button (optional) that can act as an additional input.

Pinout Example (common encoders):

• CLK (A): Clock pulse output
• DT (B): Direction pulse output
• SW: Push-button output
• +: Power (3.3V or 5V)
• GND: Ground

Step 2: Wire the Rotary Encoder to Raspberry Pi

1. Power the Encoder:
   • Connect the encoder’s + pin to Raspberry Pi's 3.3V pin.
   • Connect the GND pin to a Raspberry Pi GND pin.
2. Connect the Output Pins:
   • Connect the CLK (A) pin to GPIO17 (physical pin 11).
   • Connect the DT (B) pin to GPIO18 (physical pin 12).
3. Connect the Push Button (if available):
   • Connect the SW pin to GPIO27 (physical pin 13).
   • Add a pull-down resistor (10kΩ) if necessary.

Step 3: Install Required Libraries

Ensure your Raspberry Pi has Python and GPIO libraries installed:

sudo apt update
sudo apt install python3-rpi.gpio

Step 4: Write the Python Code

Here's an example script to read rotary encoder inputs:

Code:

import RPi.GPIO as GPIO

from time import sleep


# GPIO Pins
CLK = 17
DT = 18
SW = 27  # Optional: Push button

# Setup
GPIO.setmode(GPIO.BCM)
GPIO.setup(CLK, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(DT, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(SW, GPIO.IN, pull_up_down=GPIO.PUD_UP)  # Pull-up for button

# Variables
counter = 0
last_clk = GPIO.input(CLK)

try:
    while True:
        # Read current state of CLK
        current_clk = GPIO.input(CLK)
        current_dt = GPIO.input(DT)

        if current_clk != last_clk:  # Detect a change in CLK
            if current_dt != current_clk:
                counter += 1  # Clockwise
            else:
                counter -= 1  # Counter-clockwise
            print(f"Counter: {counter}")

        last_clk = current_clk

        # Check button press
        if GPIO.input(SW) == GPIO.LOW:
            print("Button pressed!")
            sleep(0.3)  # Debounce delay

        sleep(0.01)  # Small delay to stabilize readings

except KeyboardInterrupt:
    print("\nExiting...")

finally:
    GPIO.cleanup()

Step 5: Run the Script

Save the script as rotary_encoder.py and run it:

python3 rotary_encoder.py

Rotate the encoder and observe the printed values in the terminal. Press the button (if available) to test its functionality.

Step 6: Implement in a Project

Once you've mastered the basics, you can integrate the rotary encoder into projects like:

• Volume controllers
• Menu navigation
• Custom input devices

Tips:

• Debouncing: Rotary encoders might generate false pulses due to mechanical noise. Use software debouncing if needed.
• Interrupts: For real-time response, consider using GPIO interrupts instead of polling.

By following this guide, you can harness the power of a rotary encoder in your Raspberry Pi projects!

The post How to Use a Rotary Encoder with Raspberry Pi appeared first on Microcontroller Tutorials.

Prerequisites

Step 1: Update Your Raspberry Pi

Before installing Django, ensure your Raspberry Pi is up to date:

sudo apt update
sudo apt upgrade -y

Step 2: Install Python and Required Tools

Django requires Python 3 and pip (Python’s package manager). These are typically pre-installed, but verify their presence:

python3 --version
pip3 --version

If missing, install them:

sudo apt install python3 python3-pip -y

Install venv to create isolated Python environments:

sudo apt install python3-venv -y

Step 3: Set Up a Virtual Environment

It's best to run Django in a virtual environment to avoid conflicts with system-wide packages.

1. Create a directory for your project:
2. mkdir ~/django_project
3. cd ~/django_project
4. Create and activate the virtual environment:
5. python3 -m venv env
6. source env/bin/activate

You’ll notice your shell prompt changes to indicate the environment is active.

Step 4: Install Django

With the virtual environment active, install Django using pip:

pip install django

Verify the installation:

django-admin --version

Step 5: Start a Django Project

Create a new Django project:

django-admin startproject mysite
cd mysite

Next, run the development server to ensure everything works:

python manage.py runserver 0.0.0.0:8000

After this, visit http://<Raspberry_Pi_IP>:8000 in a browser to see the Django welcome page.

Step 6: Configure Django for Deployment

Update settings.py:

To allow external connections, open the settings.py using nano or vim. Look for this line:

ALLOWED_HOSTS = ['<Raspberry_Pi_IP>', 'localhost']

Set up static files:

STATIC_ROOT = BASE_DIR / 'staticfiles'

Run the following to collect static files:

python manage.py collectstatic

Step 7: Install and Configure Gunicorn

Gunicorn is a Python WSGI server that helps deploy Django applications. To install, run:

pip install gunicorn

After this, test gunicorn it with your project:

gunicorn mysite.wsgi:application --bind 0.0.0.0:8000

Step 8: Set Up Nginx as a Reverse Proxy

Nginx will serve as a reverse proxy for Gunicorn. Install Nginx using:

sudo apt install nginx -y

Then configure Nginx for your Django project. For this, we create a new configuration file:

sudo nano /etc/nginx/sites-available/mysite

Then we write the following to the configuration file:

server {
    listen 80;
    server_name <Raspberry_Pi_IP>;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    location /static/ {
        alias /home/pi/django_project/mysite/staticfiles/;
    }
}

Next, enable the configuration:

sudo ln -s /etc/nginx/sites-available/mysite /etc/nginx/sites-enabled/

sudo nginx -t
sudo systemctl restart nginx

Step 9: Enable Gunicorn to Start at Boot

Create a systemd service file for Gunicorn:

sudo nano /etc/systemd/system/gunicorn.service

Add the following:

[Unit]

Description=gunicorn daemon for Django
After=network.target

[Service]
User=pi
Group=www-data
WorkingDirectory=/home/pi/django_project/mysite
ExecStart=/home/pi/django_project/env/bin/gunicorn --workers 3 --bind unix:/home/pi/django_project/mysite.sock mysite.wsgi:application

[Install]
WantedBy=multi-user.target
Start and enable the service:
sudo systemctl start gunicorn
sudo systemctl enable gunicorn

Step 10: Test the Deployment

Visit http://<Raspberry_Pi_IP> in a browser. You should see your Django application served by Nginx and Gunicorn.

Conclusion

You've successfully set up a Django web server on a Raspberry Pi! This setup is perfect for small-scale projects, educational purposes, or prototyping IoT applications. For production environments, consider securing your server with HTTPS using tools like Let's Encrypt.

Feel free to extend your application with features or integrate it with sensors and GPIO for an IoT-powered web solution.

The post Building a Django Webserver on Raspberry Pi: A Step-by-Step Guide appeared first on Microcontroller Tutorials.

The Raspberry Pi Pico is a versatile microcontroller from the Raspberry Pi Foundation. It features the RP2040 microcontroller chip, offering dual-core ARM Cortex-M0+ processors and a variety of I/O pins.  Its affordability, GPIO flexibility, and programmability make it an excellent choice for various applications, including motor control projects using devices like the L298N motor driver.

The L298N simplifies the management of DC and stepper motors, allowing for control over speed and direction. This level of motor control is indispensable in scenarios where accuracy and reliability are key factors, such as in robotic vehicles, automated systems, and various electromechanical projects. Integrating the L298N with the Raspberry Pi Pico enhances the capabilities of the microcontroller, providing users with a powerful but cheap solution for motor-driven applications.

This tutorial serves as a guide for makers looking to build projects featuring the Raspberry Pi Pico and the L298N motor driver. My goal is to provide instructions on how to set up, program, and control motors seamlessly. This tutorial aims to help both beginners and experienced hobbyists easily understand Raspberry Pi Pico and L298N motor control for creative DIY projects.

Setting Up Raspberry Pi Pico and Arduino IDE

This tutorial uses Arduino to program the Raspberry Pi Pico. To know how to add the Pico to your Arduino IDE, read this tutorial.

Understanding L298N Motor Driver

Overview of L298N motor driver features

The L298N motor driver boasts essential features for effective motor control. With a dual H-bridge configuration, it supports bidirectional control, enabling precise management of DC motors in both forward and backward directions. This IC drives two motors through two channels, A and B. For example, if a motor is using channel A, its terminals must be connected to pins Out 1 and Out 2. The Enable A pin must be high to turn on the motor. To drive a motor to a direction, say, clockwise, the pin Input 1 must be high while the pin Input 2 must be low. To drive the motor counterclockwise, the pin Input 1 is low while the pin Input 2 is high.

L298N motor controller board

Makers will consider using the L298N breakout board as it is easier for prototyping.

The controller board, shown above, has terminals with labels +12V and +5V. The +12V terminal is where the motor power connects. While it is common to put in +12 VDC to this terminal, it can accept voltages from +7 VDC to +35 VDC. Just remove the jumper behind the +12V terminal if you are planning to power the motors higher than +12V.

When the +12V jumper is attached, the onboard voltage regulator is now usable, and you can source +5V from the +5V terminal. This means the +5V terminal is not for powering the board but for powering a 5V external device.

You have Motor A inputs and Motor B inputs. These connect to the microcontroller. The minimum high voltage is 2.3V, which means the 3.3V logic high from Raspberry Pi Pico is good enough.

The motor terminals connect to Motor Terminals 1, 2, 3, 4. Specifically, motor A connects to terminals 1 and 2 while Motor B connects to terminals 3 and 4.

There are also two other jumpers on the board, as shown. Remove these jumpers if you are using DC motors and keep them for stepper motors. Speed control for Motor A and Motor B is achieved via PWM on these pins.

Connecting L298N to Raspberry Pi Pico and DC Motors

The motor input pins can be connected to any digital I/O pin of the Raspberry Pi Pico. Conversely, the motor-enable pins must be wired to PWM-capable pins. Thankfully for the Pico, almost all of its GPIO pins are PWM-capable.

The Raspberry Pi Pico here gets its power from the L298N board via the 5V terminal. A Schottky diode is added to prevent backpowering. This is a setup suggested in the Raspberry Pi Pico datasheet, section 4.5.

Writing Arduino Code for DC Motor Control

Using the L298N is straightforward. Imagine a robot with two wheels. If you want the robot to move to the left, rotate the right motor forward and rotate the left motor backward.

For the left motor (motor A) to rotate in one direction, apply a high pulse to IN1 and a low pulse to IN2. To reverse the direction, reverse the pulses to IN1 and IN2. The same applies to the right motor (motor B).

Here’s a table that summarizes the pins and corresponding motor direction. This assumes that the upper DC motor is the left motor and the lower one is the right motor.

In the code, first, let us define the pins according to the wiring diagram above:

#define EnA 22
#define EnB 21
#define In1 24
#define In2 25
#define In3 26
#define In4 27

Then we initialize all of them as output pins:

void setup()
{
// All motor control pins are outputs
  pinMode(EnA, OUTPUT);
  pinMode(EnB, OUTPUT);
  pinMode(In1, OUTPUT);
  pinMode(In2, OUTPUT);
  pinMode(In3, OUTPUT);
  pinMode(In4, OUTPUT);
}

Next, we create functions corresponding to the actions in the table above: stop, forward, reverse, left, and right.

For stopping the motors, we make all of the motor control pins low, including EnA and EnB.

// Function to stop all motors
void stop ()
{
  digitalWrite(EnA, LOW);
  digitalWrite(EnB, LOW);
  digitalWrite(In1, LOW);
  digitalWrite(In2, LOW);
  digitalWrite(In3, LOW);
  digitalWrite(In4, LOW);
}

To move forward, we enable both motors and make them turn in the same direction. Enabling the motors requires a pulse to EnA/EnB, doable via the analogWrite() command. Here we use a value of 100 out of 255 for our duty cycle. Experiment with which duty cycle value is right for your motors.

// Function to move forward
void forward ()
{
  analogWrite(EnA, 100);
  analogWrite(EnB, 100);
  digitalWrite(In1, HIGH);
  digitalWrite(In2, LOW);
  digitalWrite(In3, HIGH);
  digitalWrite(In4, LOW);
}

To reverse, just logically reverse the function above, keeping the same duty cycle for EnA and EnB.

// Function to move in reverse
void reverse ()
{
  analogWrite(EnA, 100);
  analogWrite(EnB, 100);
  digitalWrite(In1, LOW);
  digitalWrite(In2, HIGH);
  digitalWrite(In3, LOW);
  digitalWrite(In4, HIGH);
}

To move left, rotate the right motor forward and the left motor backward. Moving left logically requires the inverse of moving left.

// Function to move left
void left ()
{
  analogWrite(EnA, 100);
  analogWrite(EnB, 100);
  digitalWrite(In1, LOW);
  digitalWrite(In2, HIGH);
  digitalWrite(In3, HIGH);
  digitalWrite(In4, LOW);
}

// Function to move right
void right ()
{
  analogWrite(EnA, 100);
  analogWrite(EnB, 100);
  digitalWrite(In1, HIGH);
  digitalWrite(In2, LOW);
  digitalWrite(In3, LOW);
  digitalWrite(In4, HIGH);
}

Now we have all five functions to control our motors! Simply call them inside the loop() method.

Example Code

You can find an example code in this repository where you can control the direction of the motors via a serial monitor. For example, if you type “forward”, the motors will move forward, and so on.

Connecting L298N to Raspberry Pi Pico and DC Motors

The L298N can also control stepper motors, specifically bipolar stepper motors. This time, the enable-pin jumpers must be on. The four pins from the stepper motor then connect to the motor output pins of the L298N module. Here is a wiring diagram featuring the Raspberry Pi Pico as the microcontroller:

To rotate the stepper motor, the motor output pins must provide power in a specific sequence. The four pins of the stepper motor are the end of the coils in this diagram:

When powering the coils in sequence, the permanent magnet rotor rotates according to that sequence. For simplicity, we will implement what is called a half-step drive:

Writing Arduino Code for Stepper Motor Control

The Arduino platform contains a built-in stepper library called Stepper. To use, include <Stepper.h>  and initiate the Stepper object using the number of steps per revolution and the GPIO pins for IN1 to IN4.

#include <Stepper.h>

#define In1 24
#define In2 25
#define In3 26
#define In4 27

const int stepsPerRevolution = 64;

// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, In1, In2, In3, In4);

Set the stepper motor speed inside setup()

void setup() {
//Set the speed at 60 rpm:
  myStepper.setSpeed(60);
// initialize the serial port:
  Serial.begin(9600);
}

To move the stepper motor, call the step() function with an argument equal to the steps per revolution.

myStepper.step(stepsPerRevolution);

Here is a simple sketch that rotates the stepper in one direction and then in the other direction.

#include <Stepper.h>

const int stepsPerRevolution = 64; // change this to fit the number of steps per revolution
// for your motor

// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

void setup() {
// set the speed at 60 rpm:
  myStepper.setSpeed(60);
// initialize the serial port:
  Serial.begin(9600);
}

void loop() {
// step one revolution in one direction:
  Serial.println("clockwise");
  myStepper.step(stepsPerRevolution);
  delay(500);

// step one revolution in the other direction:
  Serial.println("counterclockwise");
  myStepper.step(-stepsPerRevolution);
  delay(500);
}

The disadvantage of using the built-in stepper library is that there’s no option to change the stepping mode as it defaults to wave drive only. When the stepper motor is moving, it blocks other Arduino functions. Also, the built-in library is limited to one stepper motor.

A better library for controlling stepper motors is the AccelStepper library by AirSpayce. Besides support for half-step driving and multiple motors, the library also offers acceleration and deceleration functions, among other things.

I hope that this tutorial, in some way, helps makers like you and me. For any questions, reactions, or concerns, feel free to drop comments below. You can also follow our Facebook, TikTok, and Instagram accounts. As always, happy building!

The post Raspberry Pi Pico L298N Motor Control appeared first on Microcontroller Tutorials.

Beginner tutorials on the web often use the HC-SR04 ultrasonic sensor. Why? Because it’s easy to use and requires a few short lines of code. So when I tried it with the Raspberry Pi Pico, I expected it to work immediately. Until it didn’t.

Fortunately, I made it to work, thanks to a few days of scouring the internet. I made this tutorial hoping that you will not spend the same time as me.

The code in this tutorial uses the Raspberry Pi Pico Arduino core by Earle F. Philhower. Head over to this tutorial on how to set it up.

How the HC-SR04 Ultrasonic Sensor Works

I always assume every one of my readers is a beginner. So I have to give every detail including how the sensor works. If you already know this, kindly skip to the next section.

The ultrasonic sensor works by knowing the time between sending a sound and having that sound reflected to its source. The distance then between the sound source and the reflector is half that time multiplied by the speed of sound. The sound is above the hearing range of humans hence it’s called "ultra" sonic.

The HC-SR04 has four pins: VCC, GND, TRIG, and ECHO. VCC and GND are where you will apply the 5V DC source. TRIG, short for trigger is where you enable the sensor to send an ultrasonic signal. ECHO is where a pulse can be measured that is proportional to the distance between the sensor and the obstacle.

The TRIG pin requires a 10 µs pulse for it to start emitting 8 cycles of signal. After the ultrasonic signal is sent, the ECHO pin goes from LOW to HIGH and stays HIGH. The ECHO pin only goes LOW when the ultrasonic signal is reflected to the sensor (hence, the word “echo”). Reflection only happens when the signal is obstructed, hence the distance traveled by the signal from the sensor and back is known if the time between the the ECHO pin going HIGH then going LOW is known. If t is that time, then the distance from the sensor to the obstacle is:

distance = speed of sound * t / 2;

The HC-SR04 can measure the distance from an obstruction if it’s within 2 centimeters to 4 meters (unverified, probably less) and 15 degrees of the viewing angle.

Some Tips

If in case your ultrasonic sensor is not working as intended, take note of the following scenarios:

An upgrade of the HC-SR04 is the 5-pin HY-SRF05. When the fifth pin is grounded, you can use the TRIG pin as the ECHO pin. This reduces the number of pins used. The HY-SRF05 also claims to have a longer range than the HC-SR04. I will verify this as soon as I get my hands on one.

Wiring Diagram

The TRIG and ECHO pin may be connected to any GPIO pin of the Raspberry Pi Pico. I choose GPIO15 for the TRIG and GPIO14 for the ECHO. The HC-SR04 needs 5V to turn on so we use the VBUS pin. Note that the VBUS pin gets the 5V DC power from the USB connection of the Pico. We add a voltage divider between the ECHO and GPIO14 since the HC-SR04 sends a 5V signal and the Pico pin is only 3.3V tolerant. An optional (3V) buzzer can be connected to GPIO19. This buzzer’s sound changes with the distance of the obstacle from the sensor.

Code Explanation

Sending Pulse

The HC-SR04 is a common sensor for interfacing with an Arduino.  Using the code that is easily found in the internet didn't work initially. I found out that a voltage divider is needed because the HC-SR04 sends 5V pulses from the echo pin to the 3.3V GPIO pins of the Pico. 

First, we send a 10 µs pulse to the trigger pin. This will make HC-SR04 send out 8 pulses of ultrasonic signal.

  digitalWrite(trig_pin, LOW);
  delayMicroseconds(2);
  digitalWrite(trig_pin, HIGH);
  delayMicroseconds(TRIG_PULSE_DURATION_US);
  digitalWrite(trig_pin, LOW);

Measuring Distance

After sending the pulse, the echo pin will now be in the high state. We note this as the start of the travel of the ultrasonic signal. We use the pulseIn() function to measure the time between HIGH and LOW state of the echo pin

 echo_time = pulseIn(echo_pin, HIGH);

The distance traveled by the signal is then:

distance  = speed * echo_time

Speed here would be the speed of sound and time is the difference between the time the echo pin going high and then the time it went low. Also, we need to convert the speed of sound to centimeters per microsecond since the measured time was in microseconds. Also, since the HC-SR04’s range is from 2 to 4 centimeters only, it makes sense to use centimeters for the distance.

distance = 331.3 * echo_time * 0.0001 (in cm)

This distance is the distance traveled by the signal from the sensor, to the obstacle and back to the sensor. We want to know only the distance between the sensor and the obstacle. So, we divide the total distance in half.

distance = (331.3 * echo_time * 0.0001) / 2 (in cm)

Btw, an optional buzzer can be connected to GPIO19. The buzzer’s sound will change with the distance of the obstacle from the front of the sensor. That part is inside the loop():

 analogWrite(buzz_pin, distance_cm * 10000.00);

Effect of Temperature

The speed of sound is not constant in every environment. Its speed is different in the desert compared to a freezing tundra, for example.

The formula for the speed of sound considering temperature is:

Thus, in the code, I used the internal temperature sensor of the Raspberry Pi Pico to compensate for temperature changes:

  float comp_sound_speed = SOUND_SPEED + 0.606 * analogReadTemp();
  float distance_cm = 0.0001 * ((receiveTime - delayTime) * comp_sound_speed) / 2;

Here’s the link to download the full sketch/code.

Video Results

The post Interfacing HC-SR04 Ultrasonic Sensor with Raspberry Pi Pico appeared first on Microcontroller Tutorials.

Prerequisites

Before diving into the process of automating video uploads to Tiktok (or other video apps, provided they have their own API) using a Raspberry Pi, make sure you have the following:

1. Raspberry Pi (any model with Wi-Fi capabilities)
2. A Raspberry Pi camera module or USB webcam for recording videos
3. A TikTok account
4. Python knowledge

Setting Up the Raspberry Pi

1. Raspberry Pi Setup: Begin by setting up your Raspberry Pi with an operating system (e.g., Raspberry Pi OS). Ensure that it is connected to the internet, either via Wi-Fi or Ethernet.
2. Camera Module/USB Webcam: If you're using a camera module, make sure it's correctly connected to the Raspberry Pi's camera interface. If you're using a USB webcam, plug it into one of the available USB ports.

   If your USB webcam is from Logitech, you can check if it is properly connected using the ff. bash script:

lsusb | grep "Logitech"

  The response to the above command would be:

Bus 001 Device 004: ID 046d:0825 Logitech, Inc. Webcam C270

   If using a Raspberry Pi camera, the command is:

vcgencmd get_camera 

  The response should be:

supported=1 detected=1

3. Python Libraries: You'll need to install Python libraries such as tiktokapi, selenium, and pyautogui. These libraries play crucial roles in automating the TikTok video upload process.

tiktokapi: This library allows you to interact programmatically with TikTok's services, enabling actions such as logging in and uploading videos.

selenium: Selenium is a powerful web automation tool that helps you control web browsers programmatically. It's used to navigate the TikTok website, interact with its elements, and automate the login and video upload processes.

pyautogui: PyAutoGUI is a library for automating keyboard and mouse input. It's useful for simulating user interactions, such as selecting files to upload during the video upload process.

You can install these libraries using the following commands:

pip install tiktokapi
pip install selenium
pip install pyautogui

Recording Videos Using Raspberry Pi Camera

To record videos using the Raspberry Pi camera module and Python, you can use the picamera library. Here's a simple code snippet to get you started:

import picamera
import time

# Initialize the camera
with picamera.PiCamera() as camera:
camera.resolution = (1920, 1080) # Set the resolution
camera.start_recording('my_video.h264') # Start recording
camera.wait_recording(10) # Record for 10 seconds
camera.stop_recording() # Stop recording

Automating TikTok Login with Selenium

Below is an example of how to automate the TikTok login process using Selenium in Python:

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
import time

# Initialize the Chrome web driver (you may need to install the driver separately)
driver = webdriver.Chrome()

# Navigate to TikTok login page
driver.get("https://www.tiktok.com/login")

# Fill in login credentials
username = driver.find_element_by_name("email")
password = driver.find_element_by_name("password")

username.send_keys("your_username")
password.send_keys("your_password")

# Submit the login form
password.send_keys(Keys.RETURN)

# Wait for the login to complete (you may need to adjust the sleep duration)
time.sleep(5)

# Close the browser when done
driver.quit()

Automating Video Uploads to TikTok with Selenium

Here's an example of how to automate video uploads to TikTok using Selenium in Python:

# Continue from the previous code
# ... (login code)

# Navigate to the upload page
driver.get("https://www.tiktok.com/upload")

# Select the video file to upload
video_input = driver.find_element_by_css_selector("input[type='file']")
video_input.send_keys("/path/to/your/video.mp4") # Replace with the actual video file path

# Add captions, hashtags, and other video details (you may need to adjust the selectors)
caption = driver.find_element_by_css_selector(".caption-textarea textarea")
caption.send_keys("Check out my video!")

hashtags = driver.find_element_by_css_selector(".input.hashtag-input input")
hashtags.send_keys("#tiktokautomation #raspberrypi")

# Submit the video for uploading
submit_button = driver.find_element_by_css_selector(".upload-ui-bottombar .upload-btn")
submit_button.click()

# Wait for the upload to complete (you may need to adjust the sleep duration)
time.sleep(10)

# Close the browser when done
driver.quit()

Note on the code above, you may replace the URL to other video app provided it supports API-based uploading of videos.

Scheduling Script Execution with Cron

To schedule your Python script to run every day at midnight, you can use the cron scheduler. Open the cron configuration with the following command:

crontab -e

Then, add the following line to schedule your script:

0 0 * * * /usr/bin/python3 /path/to/your/python/script.py

Replace /path/to/your/python/script.py with the actual path to your Python script. This cron job will run your script every day at midnight.

Conclusion

With a Raspberry Pi, Python scripting, and the essential libraries such as selenium and pyautogui, you can automate the process of recording videos, logging into TikTok, and uploading videos. These libraries play a pivotal role in streamlining the automation process, allowing for consistent and scheduled video uploads.

Automating video uploads with a Raspberry Pi showcases the creative ways you can leverage technology for content creation. It's just one example of the many possibilities this versatile single-board computer offers to enthusiasts and tinkerers. Remember to abide by TikTok's terms of service and guidelines when automating uploads and ensure that your content aligns with their policies.

The post Automating Video Uploads to TikTok Using Raspberry Pi appeared first on Microcontroller Tutorials.