All posts by admin

In this Video Lesson I will teach you how to use echolocation to measure distances. We will use the HC-SR04 Ultrasonic Sensor, and will use the Raspberry Pi Pico W. We will explain how echolocation works, and show you how the sensor works. We will do the math, and then create the code for making measurements.

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================

import machine
import time

TRIG_PIN = 16
ECHO_PIN = 17

TRIG = machine.Pin(TRIG_PIN,machine.Pin.OUT)
ECHO = machine.Pin(ECHO_PIN,machine.Pin.IN)

def distance():
    TRIG.low()
    time.sleep_us(2)
    TRIG.high()
    time.sleep_us(10)
    TRIG.low()
    while (ECHO.value()==0):
        pass
    time1=time.ticks_us()
    while (ECHO.value()==1):
        pass
    time2=time.ticks_us()
    pingTime=time.ticks_diff(time2,time1)/2
    d=.0343*pingTime
    return d
while True:
    dist=distance()
    print("Distance to Target: ",dist," cm")
    time.sleep_ms(250)

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import machine

import time

TRIG_PIN = 16

ECHO_PIN = 17

TRIG = machine.Pin(TRIG_PIN,machine.Pin.OUT)

ECHO = machine.Pin(ECHO_PIN,machine.Pin.IN)

def distance():

TRIG.low()

time.sleep_us(2)

TRIG.high()

time.sleep_us(10)

TRIG.low()

while (ECHO.value()==0):

pass

time1=time.ticks_us()

while (ECHO.value()==1):

pass

time2=time.ticks_us()

pingTime=time.ticks_diff(time2,time1)/2

d=.0343*pingTime

return d

while True:

dist=distance()

print("Distance to Target: ",dist," cm")

time.sleep_ms(250)

Arduino

Using the SSD1306 OLED With an Arduino

January 23, 2025 admin

In this Video Tutorial we show you how to incorporate the SSD1306 OLED into your Arduino project. This is a versatile, low power display that makes it easy for you to incorporate a nice display into your Arduino projects. For this project, we connect the OLED via I2C. The schematic for our project is presented below:

Our physical build looked like this:

The video above shows in depth description of the code development, but for your convenience, we include the code below.

// ====================================================================
// DISCLAIMER:
// This code is provided as-is for educational and experimental 
// purposes only. The author makes no representations or warranties of 
// any kind concerning the safety, suitability, or accuracy of this 
// code. Use at your own risk. The author assumes no liability for any 
// damages, system failures, security breaches, or network issues 
// resulting from the use or implementation of this script.
// ====================================================================

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

int screenWidth = 128;
int screenHeight = 64;
int oledReset = -1;
#define SCREEN_ADDRESS 0x3C
Adafruit_SSD1306 oled(screenWidth,screenHeight,&Wire,oledReset);

void setup() {
  // put your setup code here, to run once:
Serial.begin(9600);
oled.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);
}

void loop() {
  // put your main code here, to run repeatedly:
oled.clearDisplay();
oled.display();
oled.setCursor(0,12);
oled.setTextColor(WHITE);
oled.setTextSize(3);
oled.println(" Hello");
oled.println(" World!");
oled.display();
delay(1000);
oled.invertDisplay(1);
delay(1000);
oled.invertDisplay(0);
delay(1000);

oled.clearDisplay();
oled.drawPixel(64,32,WHITE);
oled.display();
delay(1000);

oled.clearDisplay();
oled.drawLine(0,0,127,63,WHITE);
oled.display();
delay(1000);

oled.clearDisplay();
oled.drawLine(0,32,127,32,WHITE);
oled.drawLine(64,0,64,63,WHITE);
oled.display();
delay(1000);

oled.clearDisplay();
oled.drawRect(0,0,128,64,WHITE);
oled.display();
delay(1000);

oled.clearDisplay();
oled.fillRect(0,0,128,64,WHITE);
oled.display();
delay(1000);

oled.clearDisplay();
oled.fillRect(0,0,128,64,WHITE);
oled.fillRect(5,5,118,54,BLACK);
oled.display();
delay(1000);

oled.clearDisplay();
oled.drawCircle(64,32,31,WHITE);
oled.display();
delay(1000);

oled.clearDisplay();
oled.fillCircle(64,32,31,WHITE);
oled.fillCircle(64,32,24,BLACK);
oled.display();
delay(1000);

}

// ====================================================================

