DEV Community: Shilleh

How to Use L298N Motor Driver with Raspberry Pi Pico W

Shilleh — Fri, 01 Nov 2024 02:17:14 +0000

In this tutorial, we’ll explore how to control DC motors using the L298N motor driver and the Raspberry Pi Pico W, with code written in MicroPython. The L298N is a powerful dual H-bridge motor driver that lets you control the direction and speed of two DC motors simultaneously. It’s commonly used in robotics and automation projects because it can handle higher currents and voltages than a microcontroller alone, making it an essential component for projects that involve motors.

In this project, we’ll connect the L298N to the Raspberry Pi Pico W, using GPIO pins to control the motor’s direction and a PWM (Pulse Width Modulation) pin to control the motor’s speed. By the end of this tutorial, you’ll have a functioning motor that can move forward and backward, with speed control based on your input.

What You’ll Need:

Raspberry Pi Pico W

L298N motor driver

DC motor

Power source(e.g., 12V battery pack)

Breadboard (optional)

Alligator Jumper Wires

ShillehTek Jumper Wires

Why Use the L298N Motor Driver?

The L298N motor driver makes it possible to control high-power motors using the low-power outputs of microcontrollers like the Raspberry Pi Pico W. It can independently control the speed and direction of two motors. The driver is particularly useful for handling larger currents and voltages that would otherwise damage a microcontroller’s GPIO pins. The H-bridge design allows you to control the direction of current flow, enabling you to easily reverse motor direction.

Step 1: Connecting the L298N to the Raspberry Pi Pico W

Before we dive into the code, let’s wire up the Pico W and the L298N motor driver:

Power Connections:

Connect your 12V power supply to the 12V IN and GND pins of the L298N driver.
Connect Pico W to separate power supply externally

Motor Control Connections:

IN3 on the L298N to GPIO 14 on the Pico W (for motor direction control).
IN4 on the L298N to GPIO 15 on the Pico W (for motor direction control).
ENB on the L298N to GPIO 13 on the Pico W (for PWM speed control).

Motor Connection:

Connect the DC motor’s leads to the OUT3 and OUT4 terminals on the L298N motor driver.

Step 2: Writing the MicroPython Code

Now that the wiring is complete, let’s write the MicroPython code to control the motor. The following script allows us to move the motor forward and backward while controlling the speed using PWM.

from machine import Pin, PWM
from time import sleep

# Motor pins
in3 = Pin(14, Pin.OUT)  # IN3 connected to GPIO 14
in4 = Pin(15, Pin.OUT)  # IN4 connected to GPIO 15
enb = PWM(Pin(13))      # ENB connected to GPIO 13 for PWM control
enb.freq(1000)          # Set PWM frequency to 1 kHz
# Motor functions
def motor_forward(speed):
    in3.high()          # Set IN3 high
    in4.low()           # Set IN4 low
    enb.duty_u16(speed) # Set motor speed (0-65535 for duty cycle)
def motor_backward(speed):
    in3.low()           # Set IN3 low
    in4.high()          # Set IN4 high
    enb.duty_u16(speed) # Set motor speed (0-65535 for duty cycle)
def motor_stop():
    in3.low()           # Stop motor
    in4.low()           # Stop motor
    enb.duty_u16(0)     # Disable motor (set PWM duty cycle to 0)
# Main loop to test motor
try:
    while True:
        print("Moving forward")
        motor_forward(32768)  # Set speed to 50% (PWM value)
        sleep(2)

        print("Stopping")
        motor_stop()
        sleep(2)

        print("Moving backward")
        motor_backward(32768)  # Set speed to 50% (PWM value)
        sleep(2)

        print("Stopping")
        motor_stop()
        sleep(2)
except KeyboardInterrupt:
    motor_stop()
    print("Program stopped")

Code Breakdown:

IN3 and IN4: These pins control the direction of the motor. If IN3 is high and IN4 is low, the motor moves forward. If IN3 is low and IN4 is high, the motor moves backward.
ENB: This is the enable pin for the motor connected to OUT3 and OUT4. By using PWM (Pulse Width Modulation) on this pin, we can control the motor’s speed.
duty_u16(): This function controls the duty cycle of the PWM signal. A value of 65535 represents 100% speed, while 0 represents no speed.

The motor_forward, motor_backward, and motor_stop functions allow us to easily control the motor’s movement and speed. You can modify the duty_u16 value to control the speed of the motor as needed.

Step 3: Running the Code

Once the wiring and code are ready, you can upload this script to the Raspberry Pi Pico W using a MicroPython editor like Thonny. After running the code, the motor should alternate between moving forward and backward with a 2-second pause in between.

You can modify the motor_forward() and motor_backward() functions to adjust the speed and movement duration as per your project’s requirements.

Conclusion

This tutorial covers the basics of controlling a DC motor with the L298N and Raspberry Pi Pico W. From here, you can expand on this by adding additional motors, sensors, or controls to build more complex robotics projects. You could, for example, add a joystick or buttons to control the motor interactively or integrate line-following sensors to create a basic robot.

Motor control with MicroPython is a fun and practical way to get started with robotics, and the L298N motor driver offers the flexibility to drive motors with precision. I hope this tutorial helped you get your motor up and running. Stay tuned for more projects!

Controlling an LED with a Snap Using the KY-037 Sound Sensor and Raspberry Pi

Shilleh — Sun, 06 Oct 2024 12:30:38 +0000

Welcome back to part 2 of our KY-037 sound sensor tutorial series! In part 1, we successfully set up the KY-037 sound sensor with a Raspberry Pi to detect sound using its digital output. If you haven’t gone through that tutorial yet, I recommend starting there, as this guide builds upon the previous one.

In this tutorial, we’ll go a step further by integrating an LED that turns on and off based on sound detection. With just a snap of your fingers or a clap, the LED will react accordingly. This project is a fun and interactive way to learn how to control physical components with sound, making it perfect for beginner IoT enthusiasts.

— — -

Before we delve into the topic, we invite you to support our ongoing efforts and explore our various platforms dedicated to enhancing your IoT projects:

Subscribe to our YouTube Channel: Stay updated with our latest tutorials and project insights by subscribing to our channel at YouTube — Shilleh.
Support Us: Your support is invaluable. Consider buying me a coffee at Buy Me A Coffee to help us continue creating quality content.
Hire Expert IoT Services: For personalized assistance with your IoT projects, hire me on UpWork.

ShillehTek Website (Exclusive Discounts):

https://shillehtek.com/collections/all

Step 1: Gather Your Components

To get started, you’ll need the following components:

KY-037 Sound Sensor: Available at ShillehTek.
Raspberry Pi (any model with GPIO pins): I’m using a Raspberry Pi 4B.
3 Male-to-Female Jumper Wires: For connecting the sensor to the Raspberry Pi.
1 LED: Any color will work, but I’ll be using a red LED.
1 220-ohm Resistor: To prevent the LED from drawing too much current.
Breadboard (optional): For organizing your connections.
A thin screwdriver: For adjusting the potentiometer on the KY-037 sensor.

Step 2: Wiring the KY-037 Sound Sensor and LED to the Raspberry Pi

Before we dive into the wiring, let’s first understand our setup. The sound sensor will detect a snap or clap and send a digital signal to the Raspberry Pi. The Pi will then process this signal and decide whether to turn the LED on or off.

Here’s how you’ll wire the components:

Wiring the KY-037 Sound Sensor:

VCC (Power) pin of the KY-037 connects to pin 2 (5V) on the Raspberry Pi.
GND (Ground) pin of the KY-037 connects to pin 6 (Ground) on the Raspberry Pi.
D0 (Digital Output) pin of the KY-037 connects to GPIO 4 on the Raspberry Pi (pin 7 in physical pin layout).

Wiring the LED:

Connect the longer leg (positive) of the LED to GPIO 17 on the Raspberry Pi (pin 11 in physical layout).
Connect the shorter leg (negative) of the LED to one end of the 220-ohm resistor.
Connect the other end of the resistor to GND on the Raspberry Pi (pin 9 in physical layout).

Your setup should look something like this:

KY-037 to Raspberry Pi:

VCC -> 5V (Pin 2)
GND -> GND (Pin 6)
D0 -> GPIO 4 (Pin 7)

LED to Raspberry Pi:

Long Leg (Anode) -> GPIO 17 (Pin 11)
Short Leg (Cathode) -> 220-ohm Resistor -> GND (Pin 9)
In summary, the GPIO pin acts as a power source when set to High, allowing the LED to be powered and controlled through software.

Important Note: Make sure to connect the resistor to prevent too much current from flowing through the LED, which could damage it.

As I mentioned in Part 1, you should fine-tune the potentiometer to the point just below the detection threshold, allowing a snap to easily push it past the limit and trigger a response.

Here is how it looks in real life:

Step 3: Writing the Python Code

Now that we have our components connected, let’s write the Python script to control the LED based on sound detection.

Create a new Python file called sound_led_control.py on your Raspberry Pi and add the following code:

import RPi.GPIO as GPIO
import time

# Set up GPIO pin numbering mode and define pins for sensor and LED
GPIO.setmode(GPIO.BCM)
SOUND_SENSOR_PIN = 4  # GPIO pin number connected to D0 pin of KY-037
LED_PIN = 17  # GPIO pin number connected to LED

# Set up the pins
GPIO.setup(SOUND_SENSOR_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)  # Configure sound sensor pin as input
GPIO.setup(LED_PIN, GPIO.OUT)  # Configure LED pin as output

