# Welcome to The Bin! 🦝

Now that you've thrown some parts into The Bin, it's time to turn that trash into treasure! 🗑️➡️💎

Wire up your parts and write some code to make them work together. If you need
help with a part, click the "?" above it.

If you want to see examples, check here:
https://hack.club/bin-example

You can get help by chatting with other high schoolers on the Hack Club Slack in
the #electronics channel:
👉 https://hackclub.com/slack 👈

Once you're ready build your design IRL, click the "Share" button and submit
your design:
https://hack.club/bin-submit
    

help.md

diagram.json

picozero.py

from machine import Pin, SPI, SoftI2C, ADC
from speaker_machine import c_note, d_note
import max7219
from pico_dht_22 import PicoDHT22
import ssd1306
from keypad import loop_keypad
from buzzer_music import music
#import joypad
#from joypad import joy, write_joy_vars
from rotary_irq_rp2 import RotaryIRQ
import time
import machine, neopixel

song = '4 F#5 1 1;0 D5 1 1;2 E5 1 1;8 A5 1 1;12 F#5 1 1;16 E5 1 1;20 D5 1 1;32 F#5 1 1;34 A5 1 1;36 B5 1 1;40 D6 1 1;44 C#6 1 1;48 A5 1 1;52 F#5 1 1;60 E5 1 1;64 D5 1 1;66 E5 1 1;68 F#5 1 1;72 A5 1 1;76 F#5 1 1;80 E5 1 1;84 D5 1 1;96 F#5 1 1;98 A5 1 1;100 B5 1 1;116 E5 1 1;110 B5 1 1;112 A5 1 1;114 F#5 1 1;4 D3 1 5;12 F#3 1 5;20 G3 1 5;28 F#3 1 5;36 G3 1 5;44 A3 1 5;52 F#3 1 5;60 E3 1 5;68 D3 1 5;76 F#3 1 5;84 G3 1 5;92 F#3 1 5;100 G3 1 5;108 F#3 1 5;116 E3 1 5;4 D5 1 1;4 A4 1 1;12 C#5 1 1;12 A4 1 1;20 B4 1 1;20 G4 1 1;28 A4 1 1;28 F#4 1 1;36 D5 1 1;36 G5 1 1;44 E5 1 1;44 A5 1 1;52 D5 1 1;52 A4 1 1;60 C#5 1 1;60 A4 1 1;68 A4 1 1;68 D5 1 1;76 A4 1 1;76 C#5 1 1;84 B4 1 1;84 G4 1 1;92 F#4 1 1;92 A4 1 1;100 D5 1 1;100 G5 1 1;108 D5 1 1;108 F#5 1 1;124 E4 1 1;116 A4 1 1;116 C#5 1 1;124 C5 1 1;124 G4 1 1;132 D5 1 1;134 E5 1 1;136 F#5 1 1;132 D4 1 1;132 F#4 1 1;132 B4 1 1;140 E4 1 1;140 A4 1 1;140 C#5 1 1;156 C#5 1 1;156 A4 1 1;156 E4 1 1;148 D5 1 1;148 B4 1 1;148 F#4 1 1;162 C#6 1 1;158 F#5 1 1;160 B5 1 1;164 D6 1 1;164 G3 1 5;172 A3 1 5;188 E3 1 5;164 B5 1 1;164 G5 1 1;172 C#6 1 1;172 E5 1 1;172 A5 1 1;176 A5 1 1;180 D3 1 5;180 D5 1 1;180 F#5 1 1;180 A4 1 1;188 A4 1 1;188 C#5 1 1;188 E5 1 1;194 E5 1 1;192 D5 1 1;196 F#5 1 1;196 D3 1 5;204 E3 1 5;212 G3 1 5;196 F#4 1 1;196 B4 1 1;204 A4 1 1;204 C#5 1 1;220 F#3 1 5;212 B4 1 1;212 D5 1 1;220 C#5 1 1;220 A4 1 1;222 F#5 1 1;224 B5 1 1;226 C#6 1 1;228 D6 1 1;228 G3 1 5;236 A3 1 5;244 B3 1 5;228 B5 1 1;228 G5 1 1;236 E6 1 1;236 C#6 1 1;236 A5 1 1;242 D6 1 1;243 E6 1 1;244 F#6 1 1;244 B5 1 1;244 D6 1 1;252 G3 1 5;260 D4 1 1;256 B5 1 1;254 D6 1 1;258 D6 1 1;264 D4 1 1;268 D4 1 1;272 D4 1 1;262 A4 1 1;262 F#4 1 1;266 A4 1 1;266 F#4 1 1;270 A4 1 1;270 F#4 1 1;274 A4 1 1;274 F#4 1 1;260 D6 1 11;261 E6 1 11;262 F#6 1 11;270 F#6 1 11;274 F#6 1 11;278 A4 1 1;278 C#5 1 1;276 C#4 1 1;280 C#4 1 1;284 C#4 1 1;288 C#4 1 1;282 A4 1 1;286 A4 1 1;290 A4 1 1;290 C#5 1 1;286 C#5 1 1;282 C#5 1 1;276 A6 1 11;278 E6 1 11;280 D6 1 11;282 E6 1 11;277 B6 1 11;277 A6 1 11;294 C#6 1 11;292 A5 1 11;293 B5 1 11;292 B3 1 1;296 B3 1 1;300 B3 1 1;304 B3 1 1;308 G3 1 1;312 G3 1 1;316 A3 1 1;320 A3 1 1;294 D4 1 1;298 D4 1 1;302 D4 1 1;306 D4 1 1;310 D4 1 1;314 D4 1 1;318 E4 1 1;322 E4 1 1;294 F#4 1 1;298 F#4 1 1;302 F#4 1 1;306 F#4 1 1;310 B3 1 1;314 B3 1 1;322 C#4 1 1;298 C#6 1 11;302 D6 1 11;306 B5 1 11;308 F#5 1 11;314 A5 1 11;316 E5 1 11;318 C#4 1 1;294 C#6 1 11;292 A5 1 11;293 B5 1 11;298 C#6 1 11;302 D6 1 11;306 B5 1 11;308 F#5 1 11;314 A5 1 11;316 E5 1 11;260 D6 1 11;261 E6 1 11;262 F#6 1 11;270 F#6 1 11;274 F#6 1 11;276 A6 1 11;278 E6 1 11;280 D6 1 11;282 E6 1 11;277 B6 1 11;277 A6 1 11;132 D3 1 5;140 E3 1 5;156 E3 1 5;124 C3 1 5;148 F#3 1 5;324 A3 1 1;328 A5 1 11;330 C#6 1 11;333 E6 1 11;334 F#6 1 11;332 D4 1 1;336 D4 1 1;340 D4 1 1;344 D4 1 1;334 A4 1 1;334 F#4 1 1;338 F#4 1 1;342 F#4 1 1;346 F#4 1 1;346 A4 1 1;342 A4 1 1;338 A4 1 1;338 F#6 1 11;346 A6 1 11;348 F#6 1 11;348 G3 1 1;352 G3 1 1;356 A3 1 1;360 A3 1 1;350 D4 1 1;354 D4 1 1;358 E4 1 1;362 E4 1 1;354 B3 1 1;350 B3 1 1;358 C#4 1 1;362 C#4 1 1;350 E6 1 11;354 D6 1 11;356 E6 1 11;349 G6 1 11;349 F#6 1 11;358 C#6 1 11;332 D6 1 11;328 A5 1 11;330 C#6 1 11;333 E6 1 11;334 F#6 1 11;338 F#6 1 11;346 A6 1 11;348 F#6 1 11;350 E6 1 11;354 D6 1 11;356 E6 1 11;349 G6 1 11;349 F#6 1 11;358 C#6 1 11;332 D6 1 11;362 C#6 1 11;363 D6 1 11;364 C#6 1 11;364 D6 1 11;365 E6 1 11;366 F#6 1 11;364 D5 1 10;365 E5 1 10;366 F#5 1 10;364 B3 1 1;366 D4 1 1;366 F#4 1 1;368 B3 1 1;372 B3 1 1;376 B3 1 1;378 D4 1 1;374 D4 1 1;370 D4 1 1;370 F#4 1 1;374 F#4 1 1;378 F#4 1 1;377 F#6 1 11;377 F#5 1 10;378 B6 1 11;379 C#7 1 11;380 D7 1 11;380 D6 1 10;378 B5 1 10;379 C#6 1 10;380 G3 1 1;384 G3 1 1;388 G3 1 1;392 G3 1 1;362 C#6 1 11;363 D6 1 11;364 C#6 1 11;364 D6 1 11;365 E6 1 11;366 F#6 1 11;364 D5 1 10;365 E5 1 10;366 F#5 1 10;377 F#6 1 11;377 F#5 1 10;378 B6 1 11;379 C#7 1 11;380 D7 1 11;380 D6 1 10;378 B5 1 10;379 C#6 1 10;382 B3 1 1;382 D4 1 1;386 D4 1 1;390 D4 1 1;394 D4 1 1;394 B3 1 1;390 B3 1 1;386 B3 1 1;386 C#7 1 11;386 C#6 1 10;386 C#6 1 10;386 C#7 1 11;394 A6 1 11;394 A5 1 10;394 A5 1 10;394 A6 1 11;396 A3 1 1;398 C#4 1 1;398 E4 1 1;402 E4 1 1;406 E4 1 1;410 E4 1 1;410 C#4 1 1;406 C#4 1 1;402 C#4 1 1;400 A3 1 1;404 A3 1 1;408 A3 1 1;396 F#6 1 11;402 G6 1 11;403 F#6 1 11;404 E6 1 11;396 F#6 1 11;402 G6 1 11;403 F#6 1 11;404 E6 1 11;396 F#5 1 10;396 F#5 1 10;402 G5 1 10;402 G5 1 10;403 F#5 1 10;403 F#5 1 10;404 E5 1 10;404 E5 1 10;410 D6 1 11;411 E6 1 11;410 D6 1 11;411 E6 1 11;410 D5 1 10;410 D5 1 10;411 E5 1 10;411 E5 1 10;412 F#6 1 11;412 F#5 1 10;412 F#5 1 10;412 F#6 1 11;412 B3 1 1;416 B3 1 1;420 B3 1 1;424 B3 1 1;414 D4 1 1;414 F#4 1 1;418 F#4 1 1;422 F#4 1 1;426 F#4 1 1;426 D4 1 1;422 D4 1 1;418 D4 1 1;424 F#6 1 11;424 F#5 1 10;424 F#5 1 10;424 F#6 1 11;426 F#6 1 11;427 G6 1 11;426 F#5 1 10;427 G5 1 10;426 F#5 1 10;427 G5 1 10;426 F#6 1 11;427 G6 1 11;428 A3 1 1;432 A3 1 1;436 A3 1 1;440 A3 1 1;430 C#4 1 1;430 E4 1 1;434 E4 1 1;438 E4 1 1;442 E4 1 1;442 C#4 1 1;438 C#4 1 1;434 C#4 1 1;428 A6 1 11;428 A5 1 10;428 E6 1 11;428 E6 1 11;428 A6 1 11;428 A5 1 10;436 E6 1 11;436 C#6 1 11;436 E5 1 10;436 E5 1 10;436 C#6 1 11;436 E6 1 11;444 D5 1 10;444 D6 1 11;444 D4 1 1;444 D5 1 10;444 D6 1 11;445 E6 1 11;446 F#6 1 11;445 E5 1 10;446 F#5 1 10;445 E5 1 10;446 F#5 1 10;445 E6 1 11;446 F#6 1 11;448 D4 1 1;452 D4 1 1;456 D4 1 1;446 F#4 1 1;446 A4 1 1;450 A4 1 1;454 A4 1 1;458 A4 1 1;458 F#4 1 1;454 F#4 1 1;450 F#4 1 1;454 F#6 1 11;454 F#5 1 10;454 F#5 1 10;454 D6 1 11;454 D6 1 11;454 F#6 1 11;458 F#6 1 11;458 D6 1 11;458 F#5 1 10;458 D6 1 11;458 F#6 1 11;460 E6 1 11;461 F#6 1 11;462 G#6 1 11;460 E6 1 11;461 F#6 1 11;462 G#6 1 11;460 E5 1 10;461 F#5 1 10;462 G#5 1 10;461 F#5 1 10;462 G#5 1 10;460 E4 1 1;462 G#4 1 1;462 B4 1 1;466 B4 1 1;470 B4 1 1;474 B4 1 1;474 G#4 1 1;470 G#4 1 1;466 G#4 1 1;464 E4 1 1;468 E4 1 1;472 E4 1 1;466 G#6 1 11;470 G#6 1 11;474 G#6 1 11;466 G#5 1 10;470 G#5 1 10;474 G#5 1 10;466 E6 1 11;470 E6 1 11;474 E6 1 11;466 G#6 1 11;470 G#6 1 11;474 G#6 1 11;466 G#5 1 10;474 G#5 1 10;466 E6 1 11;470 E6 1 11;474 E6 1 11;476 F#4 1 1;476 F#5 1 10;476 F#6 1 11;477 G#6 1 11;478 A#6 1 11;477 G#5 1 10;478 A#5 1 10;476 F#5 1 10;477 G#5 1 10;478 A#5 1 10;476 F#6 1 11;477 G#6 1 11;478 A#6 1 11;478 A#4 1 1;478 C#5 1 1;480 F#4 1 1;482 A#4 1 1;482 C#5 1 1;484 F#4 1 1;484 A#4 1 1;484 C#5 1 1;484 F#5 1 1;484 A#5 1 10;484 F#6 1 11;484 A#6 1 11;486 A#6 1 11;486 F#6 1 11;486 A#5 1 10;486 F#5 1 1;486 C#5 1 1;486 A#4 1 1;486 F#4 1 1;490 A#6 1 11;491 A#6 1 11;492 A#6 1 11;490 F#6 1 11;491 F#6 1 11;492 F#6 1 11;490 A#5 1 10;491 A#5 1 10;492 A#5 1 10;490 F#5 1 1;491 F#5 1 1;492 F#5 1 1;490 C#5 1 1;491 C#5 1 1;492 C#5 1 1;490 A#4 1 1;491 A#4 1 1;492 A#4 1 1;490 F#4 1 1;491 F#4 1 1;492 F#4 1 1;484 F#4 1 1;484 A#4 1 1;484 C#5 1 1;484 F#5 1 1;484 A#5 1 10;484 F#6 1 11;484 A#6 1 11;486 A#6 1 11;486 F#6 1 11;486 A#5 1 10;486 F#5 1 1;486 C#5 1 1;486 A#4 1 1;486 F#4 1 1;490 A#6 1 11;491 A#6 1 11;492 A#6 1 11;490 F#6 1 11;491 F#6 1 11;492 F#6 1 11;490 A#5 1 10;491 A#5 1 10;492 A#5 1 10;490 F#5 1 1;491 F#5 1 1;492 F#5 1 1;490 C#5 1 1;491 C#5 1 1;492 C#5 1 1;490 A#4 1 1;491 A#4 1 1;492 A#4 1 1;490 F#4 1 1;491 F#4 1 1;492 F#4 1 1;256 B5 1 11;254 D6 1 11;258 D6 1 11;260 D3 1 5;264 D3 1 5;268 D3 1 5;272 D3 1 5;276 C#3 1 5;280 C#3 1 5;284 C#3 1 5;288 C#3 1 5;292 B2 1 5;296 B2 1 5;300 B2 1 5;304 B2 1 5;308 G2 1 5;312 G2 1 5;316 A2 1 5;320 A2 1 5;332 D3 1 5;336 D3 1 5;340 D3 1 5;344 D3 1 5;348 G2 1 5;352 G2 1 5;356 A2 1 5;360 A2 1 5;364 B2 1 5;368 B2 1 5;372 B2 1 5;376 B2 1 5;380 G2 1 5;384 G2 1 5;388 G2 1 5;392 G2 1 5;396 A2 1 5;400 A2 1 5;404 A2 1 5;408 A2 1 5;412 B2 1 5;416 B2 1 5;420 B2 1 5;424 B2 1 5;428 A2 1 5;432 A2 1 5;436 A2 1 5;440 A2 1 5;444 D3 1 5;448 D3 1 5;452 D3 1 5;456 D3 1 5;460 E3 1 5;464 E3 1 5;468 E3 1 5;472 E3 1 5;476 F#3 1 5;480 F#3 1 5;484 F#3 1 5;486 F#3 1 5;490 F#3 1 5;491 F#3 1 5;492 F#3 1 5'

