Home » Archives for 2b4a3pico71
Author

2b4a3pico71

KY-021 Mini Magnetic Reed Switch
Code

a KY-021 Mini Magnetic Reed Switch to a Raspberry Pi Pico 2 tutorial

by 2b4a3pico71

In this article, we connect a KY-021 Mini Magnetic Reed Switch to a Raspberry Pi Pico 2, any rp2350 type board will be suitable.

There are many good ones, I actually used a Pimoroni one as it was on hand

Overview

We will use Micropython for these examples but of course you can use the Arduino IDE as well if you have Raspberry Pi Pico support enabled

A reed switch is an electrical switch operated by a magnetic field. It consists of two thin, ferromagnetic metal reeds sealed within a glass capsule. When a magnetic field is applied near the switch, the reeds are magnetized and either attract each other (closing the circuit) or repel each other (opening the circuit), depending on the design. The glass capsule protects the reeds from environmental damage, making the switch durable and reliable.

Reed switches are commonly used in applications where non-contact operation is essential. For instance, they are widely used in security systems as door and window sensors, detecting when they are opened or closed. They are also found in devices like reed relays, home appliances, and automotive systems, where precise and safe switching is required. Reed switches are valued for their simplicity, low power consumption, and long lifespan, though they are sensitive to vibration and shock, which can affect their reliability in certain environments.

The switch may be actuated by an electromagnetic coil, making a reed relay, or by bringing a permanent magnet near it. When the magnetic field is removed, the contacts in the reed switch return to their original position.

The sensor looks like this

Parts Required

You can connect to the module using dupont style jumper wire.

Name Link
Raspberry Pi Pico 2
37 in one sensor kit
Connecting cables

 

Schematic/Connection

Pico SENSOR
GPIO28 S
3v3 +
GND –

The part I had was Pico but the pinout for a Pico 2 is the same – so this works just fine

Code Examples

Basic example

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
from machine import Pin, Timer
from time import sleep
# Initialization of GPIO27 as input
sensor = Pin(28, Pin.IN, Pin.PULL_DOWN)
# Continuous loop for continuous serial output
while True:
if sensor.value() == 0:
print("Magnetic field")
else:
print("No magnetic field")
print("---------------------------------------")
sleep(0.5)
from machine import Pin, Timer from time import sleep # Initialization of GPIO27 as input sensor = Pin(28, Pin.IN, Pin.PULL_DOWN) # Continuous loop for continuous serial output while True: if sensor.value() == 0: print("Magnetic field") else: print("No magnetic field") print("---------------------------------------") sleep(0.5)
from machine import Pin, Timer
from time import sleep

# Initialization of GPIO27 as input
sensor = Pin(28, Pin.IN, Pin.PULL_DOWN)

# Continuous loop for continuous serial output
while True:
    if sensor.value() == 0:
        print("Magnetic field")
    else:
        print("No magnetic field")

    print("---------------------------------------")
    sleep(0.5)

 

REPL Output

You will need to find a magnetic source and move it close to the sensor

No magnetic field
—————————————
No magnetic field
—————————————
No magnetic field
—————————————
No magnetic field
—————————————
Magnetic field
—————————————
Magnetic field
—————————————
No magnetic field

—————————————

Disclaimer

“This website contains affiliate links, meaning we may earn a commission at no extra cost to you if you make a purchase through our links.”

0 FacebookTwitterPinterestEmail
KY-018 Photoresistor
Code

A KY-018 Photoresistor or LDR to a Raspberry Pi Pico 2 example

by 2b4a3pico71

In this article, we connect an KY-018 Photoresistor or LDR to a Raspberry Pi Pico 2, any rp2350 type board will be suitable.

There are many good ones, I actually used a Pimoroni one as it was on hand

Overview

We will use Micropython for these examples but of course you can use the Arduino IDE as well if you have Raspberry Pi Pico support enabled

A photoresistor, also known as a light-dependent resistor (LDR), is a type of passive electronic component whose resistance decreases as the intensity of light falling on it increases. This phenomenon makes photoresistors ideal for sensing light levels.

They are typically made of semiconductor materials, such as cadmium sulfide (CdS), which exhibit photoconductivity — a property where the conductivity of a material increases with light exposure.

Photoresistors are commonly used in applications where detecting ambient light levels is necessary. For instance, they are used in automatic streetlights, which turn on when it gets dark, and in electronic devices like light meters, alarm systems, and nightlights.

While photoresistors are cost-effective and simple to use, they have limitations, such as slow response times and reduced sensitivity to certain wavelengths of light. Moreover, the use of cadmium-based photoresistors is regulated in some regions due to environmental concerns, leading to the adoption of alternative light sensors in modern designs.

The sensor looks like this

The resistance will decrease in the presence of light and increase in the absence of it. The output is analog and determines the intensity of light.

The module consists of a photoresistor, a 10 k in-line resistor and header.

This resistance can be determined using a basic voltage divider, where a known voltage is divided across the 10k resistor and the unknown resistance from the LDR. Using this measured voltage, the resistance can then be calculated. This is the basic idea

 

Parts Required

You can connect to the module using dupont style jumper wire.

Name Link
Raspberry Pi Pico 2
37 in one sensor kit
Connecting cables

 

Schematic/Connection

Pico SENSOR
GPIO28 S
3.3v middle pin
GND –

The part I had was Pico but the pinout for a Pico 2 is the same – so this works just fine

Code Example

Basic example in  thonny

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
from machine import Pin
import time
class LDR:
def __init__(self, pin):
self.ldr_pin = machine.ADC(Pin(pin))
def get_raw_value(self):
return self.ldr_pin.read_u16()
def get_light_percentage(self):
return round(self.get_raw_value()/65535*100,2)
ldr = LDR(28)
while True:
print(ldr.get_light_percentage())
time.sleep(1)
from machine import Pin import time class LDR: def __init__(self, pin): self.ldr_pin = machine.ADC(Pin(pin)) def get_raw_value(self): return self.ldr_pin.read_u16() def get_light_percentage(self): return round(self.get_raw_value()/65535*100,2) ldr = LDR(28) while True: print(ldr.get_light_percentage()) time.sleep(1)
from machine import Pin
import time
 

class LDR:
    def __init__(self, pin):
        self.ldr_pin = machine.ADC(Pin(pin))
        
    def get_raw_value(self):
        return self.ldr_pin.read_u16()
    
    def get_light_percentage(self):
        return round(self.get_raw_value()/65535*100,2)
 
ldr = LDR(28)

while True:
     print(ldr.get_light_percentage())
     time.sleep(1)

 

REPL Output

Run -c $EDITOR_CONTENT
31.31
30.99
31.11
57.09
67.28
23.32
14.8
14.55
14.77
13.92
13.68
13.92

Disclaimer

“This website contains affiliate links, meaning we may earn a commission at no extra cost to you if you make a purchase through our links.”

0 FacebookTwitterPinterestEmail
KY-015 Temperature Sensor
Code

A KY-015 Temperature Sensor to a Raspberry Pi Pico 2 example

by 2b4a3pico71