# Initialize LED state
led_state = False

# Function to toggle LED based on sound detection
def toggle_led():
    global led_state
    if led_state:
        GPIO.output(LED_PIN, GPIO.LOW)  # Turn off the LED
        print("LED turned OFF")
    else:
        GPIO.output(LED_PIN, GPIO.HIGH)  # Turn on the LED
        print("LED turned ON")
    led_state = not led_state  # Toggle the state

# Main loop to check for sound detection and toggle LED
try:
    print("Starting sound sensor program. Snap or clap to toggle the LED.")
    while True:
        if GPIO.input(SOUND_SENSOR_PIN) == 1:  # Sound detected
            toggle_led()
            time.sleep(1)  # Wait for a second to avoid multiple toggles on one sound
except KeyboardInterrupt:
    print("Program interrupted. Cleaning up GPIO settings.")
finally:
    GPIO.cleanup()  # Clean up all GPIO settings

Explanation of the Code:

Setup: We configure the sound sensor pin as an input and the LED pin as an output.
Global LED State: We keep track of whether the LED is on or off using the led_state variable.
toggle_led() Function: This function toggles the LED based on its current state.
Main Loop: The loop continuously checks for sound detection. If a sound is detected, it calls toggle_led() and then waits for 1 second to avoid rapid toggling.

Step 4: Running the Code

Once you’ve copied the code into sound_led_control.py, it’s time to run it! Open a terminal on your Raspberry Pi and navigate to the directory where the file is located. Then, run:

python3 sound_led_control.py

You should see a message in the terminal saying, “Starting sound sensor program. Snap or clap to toggle the LED.”

Testing: Try snapping your fingers or clapping near the sensor. The LED should turn on or off with each snap or clap, depending on its current state. If the LED isn’t responding as expected, adjust the potentiometer on the KY-037 to fine-tune its sensitivity.

Step 5: Conclusion and What’s Next?

Congratulations! You’ve successfully created a sound-activated LED control system using the KY-037 sound sensor and Raspberry Pi. In this tutorial, we learned:

How to wire the KY-037 sound sensor and an LED to the Raspberry Pi.
How to write a Python script to toggle the LED based on sound detection.

This project can serve as the foundation for more advanced sound-activated systems, such as creating a sound-responsive smart home lighting system or building an interactive sound-based game.

In the next tutorial, we’ll explore connecting multiple sound sensors to create more complex systems or use the analog output of the KY-037 for measuring sound intensity. Until then, keep experimenting and learning!

Support and Resources:

Don’t forget to check out my YouTube Channel for more tutorials.
Consider supporting me on Buy Me a Coffee to help fund future content creation.
For custom projects or professional consulting, feel free to hire me on Upwork.

Happy coding, and see you in the next tutorial!

Getting Started with KY-037 Sound Sensor & Raspberry Pi

Shilleh — Thu, 03 Oct 2024 21:24:18 +0000

In this tutorial, I’ll guide you through setting up the KY-037 sound sensor with a Raspberry Pi using Python. This tutorial focuses on wiring and coding to measure the digital output signal of the sensor. The KY-037 is a highly versatile sensor that can detect sound levels and is often used in projects requiring sound-activated switches, noise monitoring systems, or smart home automation.

If you’re not familiar with the KY-037, it has two types of outputs: a digital output and an analog output. The digital output is a simple on/off signal (0 for no sound detected, 1 for sound detected), making it ideal for applications that need to trigger actions when a specific sound threshold is reached — such as clapping to turn on a light. The analog output, on the other hand, provides a range of values representing sound intensity, making it useful for scenarios that require more precise sound measurements. We’ll cover the analog output in a future tutorial, as it’s less commonly used for basic sound detection applications.

Overall, this sensor is incredibly useful because it’s cost-effective, easy to set up, and versatile enough for a variety of sound-based detection projects. Whether you’re building a sound-activated alarm system or experimenting with noise sensitivity in different environments, the KY-037 is a great sensor to start with.

— — -

Before we delve into the topic, we invite you to support our ongoing efforts and explore our various platforms dedicated to enhancing your IoT projects:

Subscribe to our YouTube Channel: Stay updated with our latest tutorials and project insights by subscribing to our channel at YouTube — Shilleh.
Support Us: Your support is invaluable. Consider buying me a coffee at Buy Me A Coffee to help us continue creating quality content.
Hire Expert IoT Services: For personalized assistance with your IoT projects, hire me on UpWork.

ShillehTek Website (Exclusive Discounts):

https://shillehtek.com/collections/all

Step 1: Wiring the KY-037 Sound Sensor to the Raspberry Pi

Components Needed:

ShillehTek KY-037 Sound Sensor
Raspberry Pi (any model with GPIO pins). I used a 4B model.
3 Jumper Wires (Male-to-Female)
A thin screwdriver or blade (for adjusting the potentiometer)

Wiring Diagram:

Connect the VCC pin of the KY-037 to pin 4 (5V) on the Raspberry Pi.
Connect the GND pin of the KY-037 to pin 6 (Ground) on the Raspberry Pi.
Connect the D0 (Digital Output) pin of the KY-037 to GPIO 4 on the Raspberry Pi (pin 7 if you’re using a physical pin layout).

Your setup should look like this:

KY-037       Raspberry Pi
-----------------------------
VCC  ---->   5V (Pin 2)
GND  ---->   GND (Pin 4)
D0   ---->   GPIO 4 (Pin 7)

**Important Note:
**Before we run the code, make sure you have a small blade or screwdriver handy. The KY-037 sound sensor has a potentiometer (a small screw-like component) that you’ll need to adjust while the code is running to get the sensitivity just right. Once the code is running we should reduce or increase sensitivity depending on the output we get in the logs.

Step 2: Understanding the Python Code and Running It

Now that we have the hardware set up, let’s go through the Python script used to read the KY-037’s digital output. This script will help us detect sound and print whether sound has been detected in real time.

You can simply copy this code onto the Raspberry Pi in any Python file and run it.

import RPi.GPIO as GPIO
import time