dht_sensor=PicoDHT22(Pin(15,Pin.IN,Pin.PULL_UP),dht11=False)
#You can choose any other combination of I2C pins
i2c = SoftI2C(scl=Pin(19), sda=Pin(18))

oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

#Find a piece of music on onlinesequencer.net, click edit,
#then select all notes with CTRL+A and copy them with CTRL+C

#Paste string as shown above after removing ";:" from
#the end and "Online Sequencer:120233:" from the start

#One buzzer on pin 14
mySong = music(song, pins=[Pin(14)])

#Intialize the SPI
spi = SPI(0, baudrate=10000000, polarity=1, phase=0, sck=Pin(2), mosi=Pin(3))
ss = Pin(5, Pin.OUT)

# Create matrix display instant, which has four MAX7219 devices.
display = max7219.Matrix8x8(spi, ss, 1)

#Set the display brightness. Value is 1 to 15.
display.brightness(10)

#Define the scrolling message
scrolling_message = "SUPERFUN SOUND & LIGHT PLAYGROUND -- BY PONDERSLIME!"

#Get the message length
length = len(scrolling_message)

#Calculate number of columns of the message
column = (length * 8)

#Clear the display.
display.fill(0)
display.show()

#sleep for one one seconds
time.sleep(1)
scroll_ammt = 32