In this article, we connect a KY-015 Temperature Sensor to a Raspberry Pi Pico 2, any rp2350 type board will be suitable. There are many good ones, I actually used a Pimoroni one as it was on hand

Overview

We will use Micropython for these examples but of course you can use the Arduino IDE as well if you have Raspberry Pi Pico support enabled

The KY-015 is a DHT11 is a low-cost, digital sensor widely used for measuring temperature and humidity in various applications. It consists of a thermistor for temperature sensing and a capacitive humidity sensor, combined with a basic signal processing unit.

The sensor outputs calibrated digital data, making it simple to interface with microcontrollers, such as Arduino, Raspberry Pi, or ESP8266. Its compact size, low power consumption, and ease of use make it an ideal choice for hobbyists and small-scale IoT projects.

The DHT11 operates within a temperature range of 0°C to 50°C and a humidity range of 20% to 90%, with an accuracy of ±2°C for temperature and ±5% for humidity.

While it is affordable and beginner-friendly, the DHT11 has limitations, such as relatively slow response times and lower accuracy compared to more advanced sensors like the DHT22 or SHT series.

Nevertheless, it remains popular for basic environmental monitoring, such as weather stations, home automation systems, and agricultural applications where high precision is not critical.

Later sensors use I2C, one drawback is that the device is slow – you need sleeps/delays between readings,

  • Operating Voltage: 3.3V to 5V
  • Current Consumption: 1.5mA
  • Temperature Measurement Range: 32ºF to 122ºF( 0ºC to 50ºC)
  • Temperature Measurement Accuracy: ±2ºC
  • Temperature Measurement Resolution: 1ºC
  • Humidity Measurement Range: 20% to 90% RH
  • Humidity Measurement Resolution: ±5% RH
  • Digital Out Signal Transmission Range:
  • Dimensions: .75in X 1.77in (2cm x 4.5cm)

 

The sensor looks like this

Parts Required

You can connect to the module using dupont style jumper wire.

Name Link
Raspberry Pi Pico 2
37 in one sensor kit
Connecting cables

 

Schematic/Connection

Pico SENSOR
GPIO27 S
3v3 +
GND –

The part I had was Pico but the pinout for a Pico 2 is the same – so this works just fine

Code Examples

Basic example – this requires a file called dht.py and the example code.

dht.py

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
import array
import micropython
import utime
from machine import Pin
from micropython import const
class InvalidChecksum(Exception):
pass
class InvalidPulseCount(Exception):
pass
MAX_UNCHANGED = const(100)
MIN_INTERVAL_US = const(200000)
HIGH_LEVEL = const(50)
EXPECTED_PULSES = const(84)
class DHT11:
_temperature: float
_humidity: float
def __init__(self, pin):
self._pin = pin
self._last_measure = utime.ticks_us()
self._temperature = -1
self._humidity = -1
def measure(self):
current_ticks = utime.ticks_us()
if utime.ticks_diff(current_ticks, self._last_measure) < MIN_INTERVAL_US and (
self._temperature > -1 or self._humidity > -1
):
# Less than a second since last read, which is too soon according
# to the datasheet
return
self._send_init_signal()
pulses = self._capture_pulses()
buffer = self._convert_pulses_to_buffer(pulses)
self._verify_checksum(buffer)
self._humidity = buffer[0] + buffer[1] / 10
self._temperature = buffer[2] + buffer[3] / 10
self._last_measure = utime.ticks_us()
@property
def humidity(self):
self.measure()
return self._humidity
@property
def temperature(self):
self.measure()
return self._temperature
def _send_init_signal(self):
self._pin.init(Pin.OUT, Pin.PULL_DOWN)
self._pin.value(1)
utime.sleep_ms(50)
self._pin.value(0)
utime.sleep_ms(18)
@micropython.native
def _capture_pulses(self):
pin = self._pin
pin.init(Pin.IN, Pin.PULL_UP)
val = 1
idx = 0
transitions = bytearray(EXPECTED_PULSES)
unchanged = 0
timestamp = utime.ticks_us()
while unchanged < MAX_UNCHANGED:
if val != pin.value():
if idx >= EXPECTED_PULSES:
raise InvalidPulseCount(
"Got more than {} pulses".format(EXPECTED_PULSES)
)
now = utime.ticks_us()
transitions[idx] = now - timestamp
timestamp = now
idx += 1
val = 1 - val
unchanged = 0
else:
unchanged += 1
pin.init(Pin.OUT, Pin.PULL_DOWN)
if idx != EXPECTED_PULSES:
raise InvalidPulseCount(
"Expected {} but got {} pulses".format(EXPECTED_PULSES, idx)
)
return transitions[4:]
def _convert_pulses_to_buffer(self, pulses):
"""Convert a list of 80 pulses into a 5 byte buffer
The resulting 5 bytes in the buffer will be:
0: Integral relative humidity data
1: Decimal relative humidity data
2: Integral temperature data
3: Decimal temperature data
4: Checksum
"""
# Convert the pulses to 40 bits
binary = 0
for idx in range(0, len(pulses), 2):
binary = binary << 1 | int(pulses[idx] > HIGH_LEVEL)
# Split into 5 bytes
buffer = array.array("B")
for shift in range(4, -1, -1):
buffer.append(binary >> shift * 8 & 0xFF)
return buffer
def _verify_checksum(self, buffer):
# Calculate checksum
checksum = 0
for buf in buffer[0:4]:
checksum += buf
if checksum & 0xFF != buffer[4]:
raise InvalidChecksum()
import array import micropython import utime from machine import Pin from micropython import const class InvalidChecksum(Exception): pass class InvalidPulseCount(Exception): pass MAX_UNCHANGED = const(100) MIN_INTERVAL_US = const(200000) HIGH_LEVEL = const(50) EXPECTED_PULSES = const(84) class DHT11: _temperature: float _humidity: float def __init__(self, pin): self._pin = pin self._last_measure = utime.ticks_us() self._temperature = -1 self._humidity = -1 def measure(self): current_ticks = utime.ticks_us() if utime.ticks_diff(current_ticks, self._last_measure) < MIN_INTERVAL_US and ( self._temperature > -1 or self._humidity > -1 ): # Less than a second since last read, which is too soon according # to the datasheet return self._send_init_signal() pulses = self._capture_pulses() buffer = self._convert_pulses_to_buffer(pulses) self._verify_checksum(buffer) self._humidity = buffer[0] + buffer[1] / 10 self._temperature = buffer[2] + buffer[3] / 10 self._last_measure = utime.ticks_us() @property def humidity(self): self.measure() return self._humidity @property def temperature(self): self.measure() return self._temperature def _send_init_signal(self): self._pin.init(Pin.OUT, Pin.PULL_DOWN) self._pin.value(1) utime.sleep_ms(50) self._pin.value(0) utime.sleep_ms(18) @micropython.native def _capture_pulses(self): pin = self._pin pin.init(Pin.IN, Pin.PULL_UP) val = 1 idx = 0 transitions = bytearray(EXPECTED_PULSES) unchanged = 0 timestamp = utime.ticks_us() while unchanged < MAX_UNCHANGED: if val != pin.value(): if idx >= EXPECTED_PULSES: raise InvalidPulseCount( "Got more than {} pulses".format(EXPECTED_PULSES) ) now = utime.ticks_us() transitions[idx] = now - timestamp timestamp = now idx += 1 val = 1 - val unchanged = 0 else: unchanged += 1 pin.init(Pin.OUT, Pin.PULL_DOWN) if idx != EXPECTED_PULSES: raise InvalidPulseCount( "Expected {} but got {} pulses".format(EXPECTED_PULSES, idx) ) return transitions[4:] def _convert_pulses_to_buffer(self, pulses): """Convert a list of 80 pulses into a 5 byte buffer The resulting 5 bytes in the buffer will be: 0: Integral relative humidity data 1: Decimal relative humidity data 2: Integral temperature data 3: Decimal temperature data 4: Checksum """ # Convert the pulses to 40 bits binary = 0 for idx in range(0, len(pulses), 2): binary = binary << 1 | int(pulses[idx] > HIGH_LEVEL) # Split into 5 bytes buffer = array.array("B") for shift in range(4, -1, -1): buffer.append(binary >> shift * 8 & 0xFF) return buffer def _verify_checksum(self, buffer): # Calculate checksum checksum = 0 for buf in buffer[0:4]: checksum += buf if checksum & 0xFF != buffer[4]: raise InvalidChecksum()
import array
import micropython
import utime
from machine import Pin
from micropython import const
 