# Set up GPIO pin numbering mode and the sound sensor pin
GPIO.setmode(GPIO.BCM)
SOUND_SENSOR_PIN = 4  # GPIO pin number (adjust as needed)
GPIO.setup(SOUND_SENSOR_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

# Function to check and print sound detection status
def detect_sound():
    sound_detected = GPIO.input(SOUND_SENSOR_PIN)  # Read the digital signal

    # The KY-037 module has a potentiometer (small screw-like component) that adjusts the sensitivity.
    # Tuning this potentiometer is crucial to get accurate readings. Turning it clockwise increases sensitivity,
    # which means the sensor will detect lower sound levels and produce more "1" (sound detected) outputs.
    # Turning it counter-clockwise decreases sensitivity, making it less likely to detect sound (producing more "0" outputs).
    # If the sensor is only showing "1" (sound detected) values, rotate the potentiometer counter-clockwise
    # (you may need to rotate it up to 100 times) until you start seeing "0" values. This adjustment sets the sensitivity threshold
    # so that it can correctly detect and respond to sound changes.

    if sound_detected == 1:
        print("Sound detected!")  # Sound detected
    else:
        print("No sound detected.")  # No sound detected

# Main program loop
try:
    print("Tuning your KY-037 sound sensor: Adjust the potentiometer to get accurate 0/1 readings.")
    print("If you see only 'Sound detected!' messages, reduce sensitivity by rotating the screw counter-clockwise.")
    while True:
        detect_sound()  # Check sound sensor status
except KeyboardInterrupt:
    print("Program interrupted. Cleaning up GPIO settings.")
    GPIO.cleanup()  # Clean up all GPIO settings

Note: By default, the RPi.GPIO library should already be pre-installed on the Raspberry Pi OS. However, if it’s not available, you can install it using the following command:

sudo apt-get install python3-rpi.gpio

Tuning the Sensor While the Code is Running! Important

With the code running, this is where you’ll start adjusting the potentiometer. Use a thin blade or screwdriver to rotate the potentiometer slowly. If the output constantly shows Sound detected!, reduce the sensitivity by rotating the screw counter-clockwise. You should aim to see the output fluctuate between Sound detected! and No sound detected. when there is a change in the sound environment.

When I first got my sensor I saw this in the logs. Meaning it was sensitive.

After rotations counter clockwise (many of them). I finally saw these values.

You can adjust it to the point where it is right in between, so when you talk or make any noise, it will briefly show “Sound Detected” and then switch back to “No Sound Detected.” This is the sweet spot we need for our next tutorial, where we can snap and trigger an LED to turn on or off.
Play around with it as you like — the world is yours.

Please note that it could take dozens of rotations to finally see the value change! Yes, I know it can be frustrating, but be patient with these KY-037s, as their factory default is usually set to the highest sensitivity. I had to turn mine about 100 times counterclockwise before I saw it finally change from “Sound Detected” to “No Sound Detected.”

Step 3: Conclusion and What’s Next?

In this tutorial, we successfully connected and tuned the ShillehTek KY-037 sound sensor with the Raspberry Pi.

We covered:

Wiring the sensor to the Raspberry Pi
Running a Python script to read the digital output
Tuning the potentiometer for accurate sound detection

In the next tutorial, we’ll take it a step further and use the KY-037 to control an LED, turning it on and off with a snap of your fingers! Don’t forget to subscribe to my YouTube channel for more cool tutorials, and feel free to reach out if you have any questions or need help with your project.
If you’re interested in purchasing this sensor, you can get it directly from the ShillehTek Amazon store. Also, if you need custom projects or help with similar electronics, you can hire me on Upwork!

Good luck, my friends.

How to Post to Reddit Using Python

Shilleh — Wed, 25 Sep 2024 15:11:13 +0000

In this tutorial, we’ll walk through how to automate posting to Reddit using Python. This guide is designed for beginners looking to interact with Reddit’s API programmatically, whether for personal use, bot creation, or automating your social media workflows. By the end, you’ll be able to post to a subreddit with a script that handles authentication.

1. Create a Reddit App

To interact with Reddit’s API, you’ll need to register an app. Here’s how to do it:

Go to the Reddit Developer Console: Head to reddit.com/prefs/apps.
Click ‘Create App’: At the bottom of the page, find the “Create App” button.
Fill in the App Details:

Name: Choose a descriptive name.
App Type: Select ‘script’ since we’ll be using this for a single user.
Description: Optional, but you can leave this blank.
Redirect URI: Set this to http://localhost:8080 or any placeholder URI. We do not need this now, but in a later tutorial we will use this to enable a more secure form of authentication for our app called OAuth, which requires a redirect URL.
Personal Use Script (Client ID) and Secret: After creating the app, you’ll get these keys. Keep them safe!

Here is an example of what I filled in down below.

2. Install the Required Libraries

In your Python environment, install the praw library, which is used for interacting with Reddit's API. You should have pip on your computer if you have been working with Python.

pip install praw

3. Write the Python Script

Now let’s create the Python script that will authenticate and post content to Reddit.

import praw
# Reddit API credentials
reddit = praw.Reddit(
    client_id='your_client_id',
    client_secret='your_client_secret',
    user_agent='your_app_name',
    username='your_reddit_username',
    password='your_reddit_password'
)
# Subreddit to post to
subreddit_name = "test"  # Change to your desired subreddit
# Title and content of the post
title = "My first automated post using Python!"
selftext = "Hello Reddit! This post was made using a Python script."
# Submit the post
subreddit = reddit.subreddit(subreddit_name)
subreddit.submit(title=title, selftext=selftext)
print(f"Posted to Reddit: {title}")

4. Explanation of the Script

praw: This is the Python library that simplifies Reddit API interactions.
Reddit API credentials: Replace the placeholders with your app’s credentials (Client ID, Client Secret, etc.).

Here is an example of an app with all of the credentials. You can see the client id is under “personal use script”., quite long and random.

You can place the username and password of your reddit account in there as well. FYI this method I am showing you will not work with two-factor, if you are interested leave a comment and we can work on a more advanced methodology. For now you will have to disable two factor auth on your account to get this to work.

Finally you should place the secret in the secret section and for the user agent just put the name of the app! In my case that would be test-shilleh

Subreddit: Define the subreddit you want to post to. You can use a test subreddit like r/test for practice.
Submit the post: The submit() method handles posting to the subreddit with a title and a body (selftext). For link posts, you can pass a url instead of selftext.

5. Run the Script

Once you’ve set up everything, simply run your Python script:

python post_to_reddit.py

If everything is set up correctly, you should see your post in the subreddit you specified!

Conclusion

Automating your Reddit posts can streamline your workflow and save you time. In this tutorial, we walked through how to create a Reddit app, use praw to authenticate, and post to a subreddit with a simple script. Feel free to extend this by adding more advanced features like fetching data from an API or scheduling your posts.

If you found this tutorial helpful, consider subscribing for more Python and automation content!

How to Measure Heart Rate and Blood Oxygen Levels with MAX30102 Sensor on a Raspberry Pi Using Python

Shilleh — Sat, 24 Aug 2024 23:58:22 +0000

The MAX30102 is a compact, powerful sensor that allows you to measure heart rate and blood oxygen levels (SpO2) with high precision. This tutorial will guide you through connecting the MAX30102 sensor to a Raspberry Pi, setting up the necessary software, and writing Python code to obtain accurate heart rate and SpO2 readings. This is Part 1 of a series. In the next post, we’ll set up a Flask app to display the data in real time!

What You Will Need

Raspberry Pi (any model with I2C support)
MAX30102 Heart Rate and SpO2 sensor
Jumper wires
Breadboard (optional, for easier connections)
Internet connection for downloading software and libraries

— — -

Before we delve into the topic, we invite you to support our ongoing efforts and explore our various platforms dedicated to enhancing your IoT projects:

Subscribe to our YouTube Channel: Stay updated with our latest tutorials and project insights by subscribing to our channel at YouTube — Shilleh.
Support Us: Your support is invaluable. Consider buying me a coffee at Buy Me A Coffee to help us continue creating quality content.
Hire Expert IoT Services: For personalized assistance with your IoT projects, hire me on UpWork.

ShillehTek Website (Exclusive Discounts):

https://shillehtek.com/collections/all

ShillehTekAmazon Store:

ShillehTek Amazon Store — US

ShillehTek Amazon Store — Canada

ShillehTek Amazon Store — Japan

Step 1: Wiring the MAX30102 Sensor

Wiring Connections for MAX30102 Sensor:

VCC: Connect to 3.3V (Pin 1) on the Raspberry Pi — Power
GND: Connect to GND (Pin 6) on the Raspberry Pi — Ground
SDA: Connect to SDA (GPIO 2, Pin 3) on the Raspberry Pi — I2C Data
SCL: Connect to SCL (GPIO 3, Pin 5) on the Raspberry Pi — I2C Clock Optionally you can use a breadboard as well or connect directly to the sensor.

If using a breadboard, the connection would look like above. Where the sensor is inserted into the breadboard, along with jumper wires.

Step 2: Enable I2C on Raspberry Pi

Before diving into the code, ensure that the I2C interface is enabled on your Raspberry Pi:

Open the terminal and run the Raspberry Pi configuration tool:



sudo raspi-config

Navigate to Interface Options > I2C and select Yes to enable the I2C interface.

Reboot the Raspberry Pi to apply the changes.

Step 3: Download and Set Up the MAX30102 Library

Download the MAX30102 library and its dependencies. You can find the library here: MAX30102 GitHub Repository.

Clone the repository to your Raspberry Pi’s Desktop, you can go to the link and download and unzip the repo

Or you can clone the code on your computer using git



cd ~/Desktop
git clone https://github.com/doug-burrell/max30102.git

Navigate to the directory where you downloaded the repository, you can use the cd command in the terminal



cd max30102

Unzip all the files and ensure they are in the same directory as your Python script to avoid any import errors.

Step 4: Install Required Python Packages

You need to install a few Python packages to interface with the MAX30102 sensor and handle I2C communication:



sudo apt-get update
sudo apt-get install -y python3-pip python3-smbus i2c-tools

Step 5: Python Code to Read Heart Rate and SpO2

With the wiring complete and software installed, it’s time to write the Python script to read data from the sensor:



import max30102
import hrcalc
import time

# Initialize the MAX30102 sensor
m = max30102.MAX30102()

def read_sensor():
        while True:
            # Read data from the sensor
            red, ir = m.read_sequential()
            # Calculate heart rate and SpO2
            hr, hr_valid, spo2, spo2_valid = hrcalc.calc_hr_and_spo2(ir, red)

            # Check if valid readings are obtained
            if hr_valid and spo2_valid:
                print("Heart Rate: ", hr, "BPM")
                print("SpO2 Level: ", spo2, "%")
            else:
                print("Invalid readings. Please try again.")

            # Wait for a short time before reading again
            time.sleep(1)

if __name__ == "__main__":
    read_sensor()

How the Code Works:

Import Libraries: We import the max30102 library to interact with the sensor, hrcalc to perform heart rate and SpO2 calculations, and time for delays.
Initialize the Sensor: The MAX30102() class initializes the sensor to begin readings.
Read and Calculate: The read_sequential() function reads the raw red and IR light data. These values are then used to calculate the heart rate (hr) and SpO2 levels using hrcalc.calc_hr_and_spo2().
Display Results: The script checks if the readings are valid and prints the heart rate and SpO2 level if they are. If not, it prompts the user to try again.
Loop: The script runs in an infinite loop, continuously reading and displaying data until interrupted.

Remember to place your index finger gently on the sensor for the most accurate readings. Now you’re all set to work with your MAX30102 sensor in a controlled and efficient environment!

Here is an example output you will see once you start placing your finger on the sensor, otherwise it will show invalid. Good luck!

Conclusion
You now have a working setup to measure heart rate and blood oxygen levels using a MAX30102 sensor and Raspberry Pi. This setup provides a solid foundation for further projects, such as creating a web interface to visualize data in real time. Stay tuned for Part 2, where we’ll build a Flask app to display these readings dynamically on a web page!

Feel free to share your thoughts, questions, or improvements in the comments below.

Getting Started with STM32 Blue Pill in Arduino IDE Using a USB to TTL Converter — Write Your First Program

Shilleh — Sat, 17 Aug 2024 01:24:16 +0000

This comprehensive tutorial will guide you through the process of setting up and programming the STM32 Blue Pill using the Arduino IDE and a DSD TECH SH-U09C5 USB to TTL converter. The STM32 Blue Pill is a powerful yet affordable microcontroller board based on the STM32F103C8T6 ARM Cortex-M3 processor. Known for its robustness and versatility, the Blue Pill is an excellent choice for hobbyists, makers, and professionals alike who are looking to harness the power of 32-bit ARM architecture in their projects.

Why the STM32 Blue Pill?

The STM32 Blue Pill offers an impressive set of features at a fraction of the cost of similar microcontrollers. With a 72 MHz clock speed, 20 KB of RAM, and 64 KB of flash memory, it outperforms many 8-bit microcontrollers, making it suitable for more demanding applications such as real-time data processing, motor control, and advanced sensor integration. Its wide range of peripherals, including SPI, I2C, USART, and ADC, allows for seamless interfacing with various components, sensors, and modules.

Additionally, the STM32 Blue Pill is well-supported by the open-source community, with a variety of development environments available, including the Arduino IDE. This makes it accessible even to those who are familiar with Arduino but want to step up to more advanced hardware.

Why Use a USB to TTL Converter?

Unlike many Arduino boards, the STM32 Blue Pill does not come with a built-in USB-to-serial converter, which is typically used for uploading code and debugging. Instead, the board is equipped with UART (Universal Asynchronous Receiver-Transmitter) pins that require an external converter to communicate with your computer. The DSD TECH SH-U09C5 USB to TTL converter acts as a bridge between your computer’s USB port and the UART pins on the Blue Pill, allowing you to upload code, monitor serial output, and debug your programs. This converter is an essential tool in working with the STM32 Blue Pill, enabling seamless communication between the board and your development environment.

Get Started with a Pre-Soldered Board

For those looking to dive straight into development without the hassle of soldering, you can purchase pre-soldered STM32 Blue Pill boards at Shillehtek. These boards come ready to use, so you can focus on building your projects right away.

— — -

Before we delve into the topic, we invite you to support our ongoing efforts and explore our various platforms dedicated to enhancing your IoT projects:

Subscribe to our YouTube Channel: Stay updated with our latest tutorials and project insights by subscribing to our channel at YouTube — Shilleh.
Support Us: Your support is invaluable. Consider buying me a coffee at Buy Me A Coffee to help us continue creating quality content.
Hire Expert IoT Services: For personalized assistance with your IoT projects, hire me on UpWork.

ShillehTek Website (Exclusive Discounts):

https://shillehtek.com/collections/all

ShillehTekAmazon Store:

ShillehTek Amazon Store — US

ShillehTek Amazon Store — Canada

ShillehTek Amazon Store — Japan

Step 1: Connect the STM32 Blue Pill to the USB to TTL Converter

To start, you’ll need to connect your STM32 Blue Pill to your computer using the DSD TECH SH-U09C5 USB to TTL converter. This converter will allow your computer to communicate with the STM32 Blue Pill via its UART interface.

Wiring Setup:

RXD (SH-U09C5) -> PA9 (RX on Blue Pill)
TXD (SH-U09C5) -> PA10 (TX on Blue Pill)
GND (SH-U09C5) -> GND (Blue Pill)
VCC (SH-U09C5) -> 3.3V (Blue Pill)

Set the BOOT0 Jumper:
Set the BOOT0 jumper on the Blue Pill to the 1 position (this puts the Blue Pill into UART bootloader mode). See diagram below for bootloader mode.

Make sure to plug the TTL converter into power, you can simply plug it into your computer if it has a USB port!

Step 2: Install STM32 Support in Arduino IDE

Before you can program the STM32 Blue Pill in the Arduino IDE, you need to install support for STM32 boards.

Step 1: Open Arduino IDE Preferences

Open the Arduino IDE.
Go to File > Preferences.

Step 2: Add STM32 Board Manager URL
In the “Additional Boards Manager URLs” field, add the following URL:

https://github.com/stm32duino/BoardManagerFiles/raw/main/package_stmicroelectronics_index.json

Click OK.

Step 3: Install STM32 Boards

Go to Tools > Board > Boards Manager.
Search for STM32 and click Install next to the “STM32 MCU based boards” package.

Step 3: Select the STM32 Blue Pill Board in Arduino IDE

After installing STM32 support, you’ll need to configure the Arduino IDE to use the correct settings for your STM32 Blue Pill.

Step 1: Select the Board

Go to Tools > Board > STM32 Boards and select Generic STM32F1 series.

Step 2: Configure Board Settings

Under Tools > Board Part Number, select BluePill F103C8 (or BluePill F103CB if you have the 128KB flash version).
Set the Upload Method to STM32CubeProgrammer (Serial).
Set the Port to the port associated with the device.

Step 4: Install STM32CubeProgrammer

STM32CubeProgrammer is required for uploading code to the STM32 Blue Pill via the serial interface.

Step 1: Download and Install STM32CubeProgrammer

Download STM32CubeProgrammer from STMicroelectronics.
Make sure you create a free account if you have not.
Install it on your system following the on-screen instructions. It has downloads for different operating systems.

Step 2: Set the Environment Variable

Open a terminal and add the STM32CubeProgrammer path to the STM32_PRG_PATH environment variable.

For macOS, add the following line to your ~/.zshrc or ~/.bash_profile file:

export STM32_PRG_PATH=/Applications/STMicroelectronics/STM32Cube/STM32CubeProgrammer/STM32CubeProgrammer.app/Contents/MacOs/bin

Apply the changes by running:

source ~/.zshrc

source ~/.bash_profile

For Windows:

Open the Start Menu and search for “Environment Variables.”
Select “Edit the system environment variables” from the search results.
In the System Properties window, click on the “Environment Variables” button.
Under “System variables” (or “User variables” if you prefer), click on “New.”

Variable Name: STM32_PRG_PATH
Variable Value: The path to the STM32CubeProgrammer bin directory, such as:
C:\Program Files\STMicroelectronics\STM32Cube\STM32CubeProgrammer\bin

Click “OK” to save the new environment variable.

Close the Environment Variables and System Properties windows.

Step 5: Upload Your First Program

Now that everything is set up, you’re ready to upload your first program to the STM32 Blue Pill.

Step 1: Write the Code

Open a new sketch in Arduino IDE and write a simple program. Here’s an example that prints a message to the Serial Monitor:

void setup() {
  // Start the Serial communication at 9600 baud
  Serial.begin(9600);

  // Wait for the serial port to connect (necessary for some boards)
  while (!Serial) {
    ; // Wait
  }
}

void loop() {
  // Print a message to the Serial Monitor
  Serial.println("Hello, Blue Pill!");

  // Wait for 1 second
  delay(1000);
}

Step 2: Reset the Blue Pill

Before clicking the upload button in Arduino IDE, press the Reset button on the Blue Pill board. This ensures that the board is ready to receive the program.

Step 3: Upload the Code

Click the Upload button in Arduino IDE.
After the upload completes you will see the onboard LED blink on intervals. If you want to upload another script you can hit the reset button and modify the script and upload again!

Troubleshooting

If you encounter issues with uploading:
Ensure the correct port is selected.
Check your wiring and jumper settings.
Verify that the STM32_PRG_PATH environment variable is correctly set.
Ensure your board is authentic, like the board from STM32 ShillehTek Amazon Store. The board comes pre-soldered as well.

Conclusion

Congratulations! You’ve successfully set up and programmed your STM32 Blue Pill using the Arduino IDE and the DSD TECH SH-U09C5 USB to TTL converter. This powerful microcontroller opens up a world of possibilities for your projects, offering the performance of a 32-bit ARM Cortex-M3 processor at an affordable price. Whether you’re a beginner or an experienced developer, the STM32 Blue Pill is a versatile tool that can help you bring your ideas to life.

If you found this tutorial helpful, be sure to check out more content on my YouTube channel, where I regularly share tips, tutorials, and project ideas to help you get the most out of your development boards and microcontrollers. Don’t forget to subscribe at MM Shilleh on YouTube to stay updated with the latest videos. Good luck with your projects!

Automate Task Scheduling in AWS with Lambda, Step Functions, and CloudWatch

Shilleh — Fri, 09 Aug 2024 13:51:14 +0000

In this tutorial, I’ll show you how to automatically schedule tasks in AWS at regular intervals using AWS Step Functions and CloudWatch with AWS Lambda. Learn how to chain your Lambda functions and schedule them to run whenever you need, essential for production-level applications requiring task automation, especially for ETLs.

I’ll guide you through all the necessary AWS services, ensuring a seamless setup. This tutorial is perfect for both beginners and advanced programmers looking to automate their code tasks in AWS. While we’ll be using Python for the Lambdas, the concepts apply to any code or series of code you want to automate.

The tools I demonstrate are just the tip of the iceberg. With AWS, you can define any behaviors or patterns you want to see, offering endless possibilities for automation and task scheduling.

Don’t miss out on mastering this crucial skill for efficient cloud automation!

— — -

Before we delve into the topic, we invite you to support our ongoing efforts and explore our various platforms dedicated to enhancing your IoT projects:

Subscribe to our YouTube Channel: Stay updated with our latest tutorials and project insights by subscribing to our channel at YouTube — Shilleh.
Support Us: Your support is invaluable. Consider buying me a coffee at Buy Me A Coffee to help us continue creating quality content.
Hire Expert IoT Services: For personalized assistance with your IoT projects, hire me on UpWork.

ShillehTek Website (Exclusive Discounts):

https://shillehtek.com/collections/all

ShillehTekAmazon Store:

ShillehTek Amazon Store — US

ShillehTek Amazon Store — Canada

ShillehTek Amazon Store — Japan

Step 1-) Setup Your Lambda Functions

