import time
time.sleep(0.1) # Wait for USB to become ready

print("Hello, Pi Pico!")

from Lights import *
from Sensors import *

class SensorLight(DimLight, AnalogSensor):
    def __init__(self, lightpin, sensorpin, name):
        DimLight.__init__(self, lightpin, name + " light")
        AnalogSensor.__init__(self, sensorpin, name + " sensor")

    def operate(self):
        v = self.rawValue()
        brightness = int(v / 255)
        self.setBrightness(brightness)

l = SensorLight(lightpin =8, sensorpin = 27, name = 'Bathroom')
while True:
    l.operate()
    time.sleep(0.5)

main.py

diagram.json

"""
# Sensors.py
# A simple Sensor hierarchy for digital and analog sensors
# Added support for Ultrasonic Sensor on 9/11/23
# Added support for DHT11/DHT22 sensor on 6/14/24
# Author: Arijit Sengupta
"""

from machine import Pin, ADC
import utime
import math
import dht
from Log import *

class Sensor:
    """
    The top level sensor class - assume each sensor uses 
    at least one pin. We do not create the IO here because
    some sensors may use Analog inputs
    
    Parameters
    --------
    pin: pin number where the sensor is connected
    lowActive: set to True if the sensor gets low (or under threshold)
    when tripped. So an analog light sensor should normally get a high
    value but when covered, go low. So lowActive should be True
    
    A force sensor would be opposite - tripped when force gets high
    so lowActive should be False
    """
    
    def __init__(self, pin, name='Sensor', lowActive = True):
        self._pin = pin
        self._lowActive = lowActive
        self._name = name
        
    def tripped(self)->bool:
        Log.e(f"tripped not implemented for {type(self).__name__} {self._name}")
        return False

class DigitalSensor(Sensor):
    """
    A simple digital sensor (like the commonly available LC-393 that is a light sensor)
    has a digital output that flips based on a manual threshold control

    We are just going to poll this to keep things simple
    """
    
    def __init__(self, pin, name='Digital Sensor', lowActive=True):
        super().__init__(pin, name, lowActive)
        self._pinio = Pin(self._pin, Pin.IN)

    def tripped(self)->bool:
        v = self._pinio.value()
        if (self._lowActive and v == 0) or (not self._lowActive and v == 1):
            Log.i(f"DigitalSensor {self._name}: sensor tripped")
            return True
        else:
            return False
        
class TiltSensor(DigitalSensor):
    """
    A tilt sensor looks like a cap but has just a metal ball on two contacts
    when you tilt, the ball rolls off and the contact opens. That way its very
    much like a button which is always pressed.
    """
    
    def __init__(self, pin, name='Tilt Sensor'):
        # Init - do not call the super init - just create the Pin.
        super().__init__(pin, name)
        self._pinio = Pin(pin, Pin.IN, Pin.PULL_UP)
        
    def tripped(self):
        if self._pinio.value() == 1:
            Log.i(f"TiltSensor {self._name}: sensor tripped")
            return True
        else:
            return False

class AnalogSensor(Sensor):
    """
    A simple analog sensor that returns a voltage or voltage ratio output
    that can be read in using an ADC. Pico reads in via a 16bit unsigned

    We are just going to poll this to keep things simple
    """
    
    def __init__(self, pin, name='Analog Sensor', lowActive=True, threshold = 30000):
        """ analog sensors will need to be sent a threshold value to detect trip """
        
        super().__init__(pin, name, lowActive)
        self._pinio = ADC(self._pin)
        self._threshold = threshold

    def tripped(self)->bool:
        """ sensor is tripped if sensor value is higher or lower than threshold """
        
        v = self.rawValue()
        if (self._lowActive and v < self._threshold) or (not self._lowActive and v > self._threshold):
            Log.i(f"AnalogSensor {self._name}: sensor tripped")
            return True
        else:
            return False

    def rawValue(self):
        return self._pinio.read_u16()

class TempSensor(AnalogSensor):
    """
    Temperature sensor as a subclass of Analog Sensor - Temp sensor is a bit more
    defined since it technically returns a temperature. Note that thermistors are
    not totally accurate, but the teperature fluctuations - increases and decreases
    are what matters.
    """
    
    def __init__(self, pin, name='Temp Sensor', lowActive=False, threshold=60):
        """
        Create a new temp sensor - similar to regular analog sensor
        but now tripped will return true when temp is lower than threshold (lowActive=True)
        and higher than threshold (lowActive=False)
        """
        
        super().__init__(pin, name, lowActive, threshold)
        
    def rawValue(self):
        """
        Reture the temperature (approx) in fahrenheit
        """
        
        adcvalue = super().rawValue()
        voltage = adcvalue / 65535.0 * 5
        Rt = 10 * voltage / (5 -voltage)
        tempK = (1 / (1 / (273.15+25) + (math.log(Rt/10)) / 3950))
        tempF = int((tempK - 273.15) * 1.8) + 32
        return tempF
        
class UltrasonicSensor(Sensor):
    """
    A simple implementation of an ultrasonic sensor with digital IO
    pins for trigger and echo.
    
    While technically Ultrasonic sensor is not an analog sensor since it
    uses digital pins, it does have continuous data, so subclassing
    AnalogSensor makes more sense. But given AnalogSensor should only be
    used in ADC pins, it is better to subclass the Sensor superclass.
    
    Continuing to use the lowActive and threshold like AnalogSensor however.

    init by sending trigger, echo and optionally lowActive and threshold
    parameters. Threshold defaults to 10cm, and lowActive defaults to true
    so when distance is < 10cm, it will return true for tripped.
    """

    def __init__(self, *, trigger=0, echo=1, name='Ultrasonic', lowActive = True, threshold=10.0):
        super().__init__(trigger, name, lowActive)
        self._trigger = Pin(trigger, Pin.OUT)
        self._echo = Pin(echo, Pin.IN)
        self._threshold = threshold

    def getDistance(self)->float:
        """ Get the distance of obstacle from the sensor in cm """
        
        self._trigger.off()
        utime.sleep_us(2)
        self._trigger.on()
        utime.sleep_us(5)
        self._trigger.off()
        while self._echo.value() == 0:
            signaloff = utime.ticks_us()
        while self._echo.value() == 1:
            signalon = utime.ticks_us()
        timepassed = signalon - signaloff
        distance = (timepassed * 0.0343) / 2
        return distance

    def tripped(self)->bool:
        """ sensor is tripped if distance is higher or lower than threshold """
        
        v = self.getDistance()
        if (self._lowActive and v < self._threshold) or (not self._lowActive and v > self._threshold):
            Log.i(f"UltrasonicSensor {self._name}: sensor tripped")
            return True
        else:
            return False

# DHT11/DHT22 Sensor
class DHTSensor(DigitalSensor):
    def __init__(self, pin, name='DHT', lowActive=False, threshold=60, poll_delay=2000, sensor_type='DHT11'):
        """
        Create a new DHT sensor - similar to regular digital sensor but can take
        either the form of a DHT11 or DHT22 based on the sensor_type parameter

        DHT11 is less accurate but cheaper, DHT22 is more accurate but more expensive

        Note that the DHT sensor is a digital sensor but it returns two values - temperature
        and humidity. So we subclass DigitalSensor but override the rawValue method

        Also, the DHT sensor is a bit slow, so we will not poll it as frequently as other sensors.
        To avoid to much polling, a default poll parameter is set to 2 seconds.

        The threshold is set to 60F by default, but can be changed. This is used to determine
        if the sensor is tripped or not. Only the temperature is used for tripping.
        """
        
        super().__init__(pin, name, lowActive)
        self._sensor_type = sensor_type
        self._sensor_class = dht.DHT11 if sensor_type == "DHT11" else dht.DHT22
        self._dht_sensor = self._sensor_class(Pin(self._pin))
        self._last_poll_time = 0
        self._poll_delay = poll_delay
        self._threshold = threshold

    def getTemperature(self):
        """
        Return the temperature of the sensor
        """
        
        if utime.ticks_ms() - self._last_poll_time > self._poll_delay:
            self._dht_sensor.measure()
        self._last_poll_time = utime.ticks_ms()
        return self._dht_sensor.temperature()

    def getHumidity(self):
        """
        Return the humidity of the sensor
        """
        
        if utime.ticks_ms() - self._last_poll_time > self._poll_delay:
            self._dht_sensor.measure()
        self._last_poll_time = utime.ticks_ms()
        return self._dht_sensor.humidity()

    def rawValue(self):
        """
        Returns a tuple of temperature and humidity
        """
        
        if utime.ticks_ms() - self._last_poll_time > self._poll_delay:
            self._dht_sensor.measure()
        self._last_poll_time = utime.ticks_ms()
        return (self._dht_sensor.temperature(), self._dht_sensor.humidity())

    def tripped(self)->bool:
        """
        Sensor is tripped if temperature is higher or lower than threshold
        """
        
        if self._lowActive:
            return self.getTemperature() < self._threshold
        else:
            return self.getTemperature() >= self._threshold


Sensors.py

"""
# Lights.py
# implementation of different types of lights
# both digitally controlled (on/off)
# or PWM-controlled (dimming) to set brightness
# Author: Arijit Sengupta
"""

import utime
from machine import Pin, PWM
from Log import *
import _thread
MAX = 65535

baton = _thread.allocate_lock()

class Light:
    """
    The Light base class - just an LED controlled by a digital IO
    Pin. Save the pin in an instance variable
    """
    
    def __init__(self, pin, name="Unnamed"):
        """
        Light constructor - save the pin and set it to OUTPUT mode
        pin is the NUMBER of the pin that the LED is connected to. So
        if connecting to GP21, pass the value 21 to pin        
        name is an optional name of the light
        """
            
        Log.i(f"Light: constructor")
        self._name = name
        self._pin = pin
        self._blinking = False
        self._led = Pin(self._pin, Pin.OUT)  # We need this to use the IO functions

    def on(self):
        """ on: Turn the light on """
        
        Log.i(f"Light: turning on {self._name} light at pin {self._pin}")
        self._led.value(1)

    def off(self):
        """ off: turn the light off """
        
        Log.i(f"Light: turning off {self._name} light at pin {self._pin}")
        self._led.value(0)

    def flip(self):
        """ flip: turn off if it was on, on if it was off """
        
        Log.i(f"Light: Toggling {self._name} light at pin {self._pin}")
        self._led.toggle()

    def blink(self, delay=0.5, times=1):
        """ blink: turn on for delay sec, off for delay sec [times] times"""

        Log.i(f"Light: Blink {self._name} {times} times for {delay} sec")
        for x in range(0,times):
            self.on()
            utime.sleep(delay)
            self.off()
            utime.sleep(delay)


class DimLight(Light):
    """
    The Dimmable Light subclass - will have the standard on off methods
    and in addition will have the ability to set brightness
    """

    def __init__(self, pin, name="Unnamed"):
        """ Dimmable light constructor """

        Log.i("Dimmable light constructor")
        super().__init__(pin, name)
        self._pwm = PWM(self._led)  # Create an instance of PWM object (pulse-width modulation)
        self._pwm.freq(100000)   # set frequency to 100 khz
        self._onState = False
        self._running = False

    def on(self):
        """ Turn on - full brightness max is 255 """
        
        self._running = False
        self._onState = True
        Log.i(f"Dimlight: turn Light {self._name} on (full brightness)")
        self.setBrightness(MAX)

    def off(self):
        """  Turn off - set brightness to 0 """
        
        self._running = False
        self._onState = False
        Log.i(f"Dimlight - turn Light {self._name} off (brightness 0)")
        self.setBrightness(0)

    def flip(self):
        """ flip: turn off if it was on, on if it was off """
        
        Log.i(f"Light: Toggling {self._name} light at pin {self._pin}")
        if self._onState:
            self.off()
        else:
            self.on()       
        
    def setBrightness(self, brightness):
        """ Set brightness to a specific level 0-255 """

        Log.i(f"Dimlight: setting Light {self._name} brightness to {brightness}")
        if (brightness == MAX):
            self._pwm.duty_u16(MAX)
        else:
            self._pwm.duty_u16(brightness * brightness)
        
        if brightness < 50:
            self._onState = False
        else:
            self._onState = True

    def upDown(self):
        """
        # Do a quick demo of going up and down full brightness levels
        # Here it is better to use ChangeDutyCycle
        """
        
        Log.i(f"Dimlight: do an up-down demo on Light {self._name}")
        self._running = True
        dc = 0
        for i in range (0, 25):
            if not self._running:
                break
            dc += 10
            self.setBrightness(dc)
            utime.sleep_ms(100)

        for i in range (0, 25):
            if not self._running:
                break
            dc -= 10
            self.setBrightness(dc)
            utime.sleep_ms(100)
        self._running = False

Lights.py

"""
Log.py - a simplistic Logging process. Built to kind of mimic the
Android Logging process, but at the same time having a global level
set to see the types of logs being displayed.

Basic usage:

Log.level = DEBUG  # set global log level

# Options are: ALL/INFO (everything) DEBUG (debug and higher), ERRO (only errors)
Log.i(f'help')     # Info message: f-strings recommended for showing variables
Log.d(f'value: {v}') # Debug message
Log.e(f'Exception: {x}') # Error message
Log.name('Myproject') # Set a global project name
"""

""" Debug levels """
ALL = 4  # All messages are displayed
INFO = 3  # Basically the same as ALL - for future-proofing
DEBUG = 2  # Info is hidden - debug and higher shown
ERROR = 1  # Only error messages shown
NONE = 0  # No messages are shown from log classes


class Log:

    name = ''
    level = ALL

    @classmethod
    def i(cls, message):
        if (cls.level >= INFO):
            Log.pr(message)

    @classmethod
    def d(cls, message):
        if (cls.level >= DEBUG):
            Log.pr(message)

    @classmethod
    def e(cls, message):
        if (cls.level >= ERROR):
            Log.pr(message)

    @classmethod
    def pr(cls, message):
        if cls.name:
            m = cls.name + ": " + message
        else:
            m = message
        print(m)


if __name__ == '__main__':
    print("Hello")
    Log.level = ALL
    Log.name = 'Test'
    Log.i(f'This should print (level: {Log.level})')
    
    Log.level = ERROR
    Log.i(f'This should NOT print (level: {Log.level})')
    Log.e(f'This should print (level: {Log.level})')
    