np = neopixel.NeoPixel(machine.Pin(0), 1)
np[0] = (255, 0, 0) # set to red, full brightness
np.write()


SW = Pin(22,Pin.IN,Pin.PULL_UP)  

r = RotaryIRQ(pin_num_clk=20,
              pin_num_dt=17,
              min_val=0,
              reverse=False,
              range_mode=RotaryIRQ.RANGE_UNBOUNDED)
val_old = r.value()


#c_note()
#main()
xAxis = ADC(Pin(27))
yAxis = ADC(Pin(26))

button = Pin(1,Pin.IN, Pin.PULL_UP)
def joy():
    xValue = xAxis.read_u16()
    yValue = yAxis.read_u16()
    buttonValue= button.value()
    print(str(xValue) +", " + str(yValue) + " -- " + str(buttonValue))
    #utime.sleep(0.1)

    xStatus = "middle"
    yStatus = "middle"
    buttonStatus = "not pressed"

    if xValue <= 600:
        xStatus = "left"
        np[0] = (68, 122, 133) # set to my favorite shade of blue, full brightness
        np.write()
        #c_note()
    elif xValue >= 60000:
        xStatus = "right"
        np[0] = (191, 73, 146) # set to deep pink, full brightness
        np.write()
        #c_note()
    if yValue <= 600:
        yStatus = "up"
        np[0] = (191, 163, 73) # set to pale orange, full brightness
        np.write()
        #c_note()
    elif yValue >= 60000:
        yStatus = "down"
        np[0] = (79, 191, 73) # set to light green, full brightness
        np.write()
        #c_note()
    if buttonValue == 0:
        buttonStatus = "pressed"
        np[0] = (166, 73, 191) # set to purple, full brightness
        np.write()
        d_note()

    print("X: " + xStatus + ", Y: " + yStatus + " -- button " + buttonStatus)

while True:
  scroll_ammt -= 1
  loop_keypad()
  joy()
  print(mySong.tick())
  T,H = dht_sensor.read()
  if T is None:
      continue
      print(" sensor error")
      #d_note()
  else:
    print("{}'C  {}%".format(T,H))
    oled.fill(0)
    oled.text(str('H: ' +"{:0.2f}".format(H)+ "  %",2),40,5)
    oled.text(str('T: ' +"{:0.2f}".format(T)+ "  C",2),40,19)
    oled.show()
    #time.sleep_ms(5000)
  time.sleep(0.04)
  
  if scroll_ammt in range(32, -column, -1):
      display.fill(0)

          # Write the scrolling text in to frame buffer
      display.text(scrolling_message ,scroll_ammt,0,1)
          
          #Show the display
      display.show()
      
          #Set the Scrolling speed. Here it is 50mS.
      #time.sleep(0.05)
  else:
        scroll_ammt = 32
  try:  
    val_new = r.value()  
    if SW.value()==0 and n==0:  
        print("Button Pressed")  
        print("Selected Number is : ",val_new)
        #c_note()
        np[0] = (255, 255, 0) # set to yellow, full brightness
        np.write()
        n=1 
        while SW.value()==0:  
            continue  
    n=0  
    if val_old != val_new:  
        val_old = val_new  
        print('result =', val_new)
        #c_note()
        np[0] = (0, 255, 255) # set to teal, full brightness
        np.write()
  
  except KeyboardInterrupt:  
    break
  #time.sleep_ms(50)'''