// DISCLAIMER:

// This code is provided as-is for educational and experimental

// purposes only. The author makes no representations or warranties of

// any kind concerning the safety, suitability, or accuracy of this

// code. Use at your own risk. The author assumes no liability for any

// damages, system failures, security breaches, or network issues

// resulting from the use or implementation of this script.

// ====================================================================

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

int screenWidth = 128;

int screenHeight = 64;

int oledReset = -1;

#define SCREEN_ADDRESS 0x3C

Adafruit_SSD1306 oled(screenWidth,screenHeight,&Wire,oledReset);

void setup() {

// put your setup code here, to run once:

Serial.begin(9600);

oled.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);

}

void loop() {

// put your main code here, to run repeatedly:

oled.clearDisplay();

oled.display();

oled.setCursor(0,12);

oled.setTextColor(WHITE);

oled.setTextSize(3);

oled.println(" Hello");

oled.println(" World!");

oled.display();

delay(1000);

oled.invertDisplay(1);

delay(1000);

oled.invertDisplay(0);

delay(1000);

oled.clearDisplay();

oled.drawPixel(64,32,WHITE);

oled.display();

delay(1000);

oled.clearDisplay();

oled.drawLine(0,0,127,63,WHITE);

oled.display();

delay(1000);

oled.clearDisplay();

oled.drawLine(0,32,127,32,WHITE);

oled.drawLine(64,0,64,63,WHITE);

oled.display();

delay(1000);

oled.clearDisplay();

oled.drawRect(0,0,128,64,WHITE);

oled.display();

delay(1000);

oled.clearDisplay();

oled.fillRect(0,0,128,64,WHITE);

oled.display();

delay(1000);

oled.clearDisplay();

oled.fillRect(0,0,128,64,WHITE);

oled.fillRect(5,5,118,54,BLACK);

oled.display();

delay(1000);

oled.clearDisplay();

oled.drawCircle(64,32,31,WHITE);

oled.display();

delay(1000);

oled.clearDisplay();

oled.fillCircle(64,32,31,WHITE);

oled.fillCircle(64,32,24,BLACK);

oled.display();

delay(1000);

}

Raspberry Pi Pico

Controlling NeoPixel Array on PIO State Machine on Raspberry Pi Pico

January 21, 2025 admin

In this video lesson we show how neopixels work at a fundamental level, and show how you can use the Raspberry Pi Pico State Machines to control the neoixels. Neopixels are an excellent example for showing the importance of the pico state machine. The neopixels demand precise timing and sequence of bits to operate properly, and that precision can not be achieved in python. The video explains how the State Machines can be programmed to control the neopixels.

For your convenience, the code is included below.

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================

import rp2
from machine import Pin
import time
@rp2.asm_pio(sideset_init=rp2.PIO.OUT_HIGH,
             out_shiftdir=rp2.PIO.SHIFT_LEFT,
             autopull=True,
             pull_thresh=24)
def ws2812():
    wrap_target()
    label("bitloop")
    out(x,1).side(0)
    jmp(not_x,"do_zero").side(1)
    nop().side(1)[5-1]
    nop().side(0)[2-1]
    jmp("bitloop").side(0)
    label("do_zero")
    nop().side(1)[2-1]
    jmp("bitloop").side(0)[6-1]
    wrap()
sm=rp2.StateMachine(0,ws2812,freq=8000000,sideset_base=Pin(0))
sm.active(1)

def write_neopixel(colors):
    for color in colors:
        grb=color[1]<<16 | color[0]<<8 | color[2]
        sm.put(grb,8)
        
    
NUM_LEDS =8
myColor=[0]*NUM_LEDS
myColor=[[100,0,0],
         [0,100,0],
         [0,0,100],
         [0,100,100],
         [100,0,100],
         [100,100,0],
         [200,100,0],
         [255,255,255]]
write_neopixel(myColor)

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import rp2

from machine import Pin

import time

@rp2.asm_pio(sideset_init=rp2.PIO.OUT_HIGH,

out_shiftdir=rp2.PIO.SHIFT_LEFT,

autopull=True,

pull_thresh=24)

def ws2812():

wrap_target()

label("bitloop")

out(x,1).side(0)

jmp(not_x,"do_zero").side(1)

nop().side(1)[5-1]

nop().side(0)[2-1]

jmp("bitloop").side(0)

label("do_zero")

nop().side(1)[2-1]

jmp("bitloop").side(0)[6-1]

wrap()

sm=rp2.StateMachine(0,ws2812,freq=8000000,sideset_base=Pin(0))

sm.active(1)

def write_neopixel(colors):

for color in colors:

grb=color[1]<<16 | color[0]<<8 | color[2]

sm.put(grb,8)

NUM_LEDS =8

myColor=[0]*NUM_LEDS

myColor=[[100,0,0],

[0,100,0],

[0,0,100],

[0,100,100],

[100,0,100],

[100,100,0],

[200,100,0],

[255,255,255]]

write_neopixel(myColor)

Raspberry Pi Pico

Raspberry Pi Pico PIO State Machine IRQ Interrupts and Handlers

January 14, 2025 admin

In this video lesson we learn how to use and handle multiple IRQ interrupts using the Raspberry Pi Pico PIO state machines. We demonstrate this by using 3 LEDs, controlled by three separate buttons. We show how to set, clear, and wait on IRQ interrupts. We show how to use blocking and no blocking interrupts. In this video lesson, we use the following circuit.

For your convenience, the code we develop in the video is presented below.

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================

import rp2
from machine import Pin
import time

# Define PIO program for the button to trigger an interrupt on SM0
@rp2.asm_pio()
def button_irq():
    wrap_target()
    label('readAgain')
    mov(isr,null) [31]
    in_(pins,3) [31]
    mov(x,isr) [31]
    jmp(not_x,'readAgain')
    set(y,0b001);
    jmp(x_not_y,'checkYellow')
    irq(block,0)
    wait(0,pin,0)
    jmp('readAgain')
    label('checkYellow')
    set(y,0b010)
    jmp(x_not_y,'checkRed')
    irq(block,1)
    wait(0,pin,1)
    jmp('readAgain')
    label('checkRed') 
    irq(block,2)
    wait(0,pin,2)
    wrap()

# Define PIO program for the LED control on SM1
@rp2.asm_pio(out_init=rp2.PIO.OUT_LOW)
def led_control1():
    set(x, 0b00000)         # Initialize X register to 0 (LED off initially)
    wrap_target()
    wait(1, irq, 0)   # Wait for interrupt 0 to be set
    mov(x, invert(x)) # Invert X register to toggle state
    mov(pins,x)
    irq(clear, 0)     # Clear the interrupt to allow the next press to be handled
    wrap()
@rp2.asm_pio(out_init=rp2.PIO.OUT_LOW)
def led_control2():
    set(x, 0b00000)         # Initialize X register to 0 (LED off initially)
    wrap_target()
    wait(1, irq, 1)   # Wait for interrupt 0 to be set
    mov(x, invert(x)) # Invert X register to toggle state
    mov(pins,x)
    irq(clear, 1)     # Clear the interrupt to allow the next press to be handled
    wrap()
@rp2.asm_pio(out_init=rp2.PIO.OUT_LOW)
def led_control3():
    set(x, 0b00000)         # Initialize X register to 0 (LED off initially)
    wrap_target()
    wait(1, irq, 2)   # Wait for interrupt 0 to be set
    mov(x, invert(x)) # Invert X register to toggle state
    mov(pins,x)
    irq(clear, 2)     # Clear the interrupt to allow the next press to be handled
    wrap()

# Initialize State Machine 0 for the button (GPIO 11)
button_pin = Pin(11, Pin.IN, Pin.PULL_DOWN)
button_pin2 = Pin(12, Pin.IN, Pin.PULL_DOWN)
button_pin3 = Pin(13, Pin.IN, Pin.PULL_DOWN)
sm_button = rp2.StateMachine(0, button_irq, freq=2000, in_base=button_pin)

# Initialize State Machine 1 for the LED (GPIO 18)
led_pin1 = Pin(18, Pin.OUT)
sm_led1 = rp2.StateMachine(1, led_control1, freq=2000, out_base=led_pin1)
# 
led_pin2 = Pin(19, Pin.OUT)
sm_led2 = rp2.StateMachine(2, led_control2, freq=2000, out_base=led_pin2)

led_pin3 = Pin(20, Pin.OUT)
sm_led3 = rp2.StateMachine(3, led_control3, freq=2000, out_base=led_pin3)
# 
# Activate both state machines
sm_button.active(1)
sm_led1.active(1)
sm_led2.active(1)
sm_led3.active(1)
# Keep the program running

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import rp2

from machine import Pin

import time

# Define PIO program for the button to trigger an interrupt on SM0

@rp2.asm_pio()

def button_irq():

wrap_target()

label('readAgain')

mov(isr,null) [31]

in_(pins,3) [31]

mov(x,isr) [31]

jmp(not_x,'readAgain')

set(y,0b001);

jmp(x_not_y,'checkYellow')

irq(block,0)

wait(0,pin,0)

jmp('readAgain')

label('checkYellow')

set(y,0b010)

jmp(x_not_y,'checkRed')

irq(block,1)

wait(0,pin,1)

jmp('readAgain')

label('checkRed')

irq(block,2)

wait(0,pin,2)

wrap()

# Define PIO program for the LED control on SM1

@rp2.asm_pio(out_init=rp2.PIO.OUT_LOW)

def led_control1():

set(x, 0b00000) # Initialize X register to 0 (LED off initially)

wrap_target()

wait(1, irq, 0) # Wait for interrupt 0 to be set

mov(x, invert(x)) # Invert X register to toggle state

mov(pins,x)

irq(clear, 0) # Clear the interrupt to allow the next press to be handled

wrap()

@rp2.asm_pio(out_init=rp2.PIO.OUT_LOW)

def led_control2():

set(x, 0b00000) # Initialize X register to 0 (LED off initially)

wrap_target()

wait(1, irq, 1) # Wait for interrupt 0 to be set

mov(x, invert(x)) # Invert X register to toggle state

mov(pins,x)

irq(clear, 1) # Clear the interrupt to allow the next press to be handled

wrap()

@rp2.asm_pio(out_init=rp2.PIO.OUT_LOW)

def led_control3():

set(x, 0b00000) # Initialize X register to 0 (LED off initially)

wrap_target()

wait(1, irq, 2) # Wait for interrupt 0 to be set

mov(x, invert(x)) # Invert X register to toggle state

mov(pins,x)

irq(clear, 2) # Clear the interrupt to allow the next press to be handled

wrap()

# Initialize State Machine 0 for the button (GPIO 11)

button_pin = Pin(11, Pin.IN, Pin.PULL_DOWN)

button_pin2 = Pin(12, Pin.IN, Pin.PULL_DOWN)

button_pin3 = Pin(13, Pin.IN, Pin.PULL_DOWN)

sm_button = rp2.StateMachine(0, button_irq, freq=2000, in_base=button_pin)

# Initialize State Machine 1 for the LED (GPIO 18)

led_pin1 = Pin(18, Pin.OUT)

sm_led1 = rp2.StateMachine(1, led_control1, freq=2000, out_base=led_pin1)

led_pin2 = Pin(19, Pin.OUT)

sm_led2 = rp2.StateMachine(2, led_control2, freq=2000, out_base=led_pin2)

led_pin3 = Pin(20, Pin.OUT)

sm_led3 = rp2.StateMachine(3, led_control3, freq=2000, out_base=led_pin3)

# Activate both state machines

sm_button.active(1)

sm_led1.active(1)

sm_led2.active(1)

sm_led3.active(1)

# Keep the program running

Python, Raspberry Pi Pico

Raspberry Pi Pico PIO State Machine IRQ Interrupts

January 7, 2025 admin

<span data-mce-type="bookmark" style="display: inline-block; width: 0px; overflow: hidden; line-height: 0;" class="mce_SELRES_start"></span> In the video lesson above, we show how to incorporate IRQ interrupts on the Pi Pico PIO State Machines. The state machines will monitor the buttons, watching for button presses. When a button is pressed, an interrupt is set. That interrupt can then be used by that same state machine, a different state machine on the same PIO, or in the main micropython program. Our first example will be to toggle the LED in the main python program, based on the interrupt from the state machine. In the second example, one state machine monitors the button, and the second state machine controls the LED. This is a schematic for the circuit we will be using.

This first code controls the LED from the main python program.

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================

import rp2
from machine import Pin
import time

# Define PIO program for SM0 to trigger an interrupt on button press
@rp2.asm_pio()
def button_irq():
    wrap_target()
    wait(1, pin, 0)  [31]  # Wait for the button press (low signal on GPIO 11)
    nop() [31]
    nop() [31]
    nop() [31]
    nop() [31]
    irq(block, 0)      # Trigger interrupt 0
    wait(0, pin, 0)    # Wait for the button release (high signal on GPIO 11)
    nop() [31]
    nop() [31]
    nop() [31]
    nop() [31]
    wrap()
# Initialize State Machine 0 for the button (GPIO 11)
button_pin = Pin(11, Pin.IN, Pin.PULL_DOWN)
sm_button = rp2.StateMachine(0, button_irq, freq=2000, in_base=button_pin)
# GPIO pin for the LED (GPIO 18)
led_pin = Pin(18, Pin.OUT)
# Interrupt handler for the button press
def button_handler(sm):
    led_pin.value(not led_pin.value())  # Toggle LED state
# Attach the interrupt handler to the State Machine's IRQ
sm_button.irq(button_handler)
# Activate the state machine
sm_button.active(1)

# Keep the program running
ts=1
while True:
    time.sleep(ts)

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import rp2

from machine import Pin

import time

# Define PIO program for SM0 to trigger an interrupt on button press

@rp2.asm_pio()

def button_irq():

wrap_target()

wait(1, pin, 0) [31] # Wait for the button press (low signal on GPIO 11)

nop() [31]

irq(block, 0) # Trigger interrupt 0

wait(0, pin, 0) # Wait for the button release (high signal on GPIO 11)

nop() [31]

wrap()

# Initialize State Machine 0 for the button (GPIO 11)

button_pin = Pin(11, Pin.IN, Pin.PULL_DOWN)

sm_button = rp2.StateMachine(0, button_irq, freq=2000, in_base=button_pin)

# GPIO pin for the LED (GPIO 18)

led_pin = Pin(18, Pin.OUT)

# Interrupt handler for the button press

def button_handler(sm):

led_pin.value(not led_pin.value()) # Toggle LED state

# Attach the interrupt handler to the State Machine's IRQ

sm_button.irq(button_handler)

# Activate the state machine

sm_button.active(1)

# Keep the program running

ts=1

while True:

time.sleep(ts)

This next program uses only the state machines. Interrupts and LED control are both done in the state machines.

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================

import rp2
from machine import Pin
import time

@rp2.asm_pio()
def button_irq():
    wrap_target()
    wait(1, pin, 0) [31]
    nop() [31]
    nop() [31]
    nop() [31]
    nop() [31]
    irq(block,0)
    wait(0,pin,0)
    nop() [31]
    nop() [31]
    nop() [31]
    nop() [31]
    wrap()

@rp2.asm_pio(out_init=rp2.PIO.OUT_LOW)
def led_control():
    set(x,0b00000)
    wrap_target()
    wait(1, irq, 0)
    mov(x,invert(x))
    mov(pins,x)
    irq(clear, 0)
    wrap()

button_pin = Pin(11,Pin.IN,Pin.PULL_DOWN)
sm_button=rp2.StateMachine(0,button_irq, freq=2000, in_base=button_pin)

led_pin = Pin(18, Pin.OUT)
sm_led=rp2.StateMachine(1, led_control, freq=2000, out_base=led_pin)
sm_button.active(1)
sm_led.active(1)

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import rp2

from machine import Pin

import time

@rp2.asm_pio()

def button_irq():

wrap_target()

wait(1, pin, 0) [31]

nop() [31]

irq(block,0)

wait(0,pin,0)

nop() [31]

wrap()

@rp2.asm_pio(out_init=rp2.PIO.OUT_LOW)

def led_control():

set(x,0b00000)

wrap_target()

wait(1, irq, 0)

mov(x,invert(x))

mov(pins,x)

irq(clear, 0)

wrap()

button_pin = Pin(11,Pin.IN,Pin.PULL_DOWN)

sm_button=rp2.StateMachine(0,button_irq, freq=2000, in_base=button_pin)

led_pin = Pin(18, Pin.OUT)

sm_led=rp2.StateMachine(1, led_control, freq=2000, out_base=led_pin)

sm_button.active(1)

sm_led.active(1)

Technology Tutorials

All posts by admin

Measure Distance Using the HC-SR04 Ultrasonic Sensor on the Raspberry Pi Pico

Using the SSD1306 OLED With an Arduino

Controlling NeoPixel Array on PIO State Machine on Raspberry Pi Pico

Raspberry Pi Pico PIO State Machine IRQ Interrupts and Handlers

Raspberry Pi Pico PIO State Machine IRQ Interrupts

Making The World a Better Place One High Tech Project at a Time. Enjoy!