We are back in action with the Pi Pico project. Now let’s add a stepper motor to our project and ask ChatGPT to generate some code that will work with our current project (Project Three).

My ChatGPT query:

Now add a dc motor, include the code, the electronic components needed, and how to connect the motor to the current code.

ChatGPT Response:

Integrating a 5V DC stepper motor with five wires into your Raspberry Pi Pico setup involves using a stepper motor driver. These types of motors are typically unipolar stepper motors. Here’s a detailed guide on the electronic components needed, how to connect the stepper motor, and the necessary code changes.

Components Needed

1. 5V DC Stepper Motor: With five wires, typically a unipolar stepper motor.

2. ULN2003 Stepper Motor Driver: Suitable for driving unipolar stepper motors.

3. Power Supply: A 5V power supply for the stepper motor.

4. Jumper Wires: For connections.

5. Breadboard: For prototyping connections.

Circuit Connections

1. Connecting the Stepper Motor to ULN2003 Driver:

   • The ULN2003 driver is designed for easy connection with a unipolar stepper motor.

   • Connect the motor wires to the driver board in the order specified in the motor’s datasheet or according to the colors typically matched on the driver board.

2. Connections from ULN2003 Driver to Raspberry Pi Pico:

   • Motor Driver IN Pins: Connect these to GPIO pins on the Pico.

   • VCC (5V) and GND: Connect to the 5V and ground on the Pico or an external 5V supply with a common ground.

3. Circuit Schematic:

   • Connect the stepper motor wires to the driver.

   • Connect the driver input pins (IN1, IN2, IN3, IN4) to Pico GPIO pins (e.g., GPIO 6, GPIO 7, GPIO 8, GPIO 9).

   • Connect the VCC of the ULN2003 to the Pico's 5V pin.

   • Connect GND of the ULN2003 to the Pico's ground.

Updated Code

Here’s the updated code with stepper motor control added:

import machine
import utime
from i2c_lcd import I2cLcd

# Define the I2C address of the LCD (use the address detected by the I2C scanner)
I2C_ADDR = 0x27  # Replace with your LCD's I2C address
I2C_NUM_ROWS = 2
I2C_NUM_COLS = 16

# Initialize I2C on bus 1 with SDA on Pin 2 and SCL on Pin 3
i2c = machine.I2C(1, scl=machine.Pin(3), sda=machine.Pin(2), freq=100000)

# Initialize the LCD
lcd = I2cLcd(i2c, I2C_ADDR, I2C_NUM_ROWS, I2C_NUM_COLS)

# Define GP0 as an output pin for the LED
led_pin = machine.Pin(0, machine.Pin.OUT)

# Define GP1 as an input pin with a pull-up resistor for the button
button_pin = machine.Pin(1, machine.Pin.IN, machine.Pin.PULL_UP)

# Stepper motor control pins
stepper_pins = [
    machine.Pin(6, machine.Pin.OUT),  # IN1
    machine.Pin(7, machine.Pin.OUT),  # IN2
    machine.Pin(8, machine.Pin.OUT),  # IN3
    machine.Pin(9, machine.Pin.OUT)   # IN4
]

# Stepper motor steps for one revolution
step_sequence = [
    [1, 0, 0, 0],
    [1, 1, 0, 0],
    [0, 1, 0, 0],
    [0, 1, 1, 0],
    [0, 0, 1, 0],
    [0, 0, 1, 1],
    [0, 0, 0, 1],
    [1, 0, 0, 1]
]

# Variables to track button states
button_state = button_pin.value()
prev_button_state = button_state

# Function to display LED and motor state on the LCD
def update_lcd(led_state, motor_state):
    lcd.clear()  # Clear the LCD before writing new text
    utime.sleep_ms(100)  # Give a small delay to ensure clearing completes
    
    if led_state:
        lcd.move_to(0, 0)
        lcd.putstr("LED: ON")
    else:
        lcd.move_to(0, 0)
        lcd.putstr("LED: OFF")
        
    if motor_state:
        lcd.move_to(0, 1)
        lcd.putstr("Motor: RUNNING")
    else:
        lcd.move_to(0, 1)
        lcd.putstr("Motor: STOPPED")