main.py

from picozero import Speaker

speaker = Speaker(14)
BEAT = 0.4

def c_note():
    speaker.play('c4', 0.5) # play the middle c for half a second

def d_note():
    speaker.play('d4', 0.5) # play the middle d for half a second

def d2_note():
    speaker.play('d2', 0.5) # play the middle d for half a second
    

speaker_machine.py

from machine import Pin, I2C
from ssd1306 import SSD1306_I2C
import framebuf, sys
import utime

pix_res_x = 128
pix_res_y = 64

def init_i2c(scl_pin, sda_pin):
    # Initialize I2C device
    i2c_dev = I2C(1, scl=Pin(scl_pin), sda=Pin(sda_pin), freq=200000)
    i2c_addr = [hex(ii) for ii in i2c_dev.scan()]
    
    if not i2c_addr:
        print('No I2C Display Found')
        sys.exit()
    else:
        print("I2C Address      : {}".format(i2c_addr[0]))
        print("I2C Configuration: {}".format(i2c_dev))
    
    return i2c_dev

def display_logo(oled):
    # Display the Raspberry Pi logo on the OLED
    buffer = bytearray(b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00|?\x00\x01\x86@\x80\x01\x01\x80\x80\x01\x11\x88\x80\x01\x05\xa0\x80\x00\x83\xc1\x00\x00C\xe3\x00\x00~\xfc\x00\x00L'\x00\x00\x9c\x11\x00\x00\xbf\xfd\x00\x00\xe1\x87\x00\x01\xc1\x83\x80\x02A\x82@\x02A\x82@\x02\xc1\xc2@\x02\xf6>\xc0\x01\xfc=\x80\x01\x18\x18\x80\x01\x88\x10\x80\x00\x8c!\x00\x00\x87\xf1\x00\x00\x7f\xf6\x00\x008\x1c\x00\x00\x0c \x00\x00\x03\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
    fb = framebuf.FrameBuffer(buffer, 32, 32, framebuf.MONO_HLSB)
    
    oled.fill(0)
    oled.blit(fb, 96, 0)
    oled.show()

def display_text(oled):
    # Display text on the OLED
    oled.text("Raspberry Pi", 5, 5)
    oled.text("Pico", 5, 15)
    oled.show()

def display_anima(oled):
    # Display a simple timer animation on the OLED
    start_time = utime.ticks_ms()
    
def loop_screen():
    elapsed_time = (utime.ticks_diff(utime.ticks_ms(), start_time) // 1000) + 1
        
    # Clear the specific line by drawing a filled black rectangle
    oled.fill_rect(5, 40, oled.width - 5, 8, 0)

    oled.text("Timer:", 5, 30)
    oled.text(str(elapsed_time) + " sec", 5, 40)
    oled.show()
    utime.sleep(1)
def main():
    import keypad
    i2c_dev = init_i2c(scl_pin=19, sda_pin=18)
    oled = SSD1306_I2C(pix_res_x, pix_res_y, i2c_dev)
    display_logo(oled)
    display_text(oled)
    display_anima(oled)

if __name__ == '__main__':
    main()

screen.py

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces
#
# library taken from repository at:
# https://github.com/micropython/micropython/blob/master/drivers/display/ssd1306.py
#
from micropython import const
import framebuf
import time

# Register definitions
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xA4)
SET_NORM_INV = const(0xA6)
SET_DISP = const(0xAE)
SET_MEM_ADDR = const(0x20)
SET_COL_ADDR = const(0x21)
SET_PAGE_ADDR = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP = const(0xA0)
SET_MUX_RATIO = const(0xA8)
SET_COM_OUT_DIR = const(0xC0)
SET_DISP_OFFSET = const(0xD3)
SET_COM_PIN_CFG = const(0xDA)
SET_DISP_CLK_DIV = const(0xD5)
SET_PRECHARGE = const(0xD9)
SET_VCOM_DESEL = const(0xDB)
SET_CHARGE_PUMP = const(0x8D)

# Subclassing FrameBuffer provides support for graphics primitives
# http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
class SSD1306(framebuf.FrameBuffer):
    def __init__(self, width, height, external_vcc):
        self.width = width
        self.height = height
        self.external_vcc = external_vcc
        self.pages = self.height // 8
        self.buffer = bytearray(self.pages * self.width)
        super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB)
        self.init_display()

    def init_display(self):
        for cmd in (
            SET_DISP | 0x00,  # off
            # Address setting
            SET_MEM_ADDR,
            0x00,  # horizontal
            # Resolution and layout
            SET_DISP_START_LINE | 0x00,
            SET_SEG_REMAP | 0x01,  # Column addr 127 mapped to SEG0
            SET_MUX_RATIO,
            self.height - 1,
            SET_COM_OUT_DIR | 0x08,  # Scan from COM[N] to COM0
            SET_DISP_OFFSET,
            0x00,
            SET_COM_PIN_CFG,
            0x02 if self.width > 2 * self.height else 0x12,
            # Timing and driving scheme
            SET_DISP_CLK_DIV,
            0x80,
            SET_PRECHARGE,
            0x22 if self.external_vcc else 0xF1,
            SET_VCOM_DESEL,
            0x30,  # 0.83*Vcc
            # Display
            SET_CONTRAST,
            0xFF,  # maximum
            SET_ENTIRE_ON,  # Output follows RAM contents
            SET_NORM_INV,  # Not inverted
            # Charge pump
            SET_CHARGE_PUMP,
            0x10 if self.external_vcc else 0x14,
            SET_DISP | 0x01,
        ):  # On
            self.write_cmd(cmd)
        self.fill(0)
        self.show()

    def poweroff(self):
        self.write_cmd(SET_DISP | 0x00)

    def poweron(self):
        self.write_cmd(SET_DISP | 0x01)

    def contrast(self, contrast):
        self.write_cmd(SET_CONTRAST)
        self.write_cmd(contrast)

    def invert(self, invert):
        self.write_cmd(SET_NORM_INV | (invert & 1))

    def show(self):
        x0 = 0
        x1 = self.width - 1
        if self.width == 64:
            # Displays with width of 64 pixels are shifted by 32
            x0 += 32
            x1 += 32
        self.write_cmd(SET_COL_ADDR)
        self.write_cmd(x0)
        self.write_cmd(x1)
        self.write_cmd(SET_PAGE_ADDR)
        self.write_cmd(0)
        self.write_cmd(self.pages - 1)
        self.write_data(self.buffer)


class SSD1306_I2C(SSD1306):
    def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False):
        self.i2c = i2c
        self.addr = addr
        self.temp = bytearray(2)
        self.write_list = [b"\x40", None]  # Co=0, D/C#=1
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.temp[0] = 0x80  # Co=1, D/C#=0
        self.temp[1] = cmd
        self.i2c.writeto(self.addr, self.temp)

    def write_data(self, buf):
        self.write_list[1] = buf
        self.i2c.writevto(self.addr, self.write_list)

# Only required for SPI version (not covered in this project)
class SSD1306_SPI(SSD1306):
    def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
        self.rate = 10 * 1024 * 1024
        dc.init(dc.OUT, value=0)
        res.init(res.OUT, value=0)
        cs.init(cs.OUT, value=1)
        self.spi = spi
        self.dc = dc
        self.res = res
        self.cs = cs

        self.res(1)
        time.sleep_ms(1)
        self.res(0)
        time.sleep_ms(10)
        self.res(1)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs(1)
        self.dc(0)
        self.cs(0)
        self.spi.write(bytearray([cmd]))
        self.cs(1)

    def write_data(self, buf):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs(1)
        self.dc(1)
        self.cs(0)
        self.spi.write(buf)
        self.cs(1)


ssd1306.py

from machine import Pin
import utime
from speaker_machine import c_note

row_list = [7, 8, 9, 10]  
col_list = [11, 12, 13]
for x in range(0, 4):
  row_list[x] = Pin(row_list[x], Pin.OUT)
  row_list[x].value(1)
  
for x in range(0 ,3):
  col_list[x] = Pin(col_list[x], Pin.IN, Pin.PULL_UP)

key_list = [["1", "2", "3"],\
      ["4", "5", "6"],\
      ["7", "8", "9"],\
      ["*", "0", "#"]]

def Keypad(col, row):
  for r in row:
    r.value(0)
    result = [col[0].value(), col[1].value(), col[2].value()]
    if min(result) == 0:
      key = key_list[int(row.index(r))][int(result.index(0))]
      r.value(1)
      return (key)
    r.value(1)

def loop_keypad():
  key = Keypad(col_list, row_list)
  if key != None:
    print("key: "+key)
    c_note()
    #utime.sleep(0.3)

keypad.py

# MIT License (MIT)
# Copyright (c) 2022 Mike Teachman
# https://opensource.org/licenses/MIT

# Platform-independent MicroPython code for the rotary encoder module

# Documentation:
#   https://github.com/MikeTeachman/micropython-rotary

import micropython

_DIR_CW = const(0x10)  # Clockwise step
_DIR_CCW = const(0x20)  # Counter-clockwise step

# Rotary Encoder States
_R_START = const(0x0)
_R_CW_1 = const(0x1)
_R_CW_2 = const(0x2)
_R_CW_3 = const(0x3)
_R_CCW_1 = const(0x4)
_R_CCW_2 = const(0x5)
_R_CCW_3 = const(0x6)
_R_ILLEGAL = const(0x7)

_transition_table = [

    # |------------- NEXT STATE -------------|            |CURRENT STATE|
    # CLK/DT    CLK/DT     CLK/DT    CLK/DT
    #   00        01         10        11
    [_R_START, _R_CCW_1, _R_CW_1,  _R_START],             # _R_START
    [_R_CW_2,  _R_START, _R_CW_1,  _R_START],             # _R_CW_1
    [_R_CW_2,  _R_CW_3,  _R_CW_1,  _R_START],             # _R_CW_2
    [_R_CW_2,  _R_CW_3,  _R_START, _R_START | _DIR_CW],   # _R_CW_3
    [_R_CCW_2, _R_CCW_1, _R_START, _R_START],             # _R_CCW_1
    [_R_CCW_2, _R_CCW_1, _R_CCW_3, _R_START],             # _R_CCW_2
    [_R_CCW_2, _R_START, _R_CCW_3, _R_START | _DIR_CCW],  # _R_CCW_3
    [_R_START, _R_START, _R_START, _R_START]]             # _R_ILLEGAL

_transition_table_half_step = [
    [_R_CW_3,            _R_CW_2,  _R_CW_1,  _R_START],
    [_R_CW_3 | _DIR_CCW, _R_START, _R_CW_1,  _R_START],
    [_R_CW_3 | _DIR_CW,  _R_CW_2,  _R_START, _R_START],
    [_R_CW_3,            _R_CCW_2, _R_CCW_1, _R_START],
    [_R_CW_3,            _R_CW_2,  _R_CCW_1, _R_START | _DIR_CW],
    [_R_CW_3,            _R_CCW_2, _R_CW_3,  _R_START | _DIR_CCW],
    [_R_START,           _R_START, _R_START, _R_START],
    [_R_START,           _R_START, _R_START, _R_START]]

_STATE_MASK = const(0x07)
_DIR_MASK = const(0x30)


def _wrap(value, incr, lower_bound, upper_bound):
    range = upper_bound - lower_bound + 1
    value = value + incr

    if value < lower_bound:
        value += range * ((lower_bound - value) // range + 1)

    return lower_bound + (value - lower_bound) % range


def _bound(value, incr, lower_bound, upper_bound):
    return min(upper_bound, max(lower_bound, value + incr))


def _trigger(rotary_instance):
    for listener in rotary_instance._listener:
        listener()


class Rotary(object):

    RANGE_UNBOUNDED = const(1)
    RANGE_WRAP = const(2)
    RANGE_BOUNDED = const(3)

    def __init__(self, min_val, max_val, incr, reverse, range_mode, half_step, invert):
        self._min_val = min_val
        self._max_val = max_val
        self._incr = incr
        self._reverse = -1 if reverse else 1
        self._range_mode = range_mode
        self._value = min_val
        self._state = _R_START
        self._half_step = half_step
        self._invert = invert
        self._listener = []

    def set(self, value=None, min_val=None, incr=None,
            max_val=None, reverse=None, range_mode=None):
        # disable DT and CLK pin interrupts
        self._hal_disable_irq()

        if value is not None:
            self._value = value
        if min_val is not None:
            self._min_val = min_val
        if max_val is not None:
            self._max_val = max_val
        if incr is not None:
            self._incr = incr
        if reverse is not None:
            self._reverse = -1 if reverse else 1
        if range_mode is not None:
            self._range_mode = range_mode
        self._state = _R_START

        # enable DT and CLK pin interrupts
        self._hal_enable_irq()

    def value(self):
        return self._value

    def reset(self):
        self._value = 0

    def close(self):
        self._hal_close()

    def add_listener(self, l):
        self._listener.append(l)

    def remove_listener(self, l):
        if l not in self._listener:
            raise ValueError('{} is not an installed listener'.format(l))
        self._listener.remove(l)
        
    def _process_rotary_pins(self, pin):
        old_value = self._value
        clk_dt_pins = (self._hal_get_clk_value() <<
                       1) | self._hal_get_dt_value()
                       
        if self._invert:
            clk_dt_pins = ~clk_dt_pins & 0x03
            
        # Determine next state
        if self._half_step:
            self._state = _transition_table_half_step[self._state &
                                                      _STATE_MASK][clk_dt_pins]
        else:
            self._state = _transition_table[self._state &
                                            _STATE_MASK][clk_dt_pins]
        direction = self._state & _DIR_MASK

        incr = 0
        if direction == _DIR_CW:
            incr = self._incr
        elif direction == _DIR_CCW:
            incr = -self._incr

        incr *= self._reverse

        if self._range_mode == self.RANGE_WRAP:
            self._value = _wrap(
                self._value,
                incr,
                self._min_val,
                self._max_val)
        elif self._range_mode == self.RANGE_BOUNDED:
            self._value = _bound(
                self._value,
                incr,
                self._min_val,
                self._max_val)
        else:
            self._value = self._value + incr

        try:
            if old_value != self._value and len(self._listener) != 0:
                _trigger(self)
        except:
            pass

rotary.py

# MIT License (MIT)
# Copyright (c) 2020 Mike Teachman
# Copyright (c) 2021 Eric Moyer
# https://opensource.org/licenses/MIT

# Platform-specific MicroPython code for the rotary encoder module
# Raspberry Pi Pico implementation

# Documentation:
#   https://github.com/MikeTeachman/micropython-rotary

from machine import Pin
from rotary import Rotary

IRQ_RISING_FALLING = Pin.IRQ_RISING | Pin.IRQ_FALLING


class RotaryIRQ(Rotary):
    def __init__(
        self,
        pin_num_clk,
        pin_num_dt,
        min_val=0,
        max_val=10,
        incr=1,
        reverse=False,
        range_mode=Rotary.RANGE_UNBOUNDED,
        pull_up=False,
        half_step=False,
        invert=False
    ):
        super().__init__(min_val, max_val, incr, reverse, range_mode, half_step, invert)

        if pull_up:
            self._pin_clk = Pin(pin_num_clk, Pin.IN, Pin.PULL_UP)
            self._pin_dt = Pin(pin_num_dt, Pin.IN, Pin.PULL_UP)
        else:
            self._pin_clk = Pin(pin_num_clk, Pin.IN)
            self._pin_dt = Pin(pin_num_dt, Pin.IN)

        self._hal_enable_irq()

    def _enable_clk_irq(self):
        self._pin_clk.irq(self._process_rotary_pins, IRQ_RISING_FALLING)

    def _enable_dt_irq(self):
        self._pin_dt.irq(self._process_rotary_pins, IRQ_RISING_FALLING)

    def _disable_clk_irq(self):
        self._pin_clk.irq(None, 0)

    def _disable_dt_irq(self):
        self._pin_dt.irq(None, 0)

    def _hal_get_clk_value(self):
        return self._pin_clk.value()

    def _hal_get_dt_value(self):
        return self._pin_dt.value()

    def _hal_enable_irq(self):
        self._enable_clk_irq()
        self._enable_dt_irq()

    def _hal_disable_irq(self):
        self._disable_clk_irq()
        self._disable_dt_irq()

    def _hal_close(self):
        self._hal_disable_irq()

rotary_irq_rp2.py

from machine import Pin, ADC
from speaker_machine import c_note, d_note
import utime

xAxis = ADC(Pin(27))
yAxis = ADC(Pin(26))

button = Pin(1,Pin.IN, Pin.PULL_UP)
global select_pressed
select_pressed = False

def joy():
    xValue = xAxis.read_u16()
    yValue = yAxis.read_u16()
    buttonValue= button.value()
    print(str(xValue) +", " + str(yValue) + " -- " + str(buttonValue))
    #utime.sleep(0.1)

    xStatus = "middle"
    yStatus = "middle"
    buttonStatus = "not pressed"

    if xValue <= 600:
        xStatus = "left"
        #c_note()
    elif xValue >= 60000:
        xStatus = "right"
        #c_note()
    if yValue <= 600:
        yStatus = "up"
        #c_note()
    elif yValue >= 60000:
        yStatus = "down"
        #c_note()
    if buttonValue == 0:
        buttonStatus = "pressed"
        d_note()
        select_pressed = True

    print("X: " + xStatus + ", Y: " + yStatus + " -- button " + buttonStatus)

def write_joy_vars():
    is_joy_pressed = select_pressed
    
if __name__ == '__joy__':
    joy()

joypad.py

import time
import machine, neopixel

np = neopixel.NeoPixel(machine.Pin(28), 1)

def neo(r,g,b):
    np[0] = (r, g, b) # set to red, full brightness
    np.write()



pixel_bulb.py

'''
 *
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2021 Daniel Perron
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
'''

import utime
import rp2
from rp2 import PIO, asm_pio
from machine import Pin

#
#     A     B   C   D   E   F
#          ___     ___     ...
#     ____/   \___/   \___/   \
#
#     A = start pulse (> 1ms )
#     B = 2-40 us 
#     C = 80 us
#     D = 80 us
#
#     E and F are  data clock
#
#     E = 50 us
#     F =  26-28 us => 0    70 us => 1
#

    
@asm_pio(set_init=(PIO.OUT_HIGH),autopush=True, push_thresh=8)
def DHT22_PIO():
    # clock set at 500Khz  Cycle is 2us
    # drive output low for at least 20ms
    set(y,1)                    # 0
    pull()                      # 1
    mov(x,osr)                  # 2
    set(pindirs,1)              # 3 set pin to output
    set(pins,0)                 # 4 set pin low
    label ('waitx')
    jmp(x_dec,'waitx')          # 5 decrement x reg every 32 cycles
    set(pindirs,0)              # 6 set pin to input 
    # STATE A. Wait for high at least 80us. max should be  very short
    set(x,31)                   # 7 
    label('loopA')
    jmp(pin,'got_B')            # 8
    jmp(x_dec,'loopA')          # 9
    label('Error')
    in_(y,1)                    # 10
    jmp('Error')                # 11  Infinity loop error

    # STATE B. Get HIGH pulse. max should be 40us
    label('got_B')
    set(x,31)                   # 12
    label('loop_B')
    jmp(x_dec,'check_B')        # 13
    jmp('Error')                # 14
    label('check_B') 
    jmp(pin,'loop_B')           # 15
 
    # STATE C. Get LOW pulse. max should be 80us
    set(x,31)                   # 16
    label('loop_C')
    jmp(pin,'got_D')            # 17     
    jmp(x_dec,'loop_C')         # 18
    jmp('Error')                # 19
    
    # STATE D. Get HIGH pulse. max should be 80us
    label('got_D')
    set(x,31)                   # 20
    label('loop_D')
    jmp(x_dec,'check_D')        # 21
    jmp('Error')                # 22
    label('check_D')
    jmp(pin,'loop_D')           # 23
    
    # STATE E. Get Low pulse delay. should be around 50us
    set(x,31)                   # 24
    label('loop_E')
    jmp(pin,'got_F')            # 25
    jmp(x_dec,'loop_E')         # 26
    jmp('Error')                # 27
   
    # STATE F.
    # wait 40 us
    label('got_F')              
    nop() [20]                  # 28
    in_(pins,1)                 # 29
    # now wait for low pulse
    set(x,31)                   # 30
    jmp('loop_D')               # 31    




class PicoDHT22:
    
    def __init__(self,dataPin, powerPin=None,dht11=False,smID=1):
        self.dataPin = dataPin
        self.powerPin = powerPin
        self.dht11 = dht11
        self.smID = smID
        self.dataPin.init(Pin.IN, Pin.PULL_UP)
        if self.powerPin is not None:
            self.powerPin.init(Pin.OUT)
            self.powerPin.value(0)
        self.sm= rp2.StateMachine(self.smID)
        




    def read_array(self):
        if self.powerPin is not None:
            self.powerPin.value(1)
            utime.sleep_ms(800)
        utime.sleep_ms(200)
        #start state machine
        self.sm.init(DHT22_PIO,freq=500000,
                     set_base=self.dataPin,
                     in_base=self.dataPin,
                     jmp_pin=self.dataPin)
        if self.dht11:
            self.sm.put(10000)
        else:
            self.sm.put(1000)
        self.sm.active(1)
        value = []
        for i in range(5):
            value.append(self.sm.get())
        self.sm.active(0)
        if self.powerPin is not None:
            self.powerPin.value(0)
        return value
 
    def read(self):
        value = self.read_array()
        sumV = 0
        for i in range(4):
            sumV += value[i]
        if (sumV & 0xff) == value[4]:
            if self.dht11:
                humidity=value[0] & 0x7f
                temperature=value[2] 
            else:                
                humidity=((value[0]<<8)  + value[1])/10.0
                temperature=(((value[2] &0x7f) << 8)  + value[3]) /10.0 
            if (value[2] & 0x80) == 0x80:
                temperature = -temperature            
            return temperature, humidity
        else:
            return None, None
        
if __name__ == "__main__":
    from machine import Pin
    from PicoDHT22 import PicoDHT22
    import utime
    dht_data = Pin(15,Pin.IN,Pin.PULL_UP)
    dht_sensor=PicoDHT22(dht_data,Pin(14,Pin.OUT),dht11=False)
    while True:
        T,H = dht_sensor.read()
        if T is None:
            print(" sensor error")
        else:
            print("{:3.1f}'C  {:3.1f}%".format(T,H))
        #DHT22 not responsive if delay to short
        utime.sleep_ms(500)
        

pico_dht_22.py

"""
MicroPython max7219 cascadable 8x8 LED matrix driver
https://github.com/mcauser/micropython-max7219

MIT License
Copyright (c) 2017 Mike Causer

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""

from micropython import const
import framebuf

_NOOP = const(0)
_DIGIT0 = const(1)
_DECODEMODE = const(9)
_INTENSITY = const(10)
_SCANLIMIT = const(11)
_SHUTDOWN = const(12)
_DISPLAYTEST = const(15)

class Matrix8x8:
    def __init__(self, spi, cs, num):
        """
        Driver for cascading MAX7219 8x8 LED matrices.

        >>> import max7219
        >>> from machine import Pin, SPI
        >>> spi = SPI(1)
        >>> display = max7219.Matrix8x8(spi, Pin('X5'), 4)
        >>> display.text('1234',0,0,1)
        >>> display.show()

        """
        self.spi = spi
        self.cs = cs
        self.cs.init(cs.OUT, True)
        self.buffer = bytearray(8 * num)
        self.num = num
        fb = framebuf.FrameBuffer(self.buffer, 8 * num, 8, framebuf.MONO_HLSB)
        self.framebuf = fb
        # Provide methods for accessing FrameBuffer graphics primitives. This is a workround
        # because inheritance from a native class is currently unsupported.
        # http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
        self.fill = fb.fill  # (col)
        self.pixel = fb.pixel # (x, y[, c])
        self.hline = fb.hline  # (x, y, w, col)
        self.vline = fb.vline  # (x, y, h, col)
        self.line = fb.line  # (x1, y1, x2, y2, col)
        self.rect = fb.rect  # (x, y, w, h, col)
        self.fill_rect = fb.fill_rect  # (x, y, w, h, col)
        self.text = fb.text  # (string, x, y, col=1)
        self.scroll = fb.scroll  # (dx, dy)
        self.blit = fb.blit  # (fbuf, x, y[, key])
        self.init()

    def _write(self, command, data):
        self.cs(0)
        for m in range(self.num):
            self.spi.write(bytearray([command, data]))
        self.cs(1)

    def init(self):
        for command, data in (
            (_SHUTDOWN, 0),
            (_DISPLAYTEST, 0),
            (_SCANLIMIT, 7),
            (_DECODEMODE, 0),
            (_SHUTDOWN, 1),
        ):
            self._write(command, data)

    def brightness(self, value):
        if not 0 <= value <= 15:
            raise ValueError("Brightness out of range")
        self._write(_INTENSITY, value)

    def show(self):
        for y in range(8):
            self.cs(0)
            for m in range(self.num):
                self.spi.write(bytearray([_DIGIT0 + y, self.buffer[(y * self.num) + m]]))
            self.cs(1)

max7219.py

from machine import Pin, SPI
from pico_dht_22 import PicoDHT22
#from speaker_machine import d2_note

dht_sensor=PicoDHT22(Pin(15,Pin.IN,Pin.PULL_UP),dht11=True)

def tem_check():
    T,H = dht_sensor.read()
    if T is None:
        continue
        print(" sensor error")
        #d_note()
    else:
        print("{}'C  {}%".format(T,H))
        #d2_note()
    #DHT22 not responsive if delay too short

temp_sensor.py

"""
Micropython (Raspberry Pi Pico)
Plays music written on onlinesequencer.net through a passive piezo buzzer.
Uses fast arpeggios with a single buzzer to simulate polyphony
Also supports multiple buzzers at once for real polyphony
https://github.com/james1236/buzzer_music
"""

from machine import Pin, PWM
from math import ceil

tones = {
    'C0':16,
    'C#0':17,
    'D0':18,
    'D#0':19,
    'E0':21,
    'F0':22,
    'F#0':23,
    'G0':24,
    'G#0':26,
    'A0':28,
    'A#0':29,
    'B0':31,
    'C1':33,
    'C#1':35,
    'D1':37,
    'D#1':39,
    'E1':41,
    'F1':44,
    'F#1':46,
    'G1':49,
    'G#1':52,
    'A1':55,
    'A#1':58,
    'B1':62,
    'C2':65,
    'C#2':69,
    'D2':73,
    'D#2':78,
    'E2':82,
    'F2':87,
    'F#2':92,
    'G2':98,
    'G#2':104,
    'A2':110,
    'A#2':117,
    'B2':123,
    'C3':131,
    'C#3':139,
    'D3':147,
    'D#3':156,
    'E3':165,
    'F3':175,
    'F#3':185,
    'G3':196,
    'G#3':208,
    'A3':220,
    'A#3':233,
    'B3':247,
    'C4':262,
    'C#4':277,
    'D4':294,
    'D#4':311,
    'E4':330,
    'F4':349,
    'F#4':370,
    'G4':392,
    'G#4':415,
    'A4':440,
    'A#4':466,
    'B4':494,
    'C5':523,
    'C#5':554,
    'D5':587,
    'D#5':622,
    'E5':659,
    'F5':698,
    'F#5':740,
    'G5':784,
    'G#5':831,
    'A5':880,
    'A#5':932,
    'B5':988,
    'C6':1047,
    'C#6':1109,
    'D6':1175,
    'D#6':1245,
    'E6':1319,
    'F6':1397,
    'F#6':1480,
    'G6':1568,
    'G#6':1661,
    'A6':1760,
    'A#6':1865,
    'B6':1976,
    'C7':2093,
    'C#7':2217,
    'D7':2349,
    'D#7':2489,
    'E7':2637,
    'F7':2794,
    'F#7':2960,
    'G7':3136,
    'G#7':3322,
    'A7':3520,
    'A#7':3729,
    'B7':3951,
    'C8':4186,
    'C#8':4435,
    'D8':4699,
    'D#8':4978,
    'E8':5274,
    'F8':5588,
    'F#8':5920,
    'G8':6272,
    'G#8':6645,
    'A8':7040,
    'A#8':7459,
    'B8':7902,
    'C9':8372,
    'C#9':8870,
    'D9':9397,
    'D#9':9956,
    'E9':10548,
    'F9':11175,
    'F#9':11840,
    'G9':12544,
    'G#9':13290,
    'A9':14080,
    'A#9':14917,
    'B9':15804
}

#Time, Note, Duration, Instrument (onlinesequencer.net schematic format)
#0 D4 8 0;0 D5 8 0;0 G4 8 0;8 C5 2 0;10 B4 2 0;12 G4 2 0;14 F4 1 0;15 G4 17 0;16 D4 8 0;24 C4 8 0

class music:
    def __init__(self, songString='0 D4 8 0', looping=True, tempo=3, duty=2512, pin=None, pins=[Pin(0)]):
        self.tempo = tempo
        self.song = songString
        self.looping = looping
        self.duty = duty
        
        self.stopped = False
        
        self.timer = -1
        self.beat = -1
        self.arpnote = 0
        
        self.pwms = []
        
        if (not (pin is None)):
            pins = [pin]
        self.pins = pins
        for pin in pins:
            self.pwms.append(PWM(pin))
        
        self.notes = []

        self.playingNotes = []
        self.playingDurations = []


        #Find the end of the song
        self.end = 0
        splitSong = self.song.split(";")
        for note in splitSong:
            snote = note.split(" ")
            testEnd = round(float(snote[0])) + ceil(float(snote[2]))
            if (testEnd > self.end):
                self.end = testEnd
                
        #Create empty song structure
        while (self.end > len(self.notes)):
            self.notes.append(None)

        #Populate song structure with the notes
        for note in splitSong:
            snote = note.split(" ")
            beat = round(float(snote[0]));
            
            if (self.notes[beat] == None):
                self.notes[beat] = []
            self.notes[beat].append([snote[1],ceil(float(snote[2]))]) #Note, Duration


        #Round up end of song to nearest bar
        self.end = ceil(self.end / 8) * 8
    
    def stop(self):
        for pwm in self.pwms:
            pwm.deinit()
        self.stopped = True

    def restart(self):
        self.beat = -1
        self.timer = 0
        self.stop()
        self.pwms = []
        for pin in self.pins:
            self.pwms.append(PWM(pin))
        self.stopped = False

    def resume(self):
        self.stop()
        self.pwms = []
        for pin in self.pins:
            self.pwms.append(PWM(pin))
        self.stopped = False

    def tick(self):
        if (not self.stopped):
            self.timer = self.timer + 1
            
            #Loop
            if (self.timer % (self.tempo * self.end) == 0 and (not (self.timer == 0))):
                if (not self.looping):
                    self.stop()
                    return False
                self.beat = -1
                self.timer = 0
            
            #On Beat
            if (self.timer % self.tempo == 0):
                self.beat = self.beat + 1

                #Remove expired notes from playing list
                i = 0
                while (i < len(self.playingDurations)):
                    self.playingDurations[i] = self.playingDurations[i] - 1
                    if (self.playingDurations[i] <= 0):
                        self.playingNotes.pop(i)
                        self.playingDurations.pop(i)
                    else:
                        i = i + 1
                        
                #Add new notes and their durations to the playing list
                
                """
                #Old method runs for every note, slow to process on every beat and causes noticeable delay
                ssong = song.split(";")
                for note in ssong:
                    snote = note.split(" ")
                    if int(snote[0]) == beat:
                        playingNotes.append(snote[1])
                        playingDurations.append(int(snote[2]))
                """
                
                if (self.beat < len(self.notes)):
                    if (self.notes[self.beat] != None):
                        for note in self.notes[self.beat]:
                            self.playingNotes.append(note[0])
                            self.playingDurations.append(note[1])
                
                #Only need to run these checks on beats
                i = 0
                for pwm in self.pwms:
                    if (i >= len(self.playingNotes)):
                        if hasattr(pwm, 'duty_u16'):
                            pwm.duty_u16(0)
                        else:
                            pwm.duty(0)
                    else:
                        #Play note
                        if hasattr(pwm, 'duty_u16'):
                            pwm.duty_u16(self.duty)
                        else:
                            pwm.duty(self.duty)
                        pwm.freq(tones[self.playingNotes[i]])
                    i = i + 1
            

            #Play arp of all playing notes
            if (len(self.playingNotes) > len(self.pwms)):
                p = self.pwms[len(self.pwms)-1];
                if hasattr(p, 'duty_u16'):
                    p.duty_u16(self.duty)
                else:
                    p.duty(self.duty)
                
                if (self.arpnote > len(self.playingNotes)-len(self.pwms)):
                    self.arpnote = 0
                self.pwms[len(self.pwms)-1].freq(tones[self.playingNotes[self.arpnote+(len(self.pwms)-1)]])
                self.arpnote = self.arpnote + 1
                
            return True
        else:
            return False