ESP32 IOT

DIO

Timer

Interrupt

ESP32 DO Pin πŸ”—

ESP32 DO Source Current πŸ”—

ESP32 DO Source Current πŸ”—

ESP32 DO Sink Current πŸ”—

ESP32 DO Sink Current πŸ”—

ESP32: LED Blinking πŸ”—

ESP32: DI Pin

ESP32: Digital Input

ESP32: Digital Input Pull UP

ESP32: Digital Input Pull UP

ESP32: Digital Input Pull Down

ESP32: Digital Input Pull Down

Controlling LED with Button using Pull-Up Resistor

Controlling LED with Button using Pull-Down Resistor

Introduction to Blocking

Introducing the concept of blocking in programming and its implications.

LED + Button with Blocking

This code controls the state of two LEDs. The red LED toggles every 2 seconds, # and the blue LED's state is controlled by the button's state.

Β 

ζ­€η¨‹εΌη’ΌζŽ§εˆΆε…©ε€‹ LED ηš„η‹€ζ…‹γ€‚η΄…θ‰² LED 每 2 η§’εˆ‡ζ›δΈ€ζ¬‘οΌŒθ€Œθ—θ‰² LED ηš„η‹€ζ…‹η”±ζŒ‰ιˆ•ηš„η‹€ζ…‹ζŽ§εˆΆγ€‚

LED + Button with Blocking

Observations

  • When the button is pressed during time.sleep(), Blue LED does not turn on immediately.
  • The system is blocked and unresponsive during sleep intervals.

LED + Button with Non-Blocking

Code Sample using Timer

LED + Button with Non-Blocking

Code Sample using Timer & IRQ

Summary

  • Comparison of blocking vs non-blocking approaches.
  • Discussing the advantages of using timers and IRQs to handle multitasking.

Timer Overview

  • Definition of Timer:
    • A Timer is a hardware feature that can measure time intervals.
  • Importance in MicroPython:
    • Useful for running functions at specific intervals and creating delays.

Timer Initialization

from machine import Timer

timer0 = Timer(0)
timer0.init(period=2000, callback=lambda t:print(0))

Timer.init() method:

Used to configure the timer with specific parameters.

Timer.init(*, mode=Timer.PERIODIC, freq=-1, period=-1, callback=None)

Timer Modes

from machine import Timer

timer0 = Timer(0)
timer0.init(mode=Timer.ONE_SHOT, period=2000, callback=lambda t:print(0))

timer1 = Timer(1)
timer1.init(mode=Timer.PERIODIC, period=1000, callback=lambda t:print(1))

Timer Callbacks

Definition of Callbacks: Functions that are called when a timer expires.

from machine import Pin, Timer
timer = Timer(0)

led = Pin(21, Pin.OUT)

def toggle_led(timer):
    led.value(not led.value())

timer.init( period=1000, mode=Timer.PERIODIC, 
            callback = toggle_led )

Timer Callbacks

Deinitialize a Timer

Stops the timer, and removes the configuration.

from machine import Timer
import time

# Initialize the counter and timer
counter = 0
timer = Timer(0)

def on_timer(timer):
    global counter
    print(f"Timer Triggered! {counter}")
    counter += 1  # Increment the counter each time the timer is triggered
    
# Initialize the timer
timer.init(period=2000, mode=Timer.PERIODIC, callback=on_timer)

while True:
    # Check the counter in the main loop
    if counter == 5:
        print(f"Deinitializing Timer... {counter}")
        timer.deinit()
        counter += 1
    
    if counter > 5:
        print(f"Main loop in while is ruuning... {counter}")
        counter += 1

    time.sleep(1)  # Sleep for a while before checking the counter again

Deinitialize a Timer

Example: Variable Timer Period

from machine import Timer
import time

timer = Timer(0)

period = 1000  # 1 second
last_time = time.ticks_ms()

def on_timer(timer):
    global period, last_time
    current_time = time.ticks_ms()
    time_diff = time.ticks_diff(current_time, last_time)
    print("Timer Triggered! Time Difference: {} ms".format(time_diff))
    period += 1000  # Increase period by 1 second
    timer.init(period=period, mode=Timer.ONE_SHOT, callback=on_timer)
    last_time = current_time  # Update the last_time to the current_time
    
timer.init(period=period, mode=Timer.ONE_SHOT, callback=on_timer)