# Function to control stepper motor steps
def step_motor(steps, direction=1, delay=10):
    for _ in range(steps):
        for step in step_sequence[::direction]:
            for pin, value in zip(stepper_pins, step):
                pin.value(value)
            utime.sleep_ms(delay)

# Display initial states
update_lcd(led_pin.value(), False)

# Main loop
while True:
    # Read the state of the button
    button_state = button_pin.value()
    
    # Check if the button state has changed (active low)
    if button_state != prev_button_state:
        # Debounce delay
        utime.sleep_ms(20)
        # Confirm the state change
        if button_state == button_pin.value():
            # If the button is pressed
            if button_state == 0:
                # Toggle the LED
                led_pin.toggle()
                # Update the LCD with the new LED state
                motor_running = led_pin.value() == 1
                update_lcd(led_pin.value(), motor_running)
                
                # If LED is ON, run the stepper motor
                if motor_running:
                    step_motor(512, direction=1, delay=5)  # Run motor for 512 steps (one revolution)
                else:
                    for pin in stepper_pins:
                        pin.value(0)  # Stop the motor by setting all pins to low
    
    # Update the previous button state
    prev_button_state = button_state
    
    # Short delay to reduce CPU usage
    utime.sleep_ms(50)

Notes

• Power Supply: Ensure the motor driver and motor are powered correctly. If using the Pico's 5V output, ensure it can supply sufficient current. A separate 5V power supply might be needed for the motor, with common ground.

• Stepper Motor Steps: Adjust the steps parameter in the step_motor function to match the number of steps per revolution of your stepper motor.

• Delay Adjustment: The delay parameter in step_motor can be adjusted to control the speed of the motor. Reducing the delay will increase the motor speed.

This setup provides a way to control a 5V unipolar stepper motor, adding stepper motor functionality to the existing LED and LCD system.

Alright, let’s give this a shot and see what happens.

Videos:

It works!

Another successful ChatGPT generated code for our project.

Fritzing Schematic:

Links:

1. GitHub Code

2. Fritzing File

This is what I told ChatGPT to do:

Now add a i2c lcd 1602 screen that displays when the led is on or off. Use pin 2 for SDA and pin 3 for SCL. Make sure to use the libraries i2c_lcd.py in the program.

ChatGPTs Answer:

To add an I2C LCD 1602 screen to the existing code and display whether the LED is on or off, you need to incorporate the necessary libraries and initialize the LCD screen. Below is the modified code including the LCD initialization and displaying the LED state:

import machine
import utime
from i2c_lcd import I2cLcd  # Ensure i2c_lcd.py is on the Pico

# Define the I2C address of the LCD (use the address detected by the I2C scanner)
I2C_ADDR = 0x27  # Replace with your LCD's I2C address
I2C_NUM_ROWS = 2
I2C_NUM_COLS = 16

# Initialize I2C on bus 1 with SDA on Pin 2 and SCL on Pin 3
i2c = machine.I2C(1, scl=machine.Pin(3), sda=machine.Pin(2), freq=100000)

# Initialize the LCD
lcd = I2cLcd(i2c, I2C_ADDR, I2C_NUM_ROWS, I2C_NUM_COLS)

# Define GP0 as an output pin for the LED
led_pin = machine.Pin(0, machine.Pin.OUT)

# Define GP1 as an input pin with a pull-up resistor for the button
button_pin = machine.Pin(1, machine.Pin.IN, machine.Pin.PULL_UP)

# Variables to track button states
button_state = button_pin.value()
prev_button_state = button_state

# Function to display LED state on the LCD
def update_lcd(led_state):
    lcd.clear()  # Clear the LCD before writing new text
    utime.sleep_ms(100)  # Give a small delay to ensure clearing completes
    
    if led_state:
        lcd.move_to(0, 0)
        lcd.putstr("LED: ON")
    else:
        lcd.move_to(0, 0)
        lcd.putstr("LED: OFF")

# Display initial state
update_lcd(led_pin.value())