In this tutorial, we’ll demonstrate how to work with a straightforward set of Python Lambda functions in AWS. While you can combine various Lambda functions to create more complex workflows, we’ll keep today’s example simple to help you get started.

If you’re new to AWS Lambda, it’s a serverless computing service that allows you to run code without provisioning or managing servers. We’ll be creating two Lambda functions using Python 3.12 in AWS to illustrate the process. Here are the two Lambdas after creation:

Step 2-) Setup Your Step Function

In this step, we’ll create a Step Function that orchestrates the execution of the two Lambda functions we just created. The images above show the two Lambda functions, test-yt-1 and test-yt-2, along with the structure of the Step Function.

Here’s how it works:

Lambda Functions:

test-yt-1: This Lambda function returns a simple JSON response with a status code of 200 and a message "Hello from Lambda!".
test-yt-2: Similarly, this function returns a JSON response with a status code of 200 and a message "Hello from Lambda Again!".

Step Function Workflow:

The Step Function starts by executing the first task, which corresponds to test-yt-1.

If test-yt-1 returns a status code of 200, the workflow proceeds to the next step.
A Choice state evaluates the output of test-yt-1. If the status code is 200, the workflow continues to test-yt-2.

After successfully executing test-yt-2, the workflow ends.

This example demonstrates a very simple flow, but AWS Step Functions offer much more flexibility. You can design all sorts of workflows with complex logic, branching, and error handling. Whether you want to run a series of tasks in sequence or parallel, or just a single task, Step Functions provide a powerful yet user-friendly interface to manage these processes.