class InvalidChecksum(Exception):
    pass
 
class InvalidPulseCount(Exception):
    pass
 
MAX_UNCHANGED = const(100)
MIN_INTERVAL_US = const(200000)
HIGH_LEVEL = const(50)
EXPECTED_PULSES = const(84)
 
class DHT11:
    _temperature: float
    _humidity: float
 
    def __init__(self, pin):
        self._pin = pin
        self._last_measure = utime.ticks_us()
        self._temperature = -1
        self._humidity = -1
 
    def measure(self):
        current_ticks = utime.ticks_us()
        if utime.ticks_diff(current_ticks, self._last_measure) < MIN_INTERVAL_US and (
            self._temperature > -1 or self._humidity > -1
        ):
            # Less than a second since last read, which is too soon according
            # to the datasheet
            return
 
        self._send_init_signal()
        pulses = self._capture_pulses()
        buffer = self._convert_pulses_to_buffer(pulses)
        self._verify_checksum(buffer)
 
        self._humidity = buffer[0] + buffer[1] / 10
        self._temperature = buffer[2] + buffer[3] / 10
        self._last_measure = utime.ticks_us()
 
    @property
    def humidity(self):
        self.measure()
        return self._humidity
 
    @property
    def temperature(self):
        self.measure()
        return self._temperature
 
    def _send_init_signal(self):
        self._pin.init(Pin.OUT, Pin.PULL_DOWN)
        self._pin.value(1)
        utime.sleep_ms(50)
        self._pin.value(0)
        utime.sleep_ms(18)
 
    @micropython.native
    def _capture_pulses(self):
        pin = self._pin
        pin.init(Pin.IN, Pin.PULL_UP)
 
        val = 1
        idx = 0
        transitions = bytearray(EXPECTED_PULSES)
        unchanged = 0
        timestamp = utime.ticks_us()
 
        while unchanged < MAX_UNCHANGED:
            if val != pin.value():
                if idx >= EXPECTED_PULSES:
                    raise InvalidPulseCount(
                        "Got more than {} pulses".format(EXPECTED_PULSES)
                    )
                now = utime.ticks_us()
                transitions[idx] = now - timestamp
                timestamp = now
                idx += 1
 
                val = 1 - val
                unchanged = 0
            else:
                unchanged += 1
        pin.init(Pin.OUT, Pin.PULL_DOWN)
        if idx != EXPECTED_PULSES:
            raise InvalidPulseCount(
                "Expected {} but got {} pulses".format(EXPECTED_PULSES, idx)
            )
        return transitions[4:]
 
    def _convert_pulses_to_buffer(self, pulses):
        """Convert a list of 80 pulses into a 5 byte buffer
        The resulting 5 bytes in the buffer will be:
            0: Integral relative humidity data
            1: Decimal relative humidity data
            2: Integral temperature data
            3: Decimal temperature data
            4: Checksum
        """
        # Convert the pulses to 40 bits
        binary = 0
        for idx in range(0, len(pulses), 2):
            binary = binary << 1 | int(pulses[idx] > HIGH_LEVEL)
 
        # Split into 5 bytes
        buffer = array.array("B")
        for shift in range(4, -1, -1):
            buffer.append(binary >> shift * 8 & 0xFF)
        return buffer
 
    def _verify_checksum(self, buffer):
        # Calculate checksum
        checksum = 0
        for buf in buffer[0:4]:
            checksum += buf
        if checksum & 0xFF != buffer[4]:
            raise InvalidChecksum()

 

 

code.py

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
from machine import Pin
import utime as time
from dht import DHT11, InvalidChecksum
while True:
time.sleep(1)
pin = Pin(27, Pin.OUT, Pin.PULL_DOWN)
sensor = DHT11(pin)
t = (sensor.temperature)
h = (sensor.humidity)
print("Temperature: {}".format(sensor.temperature))
print("Humidity: {}".format(sensor.humidity))
time.sleep(1)
from machine import Pin import utime as time from dht import DHT11, InvalidChecksum while True: time.sleep(1) pin = Pin(27, Pin.OUT, Pin.PULL_DOWN) sensor = DHT11(pin) t = (sensor.temperature) h = (sensor.humidity) print("Temperature: {}".format(sensor.temperature)) print("Humidity: {}".format(sensor.humidity)) time.sleep(1)
from machine import Pin
import utime as time
from dht import DHT11, InvalidChecksum
 
 
while True:
    time.sleep(1)
    pin = Pin(27, Pin.OUT, Pin.PULL_DOWN)
    sensor = DHT11(pin)
    t  = (sensor.temperature)
    h = (sensor.humidity)
    print("Temperature: {}".format(sensor.temperature))
    print("Humidity: {}".format(sensor.humidity))
    time.sleep(1)

 

 

REPL Output

>> %Run -c $EDITOR_CONTENT

Temperature: 19.2
Humidity: 48.0
Temperature: 19.2
Humidity: 48.0
Temperature: 19.3
Humidity: 48.0
Temperature: 19.5
Humidity: 48.0
Temperature: 19.3
Humidity: 49.0
Temperature: 19.7
Humidity: 50.0

 

Disclaimer

“This website contains affiliate links, meaning we may earn a commission at no extra cost to you if you make a purchase through our links.”

0 FacebookTwitterPinterestEmail
News

A Raspberry Pi Pico powered LogicAnalyzer project

by 2b4a3pico71

The LogicAnalyzer project, developed by Agustín Gimenez Bernad, transforms the Raspberry Pi Pico into a cost-effective, high-performance logic analyzer. This tool offers up to 24 digital channels with sampling rates reaching 100 million samples per second (Msps), rivaling commercial analyzers in functionality.

Hardware Configuration