Β Example: Mutiple Timer

from machine import Timer
import time

# Initialize multiple timers
timer1 = Timer(0)
timer2 = Timer(1)

# Initialize last time for each timer
last_time1 = time.ticks_ms()
last_time2 = time.ticks_ms()

def on_timer1(timer):
    global last_time1
    current_time = time.ticks_ms()
    time_diff = time.ticks_diff(current_time, last_time1)
    print("Timer 1 Triggered! Time Difference: {} ms".format(time_diff))
    last_time1 = current_time  # Update the last_time1 to the current_time
    
def on_timer2(timer):
    global last_time2
    current_time = time.ticks_ms()
    time_diff = time.ticks_diff(current_time, last_time2)
    print("Timer 2 Triggered! Time Difference: {} ms".format(time_diff))
    last_time2 = current_time  # Update the last_time2 to the current_time

# Initialize timers with different periods and modes
timer1.init(period=1000, mode=Timer.PERIODIC, callback=on_timer1)
timer2.init(period=2000, mode=Timer.PERIODIC, callback=on_timer2)

Traffic Light Simulation

from machine import Pin, Timer

# Define a list to hold the color and pin number tuples
color_and_pin_list = [('red', 23), ('yellow', 21), ('green', 4)]

# Use a dictionary comprehension to create the 'leds' dictionary
leds = {color: Pin(pin, Pin.OUT) for color, pin in color_and_pin_list}

# Initialize timer
timer = Timer(0)

def change_light(t):
    if leds['red'].value():      # If red is ON
        leds['red'].off()
        leds['green'].on()
        timer.init(period=700, mode=Timer.ONE_SHOT, callback=change_light)
    elif leds['green'].value():  # If green is ON
        leds['green'].off()
        leds['yellow'].on()
        timer.init(period=200, mode=Timer.ONE_SHOT, callback=change_light)
    else:                        # If yellow is ON
        leds['yellow'].off()
        leds['red'].on()
        timer.init(period=500, mode=Timer.ONE_SHOT, callback=change_light)

# Initialize the starting state and start the timer
leds['green'].on()
timer.init(period=700, mode=Timer.ONE_SHOT, callback=change_light)

In this example, we are using one timer to control all three lights, changing the callback period to simulate the different light durations.

What is an IRQ?

  • IRQ stands for Interrupt Request.
  • It's a mechanism by which a processor can be interrupted from its current task to run a specific set of instructions.
  • It's useful for handling external events or inputs, like button presses or sensor readings.

Handling IRQΒ 

  1. Initialize the pin as an input pin.
  2. Configure the pin to trigger an interrupt.
  3. Define a callback function that will be executed when the interrupt is triggered.
  4. Attach the callback function to the interrupt.

Simple Example - Button Press

Objective

  • Create a simple example where a button press triggers an IRQ.
  • When the button is pressed, an LED will toggle its state (ON/OFF).

Components

  • Push Button
  • LED
  • Resistors

Button Press Example CodeΒ 

from machine import Pin
import time

# Initialize LED and Button
led = Pin(21, Pin.OUT) # LED connected to GPIO12
button = Pin(32, Pin.IN, Pin.PULL_UP) # Button connected to GPIO13
led.on()

# Callback function to handle button press
def button_handler(pin):
    led.value(not led.value()) # Toggle LED state

# Attach the callback function to button press interrupt
button.irq(trigger=Pin.IRQ_FALLING, handler=button_handler)

while True:
    time.sleep(0.1) # Sleep to reduce CPU usage

Button Press Example Connection Diagram

Button Press Example

Timer Interrupt Example

  • Timer interrupts can be used to execute a function at regular intervals.
from machine import Timer

tim = Timer(0)

def tick(timer):
    print('Tick!', timer)

# Initialize timer interrupt
tim.init(mode=Timer.PERIODIC, period=1000,  callback=tick)

# The function 'tick' will be called every 1000ms (1 second)

Conclusion

Recap

  • We learned about IRQ and how it allows the processor to handle specific events like button presses.
  • We explored how to use MicroPython to handle IRQs on an ESP32 board.
  • We implemented simple examples where a button press toggles an LED and a timer interrupt prints a message every second.

Further Learning

  • Explore more advanced IRQ features like debouncing.
  • Try handling different types of events like sensor readings.
Made with Slides.com