The visual editor in AWS makes it easy to create and manage these workflows with a nice graphical interface, allowing you to focus on your business logic without worrying about the underlying infrastructure.

Step 3-) CloudWatch Scheduler

AWS CloudWatch Scheduler is a powerful tool that allows you to automatically trigger your workflows, Lambda functions, or other AWS services at specific intervals. It is essential for automating tasks that need to run at regular times, like daily reports, routine maintenance, or even triggering workflows based on specific patterns.

Why It’s Important

By scheduling tasks, you can ensure that critical operations happen without manual intervention, reducing the risk of missed tasks and improving efficiency. Whether it’s running periodic data processing jobs or sending reminders, CloudWatch Scheduler enables you to focus on other tasks while ensuring that your processes run on time.

Setting Up a Cron-Based Schedule

In our example, we’ll use a cron-based schedule to trigger the Step Function. A cron expression is a string that defines the timing of the task. In the image above, we’ve set up a cron expression that triggers the function every 2 minutes.

Understanding Cron Expressions

A cron expression consists of five fields separated by spaces:

Minutes: (0–59)
Hours: (0–23)
Day of the Month: (1–31)
Month: (1–12)
Day of the Week: (0–7) (Sunday is both 0 and 7)

**For instance, in our setup, cron(0/2 * * * ? *), the function is scheduled to run every 2 minutes. This means that once you deploy this schedule, AWS will automatically trigger your workflow at these intervals.

You should select a target next for the step function. Be sure to select start execution and select your state machine. This should be all you need to initiate your processes at an automated interval! Very cool!**

After setting up the cron expression and confirming the schedule, AWS CloudWatch Scheduler will take care of the rest, automatically invoking your Step Function according to the specified schedule. This automation ensures your tasks run consistently, providing peace of mind and freeing you from the need to remember to start tasks manually.

Conclusion

In this tutorial, we’ve walked through the process of automating task scheduling in AWS using Step Functions, CloudWatch Scheduler, and Lambda. By chaining Lambda functions together and scheduling them to run at regular intervals, you’ve learned how to create a powerful automation workflow essential for production-level applications, such as ETL processes and other recurring tasks.

We’ve covered the basics of setting up Lambda functions, designing a Step Function to manage their execution, and using CloudWatch Scheduler to trigger these workflows automatically. While our example was straightforward, the tools and techniques demonstrated here can be applied to far more complex scenarios, enabling you to design sophisticated automation flows with conditional logic, parallel execution, and error handling — all managed through an intuitive, visual interface.

AWS provides a vast array of services that can help you define and automate almost any behavior or pattern you can imagine, making it an indispensable platform for cloud-based automation and task scheduling. By mastering these skills, you’ll be well-equipped to optimize and streamline your workflows, saving both time and effort.

If you found this tutorial helpful, I encourage you to subscribe to our YouTube channel for more in-depth tutorials and insights. Don’t hesitate to ask any questions or share your thoughts in the comments — your feedback is always appreciated! For those who want to support our content creation efforts, consider buying me a coffee or exploring our services for personalized IoT project assistance.

Thank you for following along, and I look forward to seeing you in the next tutorial!

Implementing Google reCAPTCHA in a Simple React and Node.js App

Shilleh — Tue, 23 Jul 2024 13:14:42 +0000

In today’s digital landscape, protecting your applications from bots and spam is crucial. One effective way to add an extra layer of security to your forms is by integrating Google reCAPTCHA.

CAPTCHA (Completely Automated Public Turing test to tell Computers and Humans Apart) is a type of challenge-response test used in computing to determine whether the user is human. It helps prevent automated software from performing actions that can degrade the quality of service.

reCAPTCHA is a more advanced form of CAPTCHA developed by Google, which not only protects websites from spam and abuse but also helps digitize text, annotate images, and build machine learning datasets. It often involves identifying objects in images or simply checking a box that says “I’m not a robot.”

A robot or automated script could, in theory, attempt to click a CAPTCHA checkbox, but modern CAPTCHA systems like reCAPTCHA use various techniques to distinguish human behavior from automated scripts. These techniques include:

Behavior Analysis: reCAPTCHA analyzes user behavior, such as mouse movements, keystrokes, and the time taken to complete tasks, to determine if the user is human.
Challenges: If the behavior analysis is inconclusive, reCAPTCHA may present additional challenges, such as identifying objects in images or solving puzzles, which are designed to be difficult for bots.
Machine Learning: reCAPTCHA uses machine learning algorithms to continually improve its ability to differentiate between humans and bots based on data collected from users.
These methods make it challenging for automated scripts to successfully bypass CAPTCHA systems.

This blog post will walk you through the process of implementing Google reCAPTCHA in a simple React and Node.js application. We’ll cover both the frontend and backend, ensuring that reCAPTCHA verification is seamlessly integrated into your login process.

Link to GH Project:

https://github.com/shillehbean/youtube-p2/tree/main/reCAPTCHA-react

— — -

Before we delve into the topic, we invite you to support our ongoing efforts and explore our various platforms dedicated to enhancing your IoT projects:

Subscribe to our YouTube Channel: Stay updated with our latest tutorials and project insights by subscribing to our channel at YouTube — Shilleh.
Support Us: Your support is invaluable. Consider buying me a coffee at Buy Me A Coffee to help us continue creating quality content.
Hire Expert IoT Services: For personalized assistance with your IoT projects, hire me on UpWork.

ShillehTek Website (Exclusive Discounts):

https://shillehtek.com/collections/all

ShillehTekAmazon Store:

ShillehTek Amazon Store — US

ShillehTek Amazon Store — Canada

ShillehTek Amazon Store — Japan

*Step 1: Set Up Your React and Node.js Environment
*

First, ensure you have Node.js and npm installed on your machine. If not, download and install them from https://nodejs.org/en.

Step 2: Create a New React App

Create a new React application using Create React App:

npx create-react-app recaptcha-demo
cd recaptcha-demo

*Step 3: Install Necessary Packages
*

We’ll use react-google-recaptcha for integrating reCAPTCHA into our React app:

Installing ajv manually with npm install --save-dev ajv@^7 resolves a missing module error by ensuring the correct version is available for your project dependencies.

npm install --save-dev ajv@^7
npm install react-google-recaptcha axios react-toastify

Step 4: Create Your Node.js Backend

Set up your Node.js backend by creating a new directory and initializing a new Node.js project:

cd ..
mkdir backend
cd backend
npm init -y
npm install express axios dotenv cors jsonwebtoken express-async-handler
npm install --save-dev nodemon

Your directory structure should look like this.

*Step 5: Set Up Google reCAPTCHA
*

Go to the Google reCAPTCHA Admin Console at https://www.google.com/recaptcha/admin/create to register your site. You will receive a Site Key and a Secret Key. Save these keys for use in your application.

*Step 6: Set Up Your Environment Variables
*
Create a .env file in your backend directory and add your Google reCAPTCHA keys:

CAPTCHA_SECRET_KEY=your-secret-key
JWT_SECRET=anything

Create a .env file in your React project directory and add your Google reCAPTCHA site key:

REACT_APP_CAPTCHA_SITE_KEY=your-site-key

*Step 7: Create Backend Middleware for reCAPTCHA Verification
*

Create a middleware directory and add recaptchaMiddleware.js for handling reCAPTCHA verification:

// backend/middleware/recaptchaMiddleware.js
const axios = require('axios');
const asyncHandler = require('express-async-handler');
const verifyCaptcha = asyncHandler(async (req, res, next) => {
  const { captcha } = req.body;
  if (!captcha) {
    return res.status(400).json({ message: 'Please complete the CAPTCHA' });
  }
  const secretKey = process.env.CAPTCHA_SECRET_KEY;
  try {
    const response = await axios.post(
      `https://www.google.com/recaptcha/api/siteverify?secret=${secretKey}&response=${captcha}`
    );
    if (response.data.success) {
      next();
    } else {
      return res.status(400).json({ message: 'CAPTCHA verification failed' });
    }
  } catch (error) {
    return res.status(500).json({ message: 'CAPTCHA verification error' });
  }
});
module.exports = { verifyCaptcha };

Step 8: Create Your Express Server

Set up an Express server and use the middleware for reCAPTCHA verification:

// backend/server.js
const express = require('express');
const dotenv = require('dotenv');
const cors = require('cors');
const { verifyCaptcha } = require('./middleware/recaptchaMiddleware');
const jwt = require('jsonwebtoken');

dotenv.config();
const app = express();
app.use(cors());
app.use(express.json());
app.post('/api/login', verifyCaptcha, (req, res) => {
  const { email, password } = req.body;
  if (email === 'test@example.com' && password === 'password') {
    const token = jwt.sign({ id: 1, email }, process.env.JWT_SECRET, { expiresIn: '1h' });
    res.json({ token });
  } else {
    res.status(401).json({ message: 'Invalid credentials' });
  }
});
const PORT = process.env.PORT || 5002;
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

*Step 9: Integrate reCAPTCHA in React
*

In your React app, create a login form that includes the reCAPTCHA component:

// src/Login.js
import React, { useState } from 'react';
import axios from 'axios';
import ReCAPTCHA from 'react-google-recaptcha';
import { ToastContainer, toast } from 'react-toastify';
import 'react-toastify/dist/ReactToastify.css';
import './Login.css'; // Import the CSS file

const Login = () => {
  const [formData, setFormData] = useState({ email: '', password: '', captcha: '' });
  const [isLoggedIn, setIsLoggedIn] = useState(false); // Add state for login status
  const { email, password, captcha } = formData;

  const onChange = (e) => {
    setFormData({ ...formData, [e.target.name]: e.target.value });
  };

  const onCaptchaChange = (value) => {
    setFormData({ ...formData, captcha: value });
  };

  const onSubmit = async (e) => {
    e.preventDefault();
    if (!captcha) {
      toast.error('Please complete the CAPTCHA');
      return;
    }
    try {
      const response = await axios.post('http://localhost:5002/api/login', { email, password, captcha });
      toast.success('Login successful');
      setIsLoggedIn(true); // Set login status to true on success
      console.log(response.data); // Handle the response
    } catch (error) {
      toast.error(error.response.data.message || 'Login failed');
    }
  };

  return (
    <div className="login-container">
      {isLoggedIn ? (
        <div className="success-message">
          <h1>Login Successful</h1>
        </div>
      ) : (
        <form className="login-form" onSubmit={onSubmit}>
          <input
            type="email"
            name="email"
            value={email}
            onChange={onChange}
            placeholder="Email"
            required
          />
          <input
            type="password"
            name="password"
            value={password}
            onChange={onChange}
            placeholder="Password"
            required
          />
          <div className="captcha-container">
            <ReCAPTCHA
              sitekey={process.env.REACT_APP_CAPTCHA_SITE_KEY}
              onChange={onCaptchaChange}
            />
          </div>
          <button type="submit">Login</button>
        </form>
      )}
      <ToastContainer position="top-right" autoClose={5000} />
    </div>
  );
};

export default Login;

/* src/Login.css */
.login-container {
    display: flex;
    justify-content: center;
    align-items: center;
    height: 100vh;
    background-color: #f5f5f5;
  }

  .login-form {
    background: #fff;
    padding: 2rem;
    border-radius: 8px;
    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
    display: flex;
    flex-direction: column;
    width: 300px;
  }

  .login-form input {
    margin-bottom: 1rem;
    padding: 0.75rem;
    border: 1px solid #ccc;
    border-radius: 4px;
  }

  .captcha-container {
    display: flex;
    justify-content: center;
    margin-bottom: 1rem;
  }

  .login-form button {
    padding: 0.75rem;
    background-color: #007bff;
    color: white;
    border: none;
    border-radius: 4px;
    cursor: pointer;
  }

  .login-form button:hover {
    background-color: #0056b3;
  }

  .success-message {
    background: #fff;
    padding: 2rem;
    border-radius: 8px;
    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
    text-align: center;
  }

*Step 10: Modify App.js file
*

import React from 'react';
import Login from './Login';
import './App.css';  // Optionally, create this file for styling

const App = () => {
  return (
    <div className="App">
      <h1>Login</h1>
      <Login />
    </div>
  );
};

export default App;

Run npm start in the recaptcha-demo folder

Run nodemon server.js in the backend folder

You will see the following screen.

If you login with the proper credentials and check the captcha you will see a success message

It really is that simple thanks to Google’s library implementation! Be careful of the cost as scaling over 10,000 uses per month will begin to accrue a cost in your Google Cloud account if you setup a payment method, otherwise the Captcha will fail to work if you do not have payment setup.

We went over Captcha v2 in this example but really you can use v3 and it will work similarly.

Conclusion

Implementing Google reCAPTCHA in your React and Node.js applications is a straightforward process that can significantly enhance your application’s security. By following the steps outlined in this guide, you can ensure that your forms are protected against automated abuse and spam. Remember to test your implementation thoroughly in both development and production environments to ensure it works as expected.

Easily Use Selenium with AWS Lambda

Shilleh — Sun, 14 Jul 2024 08:52:25 +0000

In this tutorial, I will guide you through the process of running Selenium with ChromeDriver inside an AWS Lambda function. This setup is useful for automating web scraping tasks, testing web applications, or performing any browser automation tasks on the cloud. By containerizing our application and deploying it to AWS Lambda, we ensure a scalable and serverless architecture. Let’s dive into the details.

What We’re Doing

We will create a Docker container that includes all the necessary dependencies for running Selenium and ChromeDriver. This container will be deployed as an AWS Lambda function. The Lambda function will perform a simple task: searching for “OpenAI” on Google and returning the titles of the search results.

Prerequisites

Before we start, make sure you have:

An AWS account
A GitHub account
Docker Desktop installed
AWS CLI configured

Before we delve into the topic, we invite you to support our ongoing efforts and explore our various platforms dedicated to enhancing your IoT projects:

Subscribe to our YouTube Channel: Stay updated with our latest tutorials and project insights by subscribing to our channel at YouTube — Shilleh.
Support Us: Your support is invaluable. Consider buying me a coffee at Buy Me A Coffee to help us continue creating quality content.
Hire Expert IoT Services: For personalized assistance with your IoT projects, hire me on UpWork.
ShillehTek Website (Exclusive Discounts):

https://shillehtek.com/collections/all

ShillehTek Amazon Store:

ShillehTek Amazon Store — US

ShillehTek Amazon Store — Canada

ShillehTek Amazon Store — Japan

The Project Files

1. main.py

This Python script is the Lambda function that uses Selenium to perform browser automation.



import os
import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options as ChromeOptions
from tempfile import mkdtemp

def lambda_handler(event, context):
    chrome_options = ChromeOptions()
    chrome_options.add_argument("--headless=new")
    chrome_options.add_argument("--no-sandbox")
    chrome_options.add_argument("--disable-dev-shm-usage")
    chrome_options.add_argument("--disable-gpu")
    chrome_options.add_argument("--disable-dev-tools")
    chrome_options.add_argument("--no-zygote")
    chrome_options.add_argument("--single-process")
    chrome_options.add_argument(f"--user-data-dir={mkdtemp()}")
    chrome_options.add_argument(f"--data-path={mkdtemp()}")
    chrome_options.add_argument(f"--disk-cache-dir={mkdtemp()}")
    chrome_options.add_argument("--remote-debugging-pipe")
    chrome_options.add_argument("--verbose")
    chrome_options.add_argument("--log-path=/tmp")
    chrome_options.binary_location = "/opt/chrome/chrome-linux64/chrome"

    service = Service(
        executable_path="/opt/chrome-driver/chromedriver-linux64/chromedriver",
        service_log_path="/tmp/chromedriver.log"
    )

    driver = webdriver.Chrome(
        service=service,
        options=chrome_options
    )
    # Open a webpage
    driver.get('https://www.google.com')
    # Find the search box
    search_box = driver.find_element(By.NAME, 'q')
    # Enter a search query
    search_box.send_keys('OpenAI')
    # Submit the search query
    search_box.send_keys(Keys.RETURN)
    # Wait for the results to load
    time.sleep(2)
    # Get the results
    results = driver.find_elements(By.CSS_SELECTOR, 'div.g')
    # Print the titles of the results
    titles = [result.find_element(By.TAG_NAME, 'h3').text for result in results]
    # Close the WebDriver
    driver.quit()
    return {
        'statusCode': 200,
        'body': titles
    }

Explanation:

chrome_options: Configures Chrome to run headlessly and optimizes it for a containerized environment.
driver.get: Navigates to Google.
search_box: Finds the search input, enters “OpenAI”, and submits the form.
results: Extracts and prints the titles of the search results.

2. Dockerfile

This Dockerfile creates an image with all the dependencies required to run Selenium with ChromeDriver.



FROM amazon/aws-lambda-python:3.12
# Install chrome dependencies
RUN dnf install -y atk cups-libs gtk3 libXcomposite alsa-lib \
    libXcursor libXdamage libXext libXi libXrandr libXScrnSaver \
    libXtst pango at-spi2-atk libXt xorg-x11-server-Xvfb \
    xorg-x11-xauth dbus-glib dbus-glib-devel nss mesa-libgbm jq unzip
# Copy and run the chrome installer script
COPY ./chrome-installer.sh ./chrome-installer.sh
RUN chmod +x ./chrome-installer.sh
RUN ./chrome-installer.sh
RUN rm ./chrome-installer.sh
# Install selenium
RUN pip install selenium
# Copy the main application code
COPY main.py ./
# Command to run the Lambda function
CMD [ "main.lambda_handler" ]

Explanation:

FROM amazon/aws-lambda-python:3.12: Uses AWS Lambda base image for Python 3.12.
RUN dnf install -y: Installs the necessary dependencies for running Chrome.
COPY ./chrome-installer.sh: Copies the Chrome installer script into the image.
RUN ./chrome-installer.sh: Executes the script to install Chrome and ChromeDriver.
RUN pip install selenium: Installs the Selenium Python package.
COPY main.py: Copies the main.py script into the image.
CMD [ “main.lambda_handler” ]: Specifies the command to run the Lambda function.

3. chrome-installer.sh

This script installs the latest versions of Chrome and ChromeDriver.



#!/bin/bash
set -e

latest_stable_json="https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions-with-downloads.json"
# Retrieve the JSON data using curl
json_data=$(curl -s "$latest_stable_json")
latest_chrome_linux_download_url="$(echo "$json_data" | jq -r ".channels.Stable.downloads.chrome[0].url")"
latest_chrome_driver_linux_download_url="$(echo "$json_data" | jq -r ".channels.Stable.downloads.chromedriver[0].url")"
download_path_chrome_linux="/opt/chrome-headless-shell-linux.zip"
download_path_chrome_driver_linux="/opt/chrome-driver-linux.zip"
mkdir -p "/opt/chrome"
curl -Lo $download_path_chrome_linux $latest_chrome_linux_download_url
unzip -q $download_path_chrome_linux -d "/opt/chrome"
rm -rf $download_path_chrome_linux
mkdir -p "/opt/chrome-driver"
curl -Lo $download_path_chrome_driver_linux $latest_chrome_driver_linux_download_url
unzip -q $download_path_chrome_driver_linux -d "/opt/chrome-driver"
rm -rf $download_path_chrome_driver_linux

*Explanation:
*

curl -s: Fetches the latest stable versions of Chrome and ChromeDriver.
mkdir -p: Creates directories to store the downloaded files.
unzip -q: Extracts the downloaded files to the specified directories.

Building, Tagging, and Pushing the Docker Image

Build the Docker Image:

docker build -t selenium-chrome-driver .

Tag the Docker Image:

docker tag selenium-chrome-driver .dkr.ecr.us-east-1.amazonaws.com/docker-images:v1.0.0

Push the Docker Image to AWS ECR:

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin .dkr.ecr.us-east-1.amazonaws.com/docker-images
docker push .dkr.ecr.us-east-1.amazonaws.com/docker-images:v1.0.0

Explanation:

docker build: Builds the Docker image from the Dockerfile.
docker tag: Tags the image with a specific version.
docker push: Pushes the image to the specified AWS ECR repository.
Deploying the Lambda Function

After pushing the image to AWS ECR, you can deploy it using AWS Lambda. Ensure you are logged into AWS and have the necessary permissions.

Increase the configuration resources in the container so it does not time out or run out of memory.

After running a test event we see a successful output! It worked :)

Conclusion

In this article, we walked through the process of setting up Selenium with ChromeDriver in an AWS Lambda function using Docker. This approach allows you to leverage the power of Selenium for browser automation in a serverless environment, ensuring scalability and efficiency. By containerizing the application, you can manage dependencies more effectively and deploy seamlessly to AWS Lambda.

Feel free to experiment and expand this setup for your own browser automation needs. Goodluck, and do not forget to subscribe or support!

How to Connect MLX90614 Infrared to Raspberry Pi Pico

Shilleh — Fri, 05 Jul 2024 21:50:53 +0000

Related Products

Here are the components used in this tutorial, available from ShillehTek:

In this blog post, we’ll guide you through connecting the MLX90614 infrared temperature sensor to a Raspberry Pi Pico W using MicroPython. The MLX90614 sensor allows for non-contact temperature measurements, making it ideal for various applications. We’ll provide a step-by-step tutorial, including wiring, code, and testing.

Before we delve into the topic, we invite you to support our ongoing efforts and explore our various platforms dedicated to enhancing your IoT projects:

Subscribe to our YouTube Channel: Stay updated with our latest tutorials and project insights by subscribing to our channel at YouTube — Shilleh.
Support Us: Your support is invaluable. Consider buying me a coffee at Buy Me A Coffee to help us continue creating quality content.
Hire Expert IoT Services: For personalized assistance with your IoT projects, hire me on UpWork.
ShillehTek Website (Exclusive Discounts):

https://shillehtek.com/collections/all

Components Needed

Raspberry Pi Pico W
MLX90614 Infrared Temperature Sensor
Breadboard (optional)
4 Jumper wires

Wiring Diagram
Connect the MLX90614 to the Raspberry Pi Pico W as follows:

MLX90614 VIN to Pico W 3.3V
MLX90614 GND to Pico W GND
MLX90614 SCL to Pico W GP1 (SCL)
MLX90614 SDA to Pico W GP0 (SDA)

Library Code
Save the following library code in mlx90614.py and upload it to your Raspberry Pi Pico W.

"""
MicroPython MLX90614 IR temperature sensor driver
https://github.com/mcauser/micropython-mlx90614MIT License
Copyright (c) 2016 Mike CauserPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""import ustructclass SensorBase:def read16(self, register):
  data = self.i2c.readfrom_mem(self.address, register, 2)
  return ustruct.unpack('<H', data)[0]def read_temp(self, register):
  temp = self.read16(register);
  # apply measurement resolution (0.02 degrees per LSB)
  temp *= .02;
  # Kelvin to Celsius
  temp -= 273.15;
  return temp;def read_ambient_temp(self):
  return self.read_temp(self._REGISTER_TA)def read_object_temp(self):
  return self.read_temp(self._REGISTER_TOBJ1)def read_object2_temp(self):
  if self.dual_zone:
   return self.read_temp(self._REGISTER_TOBJ2)
  else:
   raise RuntimeError("Device only has one thermopile")@property
 def ambient_temp(self):
  return self.read_ambient_temp()@property
 def object_temp(self):
  return self.read_object_temp()@property
 def object2_temp(self):
  return self.read_object2_temp()class MLX90614(SensorBase):_REGISTER_TA = 0x06
 _REGISTER_TOBJ1 = 0x07
 _REGISTER_TOBJ2 = 0x08def __init__(self, i2c, address=0x5a):
  self.i2c = i2c
  self.address = address
  _config1 = i2c.readfrom_mem(address, 0x25, 2)
  _dz = ustruct.unpack('<H', _config1)[0] & (1<<6)
  self.dual_zone = True if _dz else Falseclass MLX90615(SensorBase):_REGISTER_TA = 0x26
 _REGISTER_TOBJ1 = 0x27def __init__(self, i2c, address=0x5b):
  self.i2c = i2c
  self.address = address
  self.dual_zone = False

Save the following main code in a file named main.py and upload it to your Raspberry Pi Pico W.

import time
import machine
from mlx90614 import MLX90614# Initialize I2C bus
i2c = machine.I2C(0, scl=machine.Pin(1), sda=machine.Pin(0), freq=100000)# Scan for I2C devices
devices = i2c.scan()if devices:
    print("I2C devices found:", [hex(device) for device in devices])
else:
    print("No I2C devices found")# Initialize the MLX90614 sensor
sensor = MLX90614(i2c)while True:
    ambient_temp = sensor.ambient_temp
    object_temp = sensor.object_tempprint(f"Ambient Temperature: {ambient_temp:.2f}°C")
    print(f"Object Temperature: {object_temp:.2f}°C")
    time.sleep(1)

Running the Code

Upload both mlx90614.py and main.py to your Raspberry Pi Pico W.
Run the main.py script using Thonny IDE or another suitable MicroPython environment.
Checking the Output
After running the script, you should see the ambient and object temperatures printed in the console every second. Ensure the temperatures are within realistic ranges to confirm the sensor is working correctly. You can point it at your skin closely to see if it changes the temperature reading. Goodluck on your project!

Conclusion

By following this guide, you can easily connect the MLX90614 infrared temperature sensor to your Raspberry Pi Pico W and read temperature data using MicroPython. This setup allows for non-contact temperature measurements, which can be useful in various projects. Do not forget to subscribe or book a consulting slot on buymeacoffee if you have any questions!

How to Write your First C++ Program on the Raspberry Pi Pico

Shilleh — Wed, 26 Jun 2024 00:13:45 +0000

Welcome to this comprehensive tutorial on setting up, building, and flashing a C++ project for the Raspberry Pi Pico W on macOS. The Raspberry Pi Pico W is a powerful microcontroller board based on the RP2040 microcontroller, featuring dual-core ARM Cortex-M0+ processors, flexible I/O options, and built-in Wi-Fi connectivity. This tutorial will guide you through the entire process, from installing the necessary tools to running a “Hello, World!” program that communicates over USB serial.

In this guide, you will learn how to:

Set up the development environment on macOS, including installing Homebrew, CMake, and the ARM GCC toolchain.
Clone and initialize the Pico SDK, which provides essential libraries and tools for developing applications for the Raspberry Pi Pico W.
Create a simple C++ project that prints “Hello, World!” to the serial console.
Build and flash your project to the Pico W.
Connect to the Pico W’s serial output using terminal applications such as screen and minicom.

Whether you’re a seasoned developer or just getting started with microcontrollers, this tutorial will provide you with the knowledge and skills to begin developing applications for the Raspberry Pi Pico W on macOS.

— — -

Before we delve into the topic, we invite you to support our ongoing efforts and explore our various platforms dedicated to enhancing your IoT projects:

Subscribe to our YouTube Channel: Stay updated with our latest tutorials and project insights by subscribing to our channel at YouTube — Shilleh.
Support Us: Your support is invaluable. Consider buying me a coffee at Buy Me A Coffee to help us continue creating quality content.
Hire Expert IoT Services: For personalized assistance with your IoT projects, hire me on UpWork.

ShillehTek Website (Exclusive Discounts):

https://shillehtek.com/collections/all

ShillehTekAmazon Store:

ShillehTek Amazon Store — US

ShillehTek Amazon Store — Canada

ShillehTek Amazon Store — Japan

Step 1: Set Up the Environment

Install Prerequisites:

Homebrew: Install Homebrew if you haven’t already:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

CMake and ARM GCC Toolchain:

brew install cmake gcc-arm-none-eabi

Clone the Pico SDK:

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

Set the Environment Variable:

Set the PICO_SDK_PATH environment variable in your shell configuration file (~/.zshrc for Zsh or ~/.bashrc for Bash):

echo 'export PICO_SDK_PATH=~/pico/pico-sdk' >> ~/.zshrc
source ~/.zshrc

Step 2: Create a C++ Project

Create a Project Directory:

mkdir -p ~/pico/my_project
cd ~/pico/my_project

Create a CMakeLists.txt File:


cmake_minimum_required(VERSION 3.13)

# Include the Pico SDK initialization script
include($ENV{PICO_SDK_PATH}/pico_sdk_init.cmake)

project(my_project)

# Initialize the Pico SDK
pico_sdk_init()

# Add your executable and source files
add_executable(my_project
    main.cpp
)

# Enable USB stdio and disable UART stdio
pico_enable_stdio_usb(my_project 1)
pico_enable_stdio_uart(my_project 0)

# Link the Pico SDK to your project
target_link_libraries(my_project pico_stdlib)

# Create map/bin/hex/uf2 files
pico_add_extra_outputs(my_project)

Create a main.cpp File:

#include "pico/stdlib.h"
#include <cstdio> // Include the C standard IO functions

int main() {
    stdio_init_all(); // Initialize standard IO

    while (true) {
        printf("Hello, World!\n");
        sleep_ms(1000);
    }
}

Step 3: Build and Flash the Project

Navigate to the Build Directory and Clean it:

mkdir -p build
cd build
rm -rf *

Run CMake to Generate Build Files:

cmake ..

Build the Project:

make

Flash the Firmware:

Unplug the Pico W from your Mac.
Hold down the BOOTSEL button.
While holding the BOOTSEL button, plug the Pico W back into your Mac. The Pico should appear as a mass storage device (RPI-RP2).
Copy the generated .uf2 file to the Pico:

cp my_project.uf2 /Volumes/RPI-RP2/

Now that your UF2 file is on the device, your Pico W should start running it and logging to serial output. The next step shows you commands you can utilize to view the output of the program!

Verify Serial Connection

Using screen

Set the TERM Environment Variable:

If you encounter issues with the $TERM too long - sorry. error in screen, set the TERM environment variable to vt100 to ensure compatibility with screen:

export TERM=vt100

Check for Serial Device:

ls /dev/tty.*

Look for a device like

/dev/tty.usbmodemXXXX.

Connect Using screen:

screen /dev/tty.usbmodemXXXX 115200

View the Output:

If the Pico W is running your program correctly, you should see the “Hello, World!” messages being printed to the terminal every second.
Exit screen:
To exit screen, press Ctrl+A followed by K, and then confirm by pressing Y.

Conclusion

Congratulations! You have successfully set up your development environment, created and built a C++ project, and flashed it to your Raspberry Pi Pico W. You also learned how to connect to the Pico W’s serial output using screen and minicom, ensuring you can monitor and interact with your running programs.

With these foundational skills, you’re now ready to explore the full potential of the Raspberry Pi Pico W. Whether you want to build IoT applications, create interactive devices, or experiment with embedded systems, the knowledge gained from this tutorial will serve as a solid starting point.

Continue experimenting and building more complex projects, and don’t hesitate to explore the extensive documentation and resources available for the Raspberry Pi Pico W. Happy coding!

How to Use ThingSpeak with the Raspberry Pi Pico W

Shilleh — Fri, 31 May 2024 23:41:15 +0000

In this tutorial, we'll learn how to use ThingSpeak, a popular IoT platform, with the Raspberry Pi Pico W to collect and visualize sensor data. We'll be using a BME280 sensor to measure temperature, pressure, and humidity and send this data to ThingSpeak for real-time monitoring and analysis.

ThingSpeak is an open-source Internet of Things (IoT) platform that allows you to collect, store, analyze, visualize, and act on data from sensors or devices. It's particularly popular for its ease of use and integration with various hardware platforms like Raspberry Pi, Arduino, and ESP8266/ESP32.

In the end, we will have a dashboard that looks as follows, a simple weather station with gauges and graphs that updates in real-time:

Requirements

Raspberry Pi Pico W
BME280 sensor from ShillehTek
Jumper wires
Breadboard
A computer with Thonny IDE installed
Wi-Fi network credentials
ThingSpeak account

Wiring the BME280 Sensor
If you are interested in using the BME280 specifically, there is another ShillehTek tutorial on YouTube here that quickly walks you through how to get setup.

Before we get into the remainder, consider subscribing or supporting the channel. Also, be sure to checkout our various stores to shop products for Raspberry Pi, Arduino, ESP32, and DIY electronics at ShillehTek!

Subscribe:

Youtube

Support:

https://buymeacoffee.com/mmshilleh

Hire me at UpWork to build your IoT projects:

https://buymeacoffee.com/mmshilleh

Visit ShillehTek Store for Arduino and Raspberry Pi Sensors and Pre-Soldered Components:

ShillehTek Website (Exclusive Discounts):

https://buymeacoffee.com/mmshilleh

Step 1-) Setting Up ThingSpeak

Create a ThingSpeak Account: If you don't have one, sign up for a ThingSpeak account at thingspeak.com
Create a New Channel: Go to the Channels tab and click "New Channel".Name your channel (e.g., "Pico W Weather Station"). Add three fields: Temperature, Pressure, and Humidity. Save the channel and note down the Write API Key. You can get it in the API Keys tab.

Creating Visualizations -

Numeric Display for Temperature:

Go to your channel view and click on the "Add Widget" button.
Select "Numeric Display" from the widget options.
Choose the field corresponding to Temperature.
Save the widget to add it to your channel dashboard.

Graph for Pressure:

Click on the "Add Visualizations" button.
Choose the field corresponding to Pressure.
Configure the time span and any other settings you prefer.
Save the widget to add it to your channel dashboard.

Gauge for Humidity:

Click on the "Add Widget" button.
Select "Gauge" from the widget options.
Choose the field corresponding to Humidity.
Configure the gauge with appropriate min and max values (e.g., 0 to 100%).
Save the widget to add it to your channel dashboard.

Now that you have all of this, you have the basis of what you need to start populating and visualizing the sensor data from the ShillehTek BME280 in ThingSpeak. If you are using another sensor, you can play around with other widgets and visualizations as needed, the interface is fairly straightforward.

Step 2-) MicroPython Code

Here's the full code to read data from the BME280 sensor and send it to ThingSpeak:

from machine import Pin, I2C
import network
import urequests
import time
from time import sleep
import bme280
import constants

i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000) 

ssid = constants.INTERNET_NAME
password = constants.INTERNET_PASSWORD
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(ssid, password)
while not wlan.isconnected():
    pass

api_key = 'your_API_KEY'
base_url = 'https://api.thingspeak.com/update'

def read_sensor():
    bme = bme280.BME280(i2c=i2c)
    temperature, pressure, humidity = [float(i) for i in bme.values]
    return temperature, pressure, humidity

# Send data to ThingSpeak
while True:
    temperature, pressure, humidity = read_sensor()
    url = f"{base_url}?api_key={api_key}&field1={temperature}&field2={pressure}&field3={humidity}"
    response = urequests.get(url)
    print(response.text)
    time.sleep(15)

Code Walkthrough

Import Libraries: We import necessary libraries including network for Wi-Fi connectivity, urequests for HTTP requests, and bme280 for sensor interaction.
Initialize I2C: Set up I2C communication with the BME280 sensor.
Connect to Wi-Fi: Use your Wi-Fi credentials to connect the Pico W to the internet.
Read Sensor Data: Define a function read_sensor to get temperature, pressure, and humidity readings from the BME280 sensor.
Send Data to ThingSpeak: In an infinite loop, read data from the sensor and send it to ThingSpeak every 15 seconds.
If you are using the BME280 library, you need to modify the return values by removing all suffixes (e.g., 'C', 'hPa', '%') so that the data is interpretable by the IoT platform. Additionally, if you are using an earlier version of MicroPython, make sure you install urequests, as it may not come pre-installed with some versions.

You also have the option to hardcode your Wi-Fi credentials directly into the code instead of using a constants file. Simply replace the placeholders with your actual Wi-Fi SSID and password.

Once your script is running, you should see your ThingSpeak dashboard updating in real-time! This setup can be further customized to suit your specific needs. Additionally, ThingSpeak offers various other data integration and visualization options to explore.

Conclusion

Congratulations! You have successfully set up your Raspberry Pi Pico W to send sensor data to ThingSpeak. This setup allows you to monitor environmental conditions in real-time from anywhere. ThingSpeak provides powerful tools for data analysis and visualization, making it an excellent choice for IoT projects. Happy tinkering! Also, do not forget to subscribe if you have not!