# Main loop
while True:
    # Read the state of the button
    button_state = button_pin.value()
    
    # Check if the button state has changed (active low)
    if button_state != prev_button_state:
        # Debounce delay
        utime.sleep_ms(20)
        # Confirm the state change
        if button_state == button_pin.value():
            # If the button is pressed
            if button_state == 0:
                # Toggle the LED
                led_pin.toggle()
                # Update the LCD with the new LED state
                update_lcd(led_pin.value())
    
    # Update the previous button state
    prev_button_state = button_state
    
    # Short delay to reduce CPU usage
    utime.sleep_ms(50)

Explanation

1. I2C Initialization:

   • i2c = machine.I2C(1, scl=machine.Pin(3), sda=machine.Pin(2), freq=100000): Initializes I2C on bus 1 with SDA on Pin 2 and SCL on Pin 3, operating at a frequency of 100 kHz.

2. LCD Initialization:

   • lcd = I2cLcd(i2c, I2C_ADDR, I2C_NUM_ROWS, I2C_NUM_COLS): Initializes the LCD with the specified I2C address and dimensions (2 rows, 16 columns).

3. LED and Button Setup:

   • The LED is connected to GPIO0, configured as an output.

   • The button is connected to GPIO1, configured as an input with an internal pull-up resistor.

4. Display Update Function:

   • update_lcd(led_state): Clears the LCD, waits for a short delay to ensure clearing, and then writes the current state of the LED ("LED: ON" or "LED: OFF").

5. Initial Display State:

   • update_lcd(led_pin.value()): Displays the initial state of the LED on the LCD when the program starts.

6. Main Loop:

   • The main loop continuously reads the button state, toggles the LED when the button is pressed, and updates the LCD with the new LED state.

   • The button state is debounced with a delay to prevent false triggers.

We have success!

Videos:

Because it was hard to see the lcd in the first video, I created a separate video for an up-close of the lcd during operation.

Fritzing Design:

That’s it, now for the links.

GitHub Links:

GitHub Pi Pico Code: https://github.com/TheDumbEngineer/TheDumbEngineer/blob/main/ProjectThree.py

GitHub i2c_lcd.py Library: https://github.com/TheDumbEngineer/TheDumbEngineer/blob/main/i2c_lcd.py

GitHub Fritzing: https://github.com/TheDumbEngineer/TheDumbEngineer/blob/main/ThirdProject.fzz

Components Link: (since I provided links in the previous posts for the components needed leading up to this, I will just add a link to the 1602 I2C LCD screen)

1602 I2C LCD Screen: https://amzn.to/3XgVQbg

Now build on this project by adding something. Include code, code explanation, electronic components, and how to connect it all.

This is the answer ChatGPT gave me:

Let's enhance the project by adding a push button that controls the blinking of the LED. When the button is pressed, the LED will toggle its state, and when the button is released, it will stop toggling. For this enhancement, you'll need the following additional electronic component:

5. Push button switch

Here's how to connect the push button switch to the existing setup:

1. Push Button Switch:

   • Place the push button switch on the breadboard.

   • Connect one leg of the push button to a GPIO pin on the Raspberry Pi Pico. Let's use GPIO pin 1 (GP1).

   • Connect the other leg of the push button to a GND (ground) pin on the Raspberry Pi Pico. You can choose any ground pin.

   • Optionally, you can add a pull-up resistor between the GPIO pin and the button's leg connected to it to ensure stable readings. A resistor of 10k ohms is commonly used.

Here's the modified MicroPython code to incorporate the push button functionality:

# MicroPython code to toggle an LED connected to GPIO pin 0 (GP0) on Raspberry Pi Pico
# using a push button connected to GPIO pin 1 (GP1)

import machine
import utime

led_pin = machine.Pin(0, machine.Pin.OUT)  # Define GP0 as an output pin
button_pin = machine.Pin(1, machine.Pin.IN, machine.Pin.PULL_UP)  # Define GP1 as an input pin with pull-up resistor

button_state = 0  # Variable to track button state
prev_button_state = 0  # Variable to track previous button state

while True:
    button_state = button_pin.value()  # Read the state of the button
    
    if button_state != prev_button_state:  # If button state changes
        if button_state == 0:  # If button is pressed
            led_pin.toggle()  # Toggle the state of the LED
            
    prev_button_state = button_state  # Update previous button state
    utime.sleep_ms(20)  # Add a small delay to debounce the button

Explanation of the code:

• We add a new pin definition button_pin for the push button connected to GPIO pin 1 (GP1). We specify it as an input pin with a pull-up resistor.

• We introduce two variables button_state and prev_button_state to track the current and previous states of the button.

• In the while loop, we continuously read the state of the button using button_pin.value().

• If the button state changes (indicating a press or release), we toggle the LED state only when the button is pressed (button_state == 0).

• We add a small delay of 20 milliseconds to debounce the button.

Connect the push button switch as described above, upload the modified code to your Raspberry Pi Pico, and you should now be able to control the blinking of the LED using the push button!

Ok, so it mentions a pull-up resistor, realizing some of folks reading this might not understand what a pull-up resistor is or does, or how to connect it to the project. I asked ChatGPT a follow up question of:

What is a pull up resistor and how do I connect it to the project?

ChatGPTs Answer:

A pull-up resistor is a resistor connected between a signal line and a positive voltage (typically Vcc or the supply voltage). It ensures that the signal line is pulled to a logical high state (usually the same voltage as the positive supply) when no other active device is driving the line to a low state. This configuration helps prevent floating or undefined states, providing a stable reference voltage when the line is not being actively driven.

In the context of a push button switch, a pull-up resistor is used to ensure that the input pin reads a logical high state when the button is not pressed. When the button is pressed, it connects the input pin to ground, overriding the pull-up resistor and causing the input pin to read a logical low state.

Here's how to connect a pull-up resistor to your project:

   1. Choose the resistor value: A commonly used value for pull-up resistors is around 10k ohms (10,000 ohms). However, depending on your specific requirements and components, you can adjust this value if needed.

   2. Connect the resistor: Connect one end of the resistor to the GPIO pin to which the push button is connected.Connect the other end of the resistor to the positive voltage supply (Vcc), which is typically the 3.3V pin on the Raspberry Pi Pico.

I also wanted to mention that there is such thing as a pull-down resistor as well. Both have there place, but for this project we are going to use a pull-up resistor.

Image of a circuit the pull-up on the left and pull-down on the right:

Fritzing:

Now, let’s get to work!

And just like that, ChatGPT code works again folks!

Links!

Code:

GitHub: https://github.com/TheDumbEngineer/TheDumbEngineer

Electronic Components Needed:

Pi Pico: https://amzn.to/3yigkWC

LED Assortment: https://amzn.to/3UNoiyM

Pi Pico Programming Cable: https://amzn.to/3UNoAWo

Jumper Cables: https://amzn.to/3K3QmZx

Breadboard: https://amzn.to/4blRwvs

Resistor: https://amzn.to/4bJpQjV

Button: https://amzn.to/3WF9Hbb

Stay tuned!

I want to provide you all with a plan on this project and what I am going to be doing. So, the plan is to add different functionality and components to the same project as we progress, so by the end we will have something complex. Maybe we can get a couple of Pi Picos to communicate with each other. The instructions and code will be provided entirely by ChatGPT. The only thing we need to do is flash the MicroPython code and assemble the components.

Let’s get back to work!

Now that we have MicroPython flashed onto the Pi Pico we are ready to jump into the first project. So to start, I asked ChatGPT this: Create a basic Pi Pico project with MicroPython code and tell me the electronic components I need to use. Also, tell me how to connect the electronic components.

Answer:

Sure! Let's create a basic project using a Raspberry Pi Pico and MicroPython to blink an LED. For this project, you'll need the following electronic components:

1. Raspberry Pi Pico

2. LED (any color)

3. Resistor (220 ohms is a common value)

4. Breadboard

5. Jumper wires

Here's how to connect the components:

1. **Raspberry Pi Pico**:

- Connect the Raspberry Pi Pico to your computer using a micro USB cable for power and programming.

2. **LED**:

- Place the LED on the breadboard. The longer leg of the LED (the anode) should be connected to a GPIO pin on the Pi Pico. For this example, let's use GPIO pin 0 (GP0).

- Connect the shorter leg of the LED (the cathode) to one leg of the resistor.

3. **Resistor**:

- Connect the other leg of the resistor to a GND (ground) pin on the Raspberry Pi Pico. You can choose any ground pin.

4. **Breadboard and Jumper wires**:

- Use jumper wires to make the connections between the Raspberry Pi Pico, LED, and resistor on the breadboard. Make sure the connections are secure.

Once you have all the components connected, you can proceed with the MicroPython code. Here's a simple code to blink the LED:

# MicroPython code to blink an LED connected to GPIO pin 0 (GP0) on Raspberry Pi Pico

import machine
import utime

led_pin = machine.Pin(0, machine.Pin.OUT)  # Define GP0 as an output pin

while True:
    led_pin.toggle()  # Toggle the state of the LED
    utime.sleep_ms(500)  # Wait for 500 milliseconds (0.5 seconds)

Explanation of the code:

- We import the `machine` module to interact with hardware.

- We import the `utime` module for adding time delays.

- We define `led_pin` as an output pin connected to GPIO pin 0 (GP0) using `machine.Pin`.

- In the `while` loop, we toggle the state of the LED using `led_pin.toggle()` which turns it on and off alternatively.

- We add a delay of 500 milliseconds (0.5 seconds) between each toggle using `utime.sleep_ms(500)`.

Upload this code to your Raspberry Pi Pico using your preferred method (e.g., Thonny IDE, rshell, etc.), and you should see the LED blinking!

Video:

Fritzing Design:

**Note**

I used pin 23 for the ground in the video, pin 3 will work as ground too.

Github link: https://github.com/TheDumbEngineer/TheDumbEngineer/blob/main/ProjectOne.py

Components:

Pi Pico - https://amzn.to/4btgvgh

Pi Pico Programming Cable - https://amzn.to/3yeGWYN

220 Ohm Resistor - https://amzn.to/3Uw7uMF

Flashing MicroPython onto a Raspberry Pi Pico using Thonny IDE is a straightforward process. Here's a step-by-step guide:

1. **Install Thonny**: If you haven't already, download and install Thonny IDE from their official website: https://thonny.org/

2. **Install MicroPython Firmware**: Before you can flash MicroPython onto your Pi Pico, you need to download the MicroPython firmware. You can get the latest firmware from the official MicroPython website: https://micropython.org/download/rp2-pico/

3. **Connect Pi Pico**: Plug your Raspberry Pi Pico into your computer using a micro USB cable. Make sure it's properly connected and detected by your computer.

4. **Open Thonny**: Launch Thonny IDE on your computer.

5. **Select Interpreter**: In Thonny, go to the "Interpreter" menu and select "MicroPython (Raspberry Pi Pico)".

6. **Check Connection**: Once you've selected the MicroPython interpreter, Thonny will try to connect to your Pi Pico. If everything is set up correctly, you should see a REPL prompt in the Shell pane at the bottom.

7. **Flash MicroPython Firmware**: To flash MicroPython firmware onto your Pi Pico, click on "Run" in the menu bar and select "Flash mode" from the dropdown menu. Thonny will prompt you to select the firmware file you downloaded earlier.

8. **Select Firmware**: Navigate to the directory where you downloaded the MicroPython firmware and select the appropriate file. It typically has a `.uf2` extension.

9. **Flash Firmware**: After selecting the firmware file, Thonny will initiate the flashing process. Follow any on-screen instructions, and the firmware will be flashed onto your Pi Pico.

10. **Verify**: Once the flashing process is complete, you should see the Pi Pico restart, and you'll be back at the REPL prompt in Thonny. You can now start writing and executing MicroPython code on your Pi Pico.

That's it! You've successfully flashed MicroPython onto your Raspberry Pi Pico using Thonny IDE. You can now start exploring the capabilities of MicroPython on your device.

And it works, the instructions provided by ChatGPT on how to flash MicroPython on to a Pi Pico was successful!

Flashing and checking connection:

Stay tuned!