At its core, the LogicAnalyzer utilizes the Raspberry Pi Pico, a microcontroller based on the RP2040 chip. The design supports both the standard Pico and the Pico W variants, enabling wireless operation without a direct physical connection to a computer.

The hardware setup is straightforward, requiring minimal additional components, which makes it accessible for hobbyists and professionals alike.

The level shifter board allows to use voltages that range from 1.6v to 5v, it is referenced by default to 5v but you can reconfigure it to accept an external reference voltage.

Also, the latest version of the analyzer board allows to daisy chain the analyzers so you can chain up to five of these and sample up to 120 channels at once, a massive ammount of channels for a logic analyzer.

Firmware Capabilities

The firmware is tailored to leverage the Pico’s capabilities, particularly its Programmable Input/Output (PIO) modules. These modules facilitate precise timing and high-speed data acquisition across multiple channels.

The firmware supports various triggering mechanisms, including edge and pattern triggers, enhancing its versatility in capturing complex digital signals.

The firmware has been built using the standard Pico SDK and Visual Studio Code. If you want to build yourself the project and don’t have the SDK installed I recommend to use the pico setup for Windows, it makes the installation a breeze and leaves everything ready to build your projects.

The firmware can be built for different boards, right now you can use the Pico, Pico W (with and without WiFi) and the RP2040 Zero.

Software Interface

Complementing the hardware and firmware is a cross-platform software application that provides a graphical user interface for visualizing and analyzing captured signals.

The software allows users to configure sampling parameters, set triggers, and interpret data efficiently.

Additionally, it offers export options compatible with other analysis tools, ensuring flexibility in data handling.

The software has been built using .net 7.0, it uses the Avalonia UI framework for the UI so the application is 100% portable.

The solution includes two executables and five libraries. The first executable “CLCapture” is the command line capture utility, it captures samples into a CSV file that can be imported into PulseView.

The second executable “LogicAnalyzer” is the main software, it’s a full fledged analyzer that allows you to see the samples, use protocol analyzers, modify the captures and even create your own digital signal files.

Next we have the “SharedDriver” library, this library is the main driver used by both applications to interact with the device, it contains the support for the USB and WiFi devices and also implements the multi-capture driver which is used to daisy-chain up to five analyzers using a single trigger.

Next we have the “SignalDescriptionLanguage” library, it implements the parser and generator for the SDL files, more info about this on the LogicAnalyzer program section. Finally there are three protocol analyzer libraries for RS-232, SPI and I2C.

Performance and Scalability

The LogicAnalyzer achieves sampling rates up to 100Msps across 24 channels, sufficient for a wide range of digital signal analysis tasks.

Recent developments indicate the potential for even higher sampling rates in burst modes, with reports of achieving up to 400Msps.

Furthermore, the design includes provisions for daisy-chaining multiple units, allowing for the simultaneous sampling of a larger number of channels, thereby enhancing its scalability for complex applications.

Community and Documentation

The project is open-source, with comprehensive documentation available on GitHub.

The repository includes detailed instructions for hardware assembly, firmware flashing, and software installation, along with troubleshooting guides and community support forums.

This openness encourages collaboration and continuous improvement from the user community.

Conclusion

Agustín Gimenez Bernad’s LogicAnalyzer project exemplifies how the Raspberry Pi Pico can be harnessed to create a powerful, affordable logic analyzer. Its combination of high sampling rates, multiple channels, and user-friendly software makes it a valuable tool for anyone involved in digital electronics debugging and analysis.

For more detailed information and access to the project’s resources, you can visit the following link and also purchase a complete board:

 

An excellent example of a practical and usable project for  The Raspberry Pi Pico, check out the links above.

0 FacebookTwitterPinterestEmail
pico 2
News

Using a Raspberry Pi Pico to perform voltage glitching attacks on microcontrollers

by 2b4a3pico71

Matthias Kesenheimer’s PicoGlitcher is an innovative, cost-effective device designed to perform voltage glitching attacks on microcontrollers using a Raspberry Pi Pico.

Voltage glitching involves introducing brief, intentional disruptions to a device’s power supply to induce faults, potentially bypassing security measures or altering normal operations.

Traditionally, such attacks required expensive equipment, but PicoGlitcher offers a budget-friendly alternative, with an estimated total cost under $33.

Hardware and Design

The PicoGlitcher utilizes the Raspberry Pi Pico, a versatile microcontroller, to execute precise voltage glitches. The hardware setup includes a MOSFET connected to the Pico’s output, enabling controlled interruptions to the target device’s power supply.

This configuration allows for high-resolution glitching, with a sampling rate below 10 nanoseconds, making it suitable for a variety of fault injection scenarios.

Software Integration

Complementing the hardware is the fault-injection-library, a Python-based toolchain developed by Kesenheimer. This library facilitates the execution of fault injection attacks by providing user-friendly functions and classes.

Users can define parameters such as glitch delay and duration, which are then communicated to the Pico running MicroPython scripts. This integration streamlines the process, making it accessible even to those with limited experience in hardware hacking.

Applications and Demonstrations

Kesenheimer demonstrated the effectiveness of PicoGlitcher during the RHME2 Fault Injection challenge, which involved extracting a hidden flag from a Microchip ATmega328P microcontroller.

By carefully adjusting the glitch parameters, he successfully induced the microcontroller to reveal the protected information, showcasing PicoGlitcher’s practical application in real-world scenarios.

Accessibility and Community Impact

One of PicoGlitcher’s significant contributions is its accessibility. By reducing the cost and complexity associated with voltage glitching attacks, it opens the field to hobbyists, educators, and researchers. The project’s open-source nature encourages community engagement, fostering further development and exploration in hardware security.

Conclusion

PicoGlitcher exemplifies how affordable hardware like the Raspberry Pi Pico can be leveraged for sophisticated tasks such as fault injection.

Its combination of low cost, high precision, and user-friendly software makes it a valuable tool for anyone interested in exploring hardware security and fault injection techniques.

For more detailed information and access to the project’s resources, you can visit the following links:

0 FacebookTwitterPinterestEmail
Pimoroni Pico Plus 2 board
Hardware

A look at the Pimoroni Pico Plus 2 board

by 2b4a3pico71

This is a board for Pimoroni that features the RP2350

Pimoroni Pico Plus 2 W is powered and programmable via USB-C and comes with an upgraded 8MB RAM, 16MB of flash storage and easy-to-read pin labels.

It’s super easy to connect up to things without soldering, with a Qwiic/STEMMA QT connector (for adding I2C sensors and breakouts), a SP/CE connector (for hooking up SPI/serial devices) and a debug connector (for if you like to program using a SWD debugger).

It also has a reset button and a BOOT button – this can also be used as a user switch.

It has some updates compared to the official Raspberry Pi offering

  • It has more storage (16 Mbyte versus 4 Mbyte)
  • It has more RAM (8 Mbyte vs 0.5 Mbyte),
  • It uses a USB-C versus micro USB
  • Integrated reset button.
  • Five extra GPIO pins are exposed which makes a total of 31 versus 26

Features

  • Powered by RP2350B (Dual Arm Cortex M33 running at up to 150MHz with 520KB of SRAM)
  • 16MB of QSPI flash supporting XiP
  • 8MB of PSRAM
  • USB-C connector for power, programming, and data transfer
  • Qw/ST (Qwiic/STEMMA QT) connector for attaching breakouts
  • Intriguing SP/CE connector
  • 3-pin debug connector (JST-SH)
  • Reset and BOOT buttons (the BOOT button can also be used as a user button)
  • User LED indicator
  • On-board 3V3 regulator (max regulator current output 600mA)
  • Input voltage range 3V – 5.5V
  • Compatible with Raspberry Pi Pico add-ons
  • Measurements: approx 53mm x 21mm x 9mm (L x W x H, including connectors)

 

Here is the pinout

You can see a 3-pin debug connector on the top-right. Below is a 4-pin connector that carries I2C, 3.3V and GND. The I2C connections are already exposed on a couple of the castellated pads, they are GPIO 4 and GPIO 5.

The castellated pads are unusual in this boards design as there are components on both sides but it may be that this was a template for a board and the parts on the underside were added later, otherwise not sure why they are like that.

I never use these but be aware of this if you do use.

Resources

Notes

  • The user LED is wired to GP25, just like on an ordinary Pico. You can blink it in exactly the same way!
  • It is also useful for putting your Pico Plus 2 into bootloader mode, and you can also use the BOOT button as a user button. It’s wired to GP45 and active low.
  • Note – the wireless is stated as experimental, read https://github.com/pimoroni/pimoroni-pico-rp2350/releases/tag/v0.0.10

 

I have 2 of these and will be trying them out, especially the networking

0 FacebookTwitterPinterestEmail
Hardware

An Audio Expansion Board for your Raspberry Pi Pico

by 2b4a3pico71

In this article we look at a speaker expansion board for your Raspberry Pi Pico.

This board has an on board speaker and also a headphone jack.

This is a picture of the board in question

Raspberry Pi Pico Speaker Expansion Board

The main audio chip on this board after closer examination was found to be a NS8002 power amplifier – not one I had ever heard of.

Here is a little bit of information about this chip

This NS8002 is a bridged audio power amplifier. When 5V working voltage, maximum drive power is 3W (3ΩBTL negative Load, THD + N <10%).

Device application circuit is simple, just a handful of peripheral devices; NS8002 output without external Coupling capacitors or bootstrap capacitors and snubber networks.

Device using SOP package, is particularly suitable for large-volume, small weight portable systems; NS8002 by Control goes into sleep mode, thereby reducing power consumption; NS8002 internal overheating Automatic shutdown protection mechanism; NS8002 work Stable.

By configuring the external resistor voltage gain amplifier can be adjusted to facilitate application.

Features

1. High output power (THD + N <10%): 3W (3Ω load)
2. Power-down mode leakage current: 0.6μA (typical)
3. High Shut Down
4. External adjustable gain
5. Wide operating voltage range 2.2V ~ 5.5V
6. Without drive output coupling capacitors, bootstrap capacitors and snubber networks
7. Using SOP package.

Product Page

Available from the link below from about $3

Raspberry PI speaker board from Aliexpress

Code Example

The code example uses pwm on GPIO15 and defines a variety of notes.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
from machine import Pin, PWM
from utime import sleep
buzzer = PWM(Pin(15))
tones = {
"B0": 31,
"C1": 33,
"CS1": 35,
"D1": 37,
"DS1": 39,
"E1": 41,
"F1": 44,
"FS1": 46,
"G1": 49,
"GS1": 52,
"A1": 55,
"AS1": 58,
"B1": 62,
"C2": 65,
"CS2": 69,
"D2": 73,
"DS2": 78,
"E2": 82,
"F2": 87,
"FS2": 93,
"G2": 98,
"GS2": 104,
"A2": 110,
"AS2": 117,
"B2": 123,
"C3": 131,
"CS3": 139,
"D3": 147,
"DS3": 156,
"E3": 165,
"F3": 175,
"FS3": 185,
"G3": 196,
"GS3": 208,
"A3": 220,
"AS3": 233,
"B3": 247,
"C4": 262,
"CS4": 277,
"D4": 294,
"DS4": 311,
"E4": 330,
"F4": 349,
"FS4": 370,
"G4": 392,
"GS4": 415,
"A4": 440,
"AS4": 466,
"B4": 494,
"C5": 523,
"CS5": 554,
"D5": 587,
"DS5": 622,
"E5": 659,
"F5": 698,
"FS5": 740,
"G5": 784,
"GS5": 831,
"A5": 880,
"AS5": 932,
"B5": 988,
"C6": 1047,
"CS6": 1109,
"D6": 1175,
"DS6": 1245,
"E6": 1319,
"F6": 1397,
"FS6": 1480,
"G6": 1568,
"GS6": 1661,
"A6": 1760,
"AS6": 1865,
"B6": 1976,
"C7": 2093,
"CS7": 2217,
"D7": 2349,
"DS7": 2489,
"E7": 2637,
"F7": 2794,
"FS7": 2960,
"G7": 3136,
"GS7": 3322,
"A7": 3520,
"AS7": 3729,
"B7": 3951,
"C8": 4186,
"CS8": 4435,
"D8": 4699,
"DS8": 4978
}
song = ["E5","G5","A5","P","E5","G5","B5","A5","P","E5","G5","A5","P","G5","E5"]
def playtone(frequency):
buzzer.duty_u16(1000)
buzzer.freq(frequency)
def bequiet():
buzzer.duty_u16(0)
def playsong(mysong):
for i in range(len(mysong)):
if (mysong[i] == "P"):
bequiet()
else:
playtone(tones[mysong[i]])
sleep(0.3)
bequiet()
playsong(song)
from machine import Pin, PWM from utime import sleep buzzer = PWM(Pin(15)) tones = { "B0": 31, "C1": 33, "CS1": 35, "D1": 37, "DS1": 39, "E1": 41, "F1": 44, "FS1": 46, "G1": 49, "GS1": 52, "A1": 55, "AS1": 58, "B1": 62, "C2": 65, "CS2": 69, "D2": 73, "DS2": 78, "E2": 82, "F2": 87, "FS2": 93, "G2": 98, "GS2": 104, "A2": 110, "AS2": 117, "B2": 123, "C3": 131, "CS3": 139, "D3": 147, "DS3": 156, "E3": 165, "F3": 175, "FS3": 185, "G3": 196, "GS3": 208, "A3": 220, "AS3": 233, "B3": 247, "C4": 262, "CS4": 277, "D4": 294, "DS4": 311, "E4": 330, "F4": 349, "FS4": 370, "G4": 392, "GS4": 415, "A4": 440, "AS4": 466, "B4": 494, "C5": 523, "CS5": 554, "D5": 587, "DS5": 622, "E5": 659, "F5": 698, "FS5": 740, "G5": 784, "GS5": 831, "A5": 880, "AS5": 932, "B5": 988, "C6": 1047, "CS6": 1109, "D6": 1175, "DS6": 1245, "E6": 1319, "F6": 1397, "FS6": 1480, "G6": 1568, "GS6": 1661, "A6": 1760, "AS6": 1865, "B6": 1976, "C7": 2093, "CS7": 2217, "D7": 2349, "DS7": 2489, "E7": 2637, "F7": 2794, "FS7": 2960, "G7": 3136, "GS7": 3322, "A7": 3520, "AS7": 3729, "B7": 3951, "C8": 4186, "CS8": 4435, "D8": 4699, "DS8": 4978 } song = ["E5","G5","A5","P","E5","G5","B5","A5","P","E5","G5","A5","P","G5","E5"] def playtone(frequency): buzzer.duty_u16(1000) buzzer.freq(frequency) def bequiet(): buzzer.duty_u16(0) def playsong(mysong): for i in range(len(mysong)): if (mysong[i] == "P"): bequiet() else: playtone(tones[mysong[i]]) sleep(0.3) bequiet() playsong(song)
from machine import Pin, PWM
from utime import sleep
buzzer = PWM(Pin(15))

tones = {
"B0": 31,
"C1": 33,
"CS1": 35,
"D1": 37,
"DS1": 39,
"E1": 41,
"F1": 44,
"FS1": 46,
"G1": 49,
"GS1": 52,
"A1": 55,
"AS1": 58,
"B1": 62,
"C2": 65,
"CS2": 69,
"D2": 73,
"DS2": 78,
"E2": 82,
"F2": 87,
"FS2": 93,
"G2": 98,
"GS2": 104,
"A2": 110,
"AS2": 117,
"B2": 123,
"C3": 131,
"CS3": 139,
"D3": 147,
"DS3": 156,
"E3": 165,
"F3": 175,
"FS3": 185,
"G3": 196,
"GS3": 208,
"A3": 220,
"AS3": 233,
"B3": 247,
"C4": 262,
"CS4": 277,
"D4": 294,
"DS4": 311,
"E4": 330,
"F4": 349,
"FS4": 370,
"G4": 392,
"GS4": 415,
"A4": 440,
"AS4": 466,
"B4": 494,
"C5": 523,
"CS5": 554,
"D5": 587,
"DS5": 622,
"E5": 659,
"F5": 698,
"FS5": 740,
"G5": 784,
"GS5": 831,
"A5": 880,
"AS5": 932,
"B5": 988,
"C6": 1047,
"CS6": 1109,
"D6": 1175,
"DS6": 1245,
"E6": 1319,
"F6": 1397,
"FS6": 1480,
"G6": 1568,
"GS6": 1661,
"A6": 1760,
"AS6": 1865,
"B6": 1976,
"C7": 2093,
"CS7": 2217,
"D7": 2349,
"DS7": 2489,
"E7": 2637,
"F7": 2794,
"FS7": 2960,
"G7": 3136,
"GS7": 3322,
"A7": 3520,
"AS7": 3729,
"B7": 3951,
"C8": 4186,
"CS8": 4435,
"D8": 4699,
"DS8": 4978
}

song = ["E5","G5","A5","P","E5","G5","B5","A5","P","E5","G5","A5","P","G5","E5"]

def playtone(frequency):
    buzzer.duty_u16(1000)
    buzzer.freq(frequency)

def bequiet():
    buzzer.duty_u16(0)

def playsong(mysong):
    for i in range(len(mysong)):
        if (mysong[i] == "P"):
            bequiet()
        else:
            playtone(tones[mysong[i]])
            sleep(0.3)
            bequiet()
playsong(song)

 

0 FacebookTwitterPinterestEmail
Raspberry Pi Pico Expansion Board Pico all gpio test board
Hardware

A Raspberry Pi Pico GPIO Test Board

by 2b4a3pico71

In this article we look at an expansion board for the Raspberry Pi Pico that I found on one of my searches online which is designed to test all of the GPIO pins of the Raspberry Pi Pico.

Its a fairly niche board, it is low cost and doesn’t really have that many use cases for most users but as always we have a look and give you couple of micropython code examples later on.

You can see this pictured below, the board contains 5 push buttons, 1 potentiometer and 20 leds connected to various GPIO pins.

 

Raspberry Pi Pico Expansion Board Pico all gpio test board

Here is an image of the pins that this board uses and the function of them, as you can see all used.

pico-all-gpio-test-pinout

This board has a couple of possible use cases

  • As a demo board , test whether the GPIO pins of Pico are working
  • As a basic expansion board, this module includes LEDs, buttons, and you can test ADC basic function.

Purchase

The board only costs about $2 from A;iexpress

Aliexpress store link

Code

There are a couple of code examples

This is a button test example, simply a case of press a button and an LED will light

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
from machine import Pin
import time
led = Pin(15, Pin.OUT)
button = Pin(12, Pin.IN, Pin.PULL_UP)
button1 = Pin(13, Pin.IN, Pin.PULL_UP)
button2 = Pin(14, Pin.IN, Pin.PULL_UP)
button3 = Pin(16, Pin.IN, Pin.PULL_UP)
button4 = Pin(17, Pin.IN, Pin.PULL_UP)
while True:
if button.value() &amp; button1.value() &amp; button2.value() &amp; button3.value() &amp; button4.value() :
led.low()
time.sleep(0.5)
elif button.value() | button1.value() | button2.value() | button3.value() | button4.value() :
led.high()
time.sleep(0.5)
from machine import Pin import time led = Pin(15, Pin.OUT) button = Pin(12, Pin.IN, Pin.PULL_UP) button1 = Pin(13, Pin.IN, Pin.PULL_UP) button2 = Pin(14, Pin.IN, Pin.PULL_UP) button3 = Pin(16, Pin.IN, Pin.PULL_UP) button4 = Pin(17, Pin.IN, Pin.PULL_UP) while True: if button.value() &amp; button1.value() &amp; button2.value() &amp; button3.value() &amp; button4.value() : led.low() time.sleep(0.5) elif button.value() | button1.value() | button2.value() | button3.value() | button4.value() : led.high() time.sleep(0.5)
from machine import Pin
import time

led = Pin(15, Pin.OUT)
button = Pin(12, Pin.IN, Pin.PULL_UP)
button1 = Pin(13, Pin.IN, Pin.PULL_UP)
button2 = Pin(14, Pin.IN, Pin.PULL_UP)
button3 = Pin(16, Pin.IN, Pin.PULL_UP)
button4 = Pin(17, Pin.IN, Pin.PULL_UP)

while True:
    if button.value() &amp; button1.value() &amp; button2.value() &amp; button3.value() &amp; button4.value() :                       
        led.low()
        time.sleep(0.5)
    elif button.value() | button1.value() | button2.value() | button3.value() | button4.value() :
        led.high()
        time.sleep(0.5)

 

This is an led test example, the LEDs will flash in sequence

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
from machine import Pin
import time
led=[28,27,1,0,22,21,3,2,20,19,5,4,15,18,7,6,11,10,9,8];
Pin(led[0], Pin.OUT)
Pin(led[1], Pin.OUT)
Pin(led[2], Pin.OUT)
Pin(led[3], Pin.OUT)
Pin(led[4], Pin.OUT)
Pin(led[5], Pin.OUT)
Pin(led[6], Pin.OUT)
Pin(led[7], Pin.OUT)
Pin(led[8], Pin.OUT)
Pin(led[9], Pin.OUT)
Pin(led[10], Pin.OUT)
Pin(led[11], Pin.OUT)
Pin(led[12], Pin.OUT)
Pin(led[13], Pin.OUT)
Pin(led[14], Pin.OUT)
Pin(led[15], Pin.OUT)
Pin(led[16], Pin.OUT)
Pin(led[17], Pin.OUT)
Pin(led[18], Pin.OUT)
Pin(led[19], Pin.OUT)
while 1:
for i in range(len(led)):
j=Pin(led[i], Pin.OUT)
Pin(led[0], Pin.OUT).low()
Pin(led[1], Pin.OUT).low()
Pin(led[2], Pin.OUT).low()
Pin(led[3], Pin.OUT).low()
Pin(led[4], Pin.OUT).low()
Pin(led[5], Pin.OUT).low()
Pin(led[6], Pin.OUT).low()
Pin(led[7], Pin.OUT).low()
Pin(led[8], Pin.OUT).low()
Pin(led[9], Pin.OUT).low()
Pin(led[10], Pin.OUT).low()
Pin(led[11], Pin.OUT).low()
Pin(led[12], Pin.OUT).low()
Pin(led[13], Pin.OUT).low()
Pin(led[14], Pin.OUT).low()
Pin(led[15], Pin.OUT).low()
Pin(led[16], Pin.OUT).low()
Pin(led[17], Pin.OUT).low()
Pin(led[18], Pin.OUT).low()
Pin(led[19], Pin.OUT).low()
time.sleep(0.1)
j.high()
time.sleep(0.1)
from machine import Pin import time led=[28,27,1,0,22,21,3,2,20,19,5,4,15,18,7,6,11,10,9,8]; Pin(led[0], Pin.OUT) Pin(led[1], Pin.OUT) Pin(led[2], Pin.OUT) Pin(led[3], Pin.OUT) Pin(led[4], Pin.OUT) Pin(led[5], Pin.OUT) Pin(led[6], Pin.OUT) Pin(led[7], Pin.OUT) Pin(led[8], Pin.OUT) Pin(led[9], Pin.OUT) Pin(led[10], Pin.OUT) Pin(led[11], Pin.OUT) Pin(led[12], Pin.OUT) Pin(led[13], Pin.OUT) Pin(led[14], Pin.OUT) Pin(led[15], Pin.OUT) Pin(led[16], Pin.OUT) Pin(led[17], Pin.OUT) Pin(led[18], Pin.OUT) Pin(led[19], Pin.OUT) while 1: for i in range(len(led)): j=Pin(led[i], Pin.OUT) Pin(led[0], Pin.OUT).low() Pin(led[1], Pin.OUT).low() Pin(led[2], Pin.OUT).low() Pin(led[3], Pin.OUT).low() Pin(led[4], Pin.OUT).low() Pin(led[5], Pin.OUT).low() Pin(led[6], Pin.OUT).low() Pin(led[7], Pin.OUT).low() Pin(led[8], Pin.OUT).low() Pin(led[9], Pin.OUT).low() Pin(led[10], Pin.OUT).low() Pin(led[11], Pin.OUT).low() Pin(led[12], Pin.OUT).low() Pin(led[13], Pin.OUT).low() Pin(led[14], Pin.OUT).low() Pin(led[15], Pin.OUT).low() Pin(led[16], Pin.OUT).low() Pin(led[17], Pin.OUT).low() Pin(led[18], Pin.OUT).low() Pin(led[19], Pin.OUT).low() time.sleep(0.1) j.high() time.sleep(0.1)
from machine import Pin
import time

led=[28,27,1,0,22,21,3,2,20,19,5,4,15,18,7,6,11,10,9,8];

Pin(led[0], Pin.OUT)
Pin(led[1], Pin.OUT)
Pin(led[2], Pin.OUT)
Pin(led[3], Pin.OUT)
Pin(led[4], Pin.OUT)
Pin(led[5], Pin.OUT)
Pin(led[6], Pin.OUT)
Pin(led[7], Pin.OUT)
Pin(led[8], Pin.OUT)
Pin(led[9], Pin.OUT)
Pin(led[10], Pin.OUT)
Pin(led[11], Pin.OUT)
Pin(led[12], Pin.OUT)
Pin(led[13], Pin.OUT)
Pin(led[14], Pin.OUT)
Pin(led[15], Pin.OUT)
Pin(led[16], Pin.OUT)
Pin(led[17], Pin.OUT)
Pin(led[18], Pin.OUT)
Pin(led[19], Pin.OUT)


while 1:
    for i in range(len(led)):
        j=Pin(led[i], Pin.OUT)
        Pin(led[0], Pin.OUT).low()
        Pin(led[1], Pin.OUT).low()
        Pin(led[2], Pin.OUT).low()
        Pin(led[3], Pin.OUT).low()
        Pin(led[4], Pin.OUT).low()
        Pin(led[5], Pin.OUT).low()
        Pin(led[6], Pin.OUT).low()
        Pin(led[7], Pin.OUT).low()
        Pin(led[8], Pin.OUT).low()
        Pin(led[9], Pin.OUT).low()
        Pin(led[10], Pin.OUT).low()
        Pin(led[11], Pin.OUT).low()
        Pin(led[12], Pin.OUT).low()
        Pin(led[13], Pin.OUT).low()
        Pin(led[14], Pin.OUT).low()
        Pin(led[15], Pin.OUT).low()
        Pin(led[16], Pin.OUT).low()
        Pin(led[17], Pin.OUT).low()
        Pin(led[18], Pin.OUT).low()
        Pin(led[19], Pin.OUT).low()
        
        
        time.sleep(0.1)
        j.high()
        time.sleep(0.1)

 

0 FacebookTwitterPinterestEmail
pir modules
Basics

A Micropython PIR example for the Raspberry Pi Pico

by 2b4a3pico71

In this example we connect a PIR module up to our Raspberry PI Pico, this is quite a simple module to connect as it requires only 3v3, Gnd and the output is ok to connect to a Pico  and does not require any level shifting.

A passive infrared sensor (PIR sensor) is an electronic sensor that measures infrared (IR) light radiating from objects in its field of view. They are most often used in PIR-based motion detectors.

Here is a typical collection of PIR detectors which can be commonly found on the internet and can be used in many projects. They all should work Ok,we have personally tested 2 of these – the large one at the top and the smaller PIR module in the middle.

There was no difference in how they worked.

pir modules

Interestingly the sensor can be adjusted using the 2 pots on it which you can see underneath

Adjust the distance potentiometer clockwise rotation, increased sensing distance (about 7 meters), on the contrary, the sensing distance decreases (about 3 meters).

Adjust the delay potentiometer clockwise rotation sensor the delay lengthened (300S), on the contrary, shorten the induction delay (5S).

pir adjust

Induction module needs a minute or so to initialize. During initializing time, it will output 0-3 times. One minute later it comes into standby.

Parts Required

The PIR is low cost and you should be able to get one for under $1

Name Link
Pico AliexpressAmazon
PIR PIR modules from Aliexpress
Connecting cables Aliexpress linkAmazon.com link

Ebay link

 

Schematic/Connection

Black for GND
Red for V+
Yellow for Output

So color coded for ease of use, this layout shows a connection to the module

rp2040 and pir

 

Code Example

I used Thonny for development, you can use any GPIO pin to connect to the PIR but you would need to alter the code below.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
from machine import Pin
import utime
from time import sleep
# Connect GP16 to PIR sensor's OUT pin), please use 3.3V connect to VCC on PIR sensor.
pir = Pin(16, Pin.IN, Pin.PULL_UP)
while True:
print(pir.value())
sleep(0.1)
from machine import Pin import utime from time import sleep # Connect GP16 to PIR sensor's OUT pin), please use 3.3V connect to VCC on PIR sensor. pir = Pin(16, Pin.IN, Pin.PULL_UP) while True: print(pir.value()) sleep(0.1)
from machine import Pin
import utime
from time import sleep

# Connect GP16 to PIR sensor's OUT pin), please use 3.3V connect to VCC on PIR sensor.
pir = Pin(16, Pin.IN, Pin.PULL_UP)


while True:
    print(pir.value())
    sleep(0.1)

 

This example has very basic output, if no object is detected then 0 is output, if an object is detected then a 1 will be outputted

Here is an adapted example with has easier to read output

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
from machine import Pin
import utime
from time import sleep
# Connect GP16 to PIR sensor's OUT pin), please use 3.3V connect to VCC on PIR sensor.
pir = Pin(16, Pin.IN, Pin.PULL_UP)
while True:
if pir():
print('Motion detected!')
sleep(5)
if not pir():
print('Motion stopped')
from machine import Pin import utime from time import sleep # Connect GP16 to PIR sensor's OUT pin), please use 3.3V connect to VCC on PIR sensor. pir = Pin(16, Pin.IN, Pin.PULL_UP) while True: if pir(): print('Motion detected!') sleep(5) if not pir(): print('Motion stopped')
from machine import Pin
import utime
from time import sleep

# Connect GP16 to PIR sensor's OUT pin), please use 3.3V connect to VCC on PIR sensor.
pir = Pin(16, Pin.IN, Pin.PULL_UP)


while True:
  if pir():
    print('Motion detected!')
    sleep(5)
    if not pir():
        print('Motion stopped')

 

Output

Here is what I saw in the REPL window

Motion detected!
Motion stopped
Motion detected!
Motion stopped

Motion detected!
Motion stopped

0 FacebookTwitterPinterestEmail
pico and rgb led
Basics

A Raspberry Pi Pico and RGB Led Example In Micropython

by 2b4a3pico71

In this article we present an RGB LED example on a Raspberry Pi Pico, rather than just use the default example to flash an LED, we will connect an RGB led up to.

Tri-color LEDs contain three different LED emitters in one case. Each emitter is connected to a separate lead so they can be controlled independently. A four-lead arrangement is typical with one common lead (anode or cathode) and an additional lead for each color.

Others, however, have only two leads (positive and negative) and have a built-in electronic controller.

I used an RGB LED module, I find this is easier than using a breadboard with an RGB led and required resistors but you construct this if you want, the layout later in the article shows how to make this.

RGB LED module

Parts List

I used an expander board with the raspberry pi pico fitted to it but you can quite easily connect and RGB led directly to the board with cables. The layout that you can see underneath in the article shows this.

Here are some basic parts

Name Link
Raspberry Pi Pico Aliexpress

Amazon
RGB Board Aliexpress
Connecting cables Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire

Layout

The schematics and layout shows 3 1K resistors, this is what my small module which you can see pictured above had built in. These are the individual components if you want to build this using individual components.

pico and rgb led

 

Code

I used the thonny IDE that supports Micropython on the Raspberry Pi Pico

The machine module is used to control on-chip hardware. This is standard on all MicroPython ports. Here we are using it to take control of a GPIO, so we can drive it high and low

We also include the utime module to bring in a basic delay

We then set the various pins to outputs like – red = Pin(18, Pin.OUT)

Now as we said this is a common anode rgb led, so to switch an individual led on you send a low (0) and to switch an led off you send a high (1). If you have a common cathode type the you need to reverse this.

So to switch the red led on you would send this – red.value(0)
To switch the red led off you would send this – red.value(1)

This first example switches all of the led off then back on again.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
from machine import Pin
import utime
red = Pin(16, Pin.OUT)
green = Pin(18, Pin.OUT)
blue = Pin(20, Pin.OUT)
while True:
red.value(1)
green.value(1)
blue.value(1)
utime.sleep(1)
red.value(0)
green.value(0)
blue.value(0)
utime.sleep(1)
from machine import Pin import utime red = Pin(16, Pin.OUT) green = Pin(18, Pin.OUT) blue = Pin(20, Pin.OUT) while True: red.value(1) green.value(1) blue.value(1) utime.sleep(1) red.value(0) green.value(0) blue.value(0) utime.sleep(1)
from machine import Pin
import utime

red = Pin(16, Pin.OUT)
green = Pin(18, Pin.OUT)
blue = Pin(20, Pin.OUT)

while True:
    red.value(1)
    green.value(1)
    blue.value(1)
    utime.sleep(1)
    
    red.value(0)
    green.value(0)
    blue.value(0)
    utime.sleep(1)

 

This example switches the red led, green led and blue led off in sequence

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
from machine import Pin
import utime
red = Pin(16, Pin.OUT)
green = Pin(18, Pin.OUT)
blue = Pin(20, Pin.OUT)
while True:
red.value(1)
green.value(1)
blue.value(1)
utime.sleep(1)
red.value(0)
green.value(1)
blue.value(1)
utime.sleep(1)
red.value(1)
green.value(0)
blue.value(1)
utime.sleep(1)
red.value(1)
green.value(1)
blue.value(0)
utime.sleep(1)
from machine import Pin import utime red = Pin(16, Pin.OUT) green = Pin(18, Pin.OUT) blue = Pin(20, Pin.OUT) while True: red.value(1) green.value(1) blue.value(1) utime.sleep(1) red.value(0) green.value(1) blue.value(1) utime.sleep(1) red.value(1) green.value(0) blue.value(1) utime.sleep(1) red.value(1) green.value(1) blue.value(0) utime.sleep(1)
from machine import Pin
import utime

red = Pin(16, Pin.OUT)
green = Pin(18, Pin.OUT)
blue = Pin(20, Pin.OUT)

while True:
    red.value(1)
    green.value(1)
    blue.value(1)
    utime.sleep(1)
    
    red.value(0)
    green.value(1)
    blue.value(1)
    utime.sleep(1)
    
    red.value(1)
    green.value(0)
    blue.value(1)    
    utime.sleep(1)
    
    red.value(1)
    green.value(1)
    blue.value(0)
    utime.sleep(1)

 

0 FacebookTwitterPinterestEmail
Newer Posts
Older Posts

Adblock Detected

Please support us by disabling your AdBlocker extension from your browsers for our website.