serverあれこれ

from machine import Pin, I2C
import sht31

i2c = I2C(0, scl=Pin(21), sda=Pin(20), freq =400000)
sensor = sht31.SHT31(i2c, addr=0x45)

(temperature, humidity) = sensor.get_temp_humi()
print("temp: {}".format(temperature))
print("humidity: {}".format(humidity))

// Raspberry Pi Picoのベースサイズ
PICO_W=51;
PICO_D=22;

// Raspberry Pi Picoを支える足の部分
LEG_HEIGHT=4;
LEG_DISTANCE=8.2;
LEG_SIZE=4;
LEG_HOLE_DIAMETER=1.5+0.5;

// Raspberry Pi Pico固定用足のオフセット
LEG_OFFSET_W=1;
LEG_OFFSET_D=0.8;

// プレートの厚さ
PLATE_THICK=2;

// LEGOの1ブロック
LEGO_SQUARE=7.95;
// LEGOの側面の厚さ
LEGO_WALL=1.5;
// 突起の直径
LEGO_PEG=4.8;
LEGO_PEG_R=LEGO_PEG/2;
LEGO_PEG_H=2.8;
// LEGOの底面の円の直径
LEGO_BOTTOM_CIRCLE=6.4;

// プレートのサイズ(ブロック単位)
NUM_HOLE_W=7;
NUM_HOLE_D=3;

module pico_mounter_lego()
{
    // ベースプレート
    translate([0, 0, 0])
    linear_extrude(height=PLATE_THICK){
        square([LEGO_SQUARE*NUM_HOLE_W, LEGO_SQUARE*NUM_HOLE_D]);
    }

    //壁
    translate([0, 0, -LEGO_PEG_H])
    linear_extrude(height=LEGO_PEG_H){
        square([LEGO_SQUARE*NUM_HOLE_W, LEGO_WALL]);
    }

    translate([0, LEGO_SQUARE*NUM_HOLE_D-LEGO_WALL, -LEGO_PEG_H])
    linear_extrude(height=LEGO_PEG_H){
        square([LEGO_SQUARE*NUM_HOLE_W, LEGO_WALL]);
    }

    translate([0, 0, -LEGO_PEG_H])
    linear_extrude(height=LEGO_PEG_H){
        square([LEGO_WALL, LEGO_SQUARE*NUM_HOLE_D]);
    }

    translate([LEGO_SQUARE*NUM_HOLE_W-LEGO_WALL, 0, -LEGO_PEG_H])
    linear_extrude(height=LEGO_PEG_H){
        square([LEGO_WALL, LEGO_SQUARE*NUM_HOLE_D]);
    }


    for( lw = [0 : NUM_HOLE_W-2] ){
        for( ld = [0 : NUM_HOLE_D-2] ){
            translate([LEGO_SQUARE*(lw+1), LEGO_SQUARE*(ld+1), -LEGO_PEG_H])
            linear_extrude(height=LEGO_PEG_H){
                circle(LEGO_BOTTOM_CIRCLE/2, $fn=50);
            }
        }
    }
}

module pico_mounter()
{
    difference(){
        union(){
            // 底面
            translate([0, 0, 0])
            linear_extrude(height=PLATE_THICK){
                square([PICO_W, PICO_D]);
            }

            translate([LEG_OFFSET_W, PICO_D/2-LEG_DISTANCE/2-LEG_SIZE, PLATE_THICK])
            linear_extrude(height=LEG_HEIGHT){
                square([LEG_SIZE, LEG_SIZE]);
            }
            translate([LEG_OFFSET_W, PICO_D/2+LEG_DISTANCE/2, PLATE_THICK])
            linear_extrude(height=LEG_HEIGHT){
                square([LEG_SIZE, LEG_SIZE]);
            }    
            translate([PICO_W-LEG_SIZE+LEG_OFFSET_W, PICO_D/2-LEG_DISTANCE/2-LEG_SIZE, PLATE_THICK])
            linear_extrude(height=LEG_HEIGHT){
                square([LEG_SIZE, LEG_SIZE]);
            }
            translate([PICO_W-LEG_SIZE+LEG_OFFSET_W, PICO_D/2+LEG_DISTANCE/2, PLATE_THICK])
            linear_extrude(height=LEG_HEIGHT){
                square([LEG_SIZE, LEG_SIZE]);
            }
        }
        union(){
            translate([LEG_SIZE/2+LEG_OFFSET_W, PICO_D/2-LEG_DISTANCE/2-LEG_SIZE/2, 0])
            linear_extrude(height=LEG_HEIGHT+PLATE_THICK){
                circle(LEG_HOLE_DIAMETER/2, $fn=50);
            }
            translate([LEG_SIZE/2+LEG_OFFSET_W, PICO_D/2+LEG_DISTANCE/2+LEG_SIZE/2, 0])
            linear_extrude(height=LEG_HEIGHT+PLATE_THICK){
                circle(LEG_HOLE_DIAMETER/2, $fn=50);
            }
            translate([PICO_W-LEG_SIZE/2+LEG_OFFSET_W, PICO_D/2-LEG_DISTANCE/2-LEG_SIZE/2, 0])
            linear_extrude(height=LEG_HEIGHT+PLATE_THICK){
                circle(LEG_HOLE_DIAMETER/2, $fn=50);
            }
            translate([PICO_W-LEG_SIZE/2+LEG_OFFSET_W, PICO_D/2+LEG_DISTANCE/2+LEG_SIZE/2, 0])
            linear_extrude(height=LEG_HEIGHT+PLATE_THICK){
                circle(LEG_HOLE_DIAMETER/2, $fn=50);
            }
        }
    }
}

pico_mounter_lego();
translate([LEG_OFFSET_W, LEG_OFFSET_D, 0])
pico_mounter();

関連情報 ・OpenSCADまとめ

・OpenSCADとUltimaker Curaを使用してRaspberry Pi Picoのケースを作成する

import wavePlayer
import uos
player = wavePlayer.wavePlayer()

soundsFolder= "/sounds"

try:
    for file in uos.listdir(soundsFolder):
        print(soundsFolder + "/" + file)
        player.play(soundsFolder + "/" + file)
except KeyboardInterrupt:
    player.stop()

import machine
import time

# Raspberry Pi Picoの26ピン=ADC0
pin26 = machine.ADC(0)

while True:
    value = pin26.read_u16()
    print("rotary angle sensor:{}".format(value))
    time.sleep(1)

import machine
import time

PIN5 = machine.Pin(5, machine.Pin.OUT)

while True:
    # 2秒おきに短いブザー音を出力
    PIN5.value(1)
    time.sleep(0.1)
    PIN5.value(0)
    time.sleep(1.9)

import machine 
import time

# Raspberry Pi Picoの26ピン=ADC0
pin26 = machine.ADC(0)

while True:
    value = pin26.read_u16()

    print("lightness:{}".format(value))
    time.sleep(1)

import serial
import time

PANID="0x1111"

try:
    ser = serial.Serial(port='/dev/serial0',baudrate=115200,timeout=None)

    # initialize subGHz
    ser.write("sgi\n".encode("utf-8"))
    ser.flush()
    line = ser.readline()
    print("result:{}".format(line.decode('utf-8').strip()))

    # start with ch=36 and PANID=0x1111
    ser.write(("sgb,36,"+PANID+",100,20\n").encode("utf-8"))
    ser.flush()
    line = ser.readline()
    print("result:{}".format(line.decode('utf-8').strip()))

    # get my address
    ser.write("sggma\n".encode("utf-8"))
    ser.flush()
    myaddress = ser.readline().decode('utf-8').strip().split(',')[1]
    print("sggma:{}".format(myaddress))

    # get send mode
    ser.write("sggsm\n".encode("utf-8"))
    ser.flush()
    line = ser.readline()
    print("result:{}".format(line.decode('utf-8').strip()))

    # Enable Rx
    #ser.write("sgre\n".encode("utf-8"))
    ser.write("sgra\r\n".encode("utf-8"))
    ser.flush()
    line = ser.readline()
    print("result:{}".format(line.decode('utf-8').strip()))

    try:
        while True:
            rl = ser.readline()
            #print(rl)
            recv = rl.decode('utf-8').strip().split(',')
            if len(recv) >= 8 and len(recv[8]) > 0:
                print("result:{}".format(recv[8]))
    except KeyboardInterrupt:
        # close
        ser.write("sgc\n".encode("utf-8"))
        ser.flush()
        line = ser.readline()
        print("result:{}".format(line.decode('utf-8').strip()))
finally:
    ser.close()

python3 mj2001_recv.py

import machine 
import time

PANID="0x11111"
dest_addr="0xABCD"

# initialize UART.
uart = machine.UART(0, 115200)

ct = 0
# initialize subGHz
uart.write('sgi\n')
print(uart.readline())


while True:
    # begin with ch=36,PANID=0x1111
    uart.write("sgb,36,"+PANID+",100,20\n")
    print(uart.readline())

    # send count message
    uart.write("w,count:{}    \n".format(ct))
    print(uart.readline())
    uart.write("sgs,"+PANID+","+dest_addr+"\n")
    print(uart.readline())
    
    # close
    uart.write("sgc\n")
    print(uart.readline())

    ct=ct+1
    time.sleep(1)

import time
from machine import Pin, I2C
i2c=I2C(0, scl=Pin(1), sda=Pin(0), freq=400000)

addr_tsl25721=0x39
#print(i2c.scan())
FIELD_COMMAND = 0x80 # Write
FIELD_TYPE = 0x20 #  Auto-increment protocol transaction

REG_CONTROL = 0x0F # Control Register
VAL_CONTROL_RESET = 0x00 # Reset Value for Control Register
REG_CONFIG = 0x0D # Config Register
VAL_CONFIG_RESET = 0x00 # Reset Value for Config Register
REG_ATIME = 0x01 # ATIME(ALS time) Register
VAL_ATIME_C64 = 0xC0 # INTEG_CYCLE=64, Time=175ms
REG_ENABLE = 0x00 # Enable Register
VAL_ENABLE_PON = 0x01 # Power ON
VAL_ENABLE_AEN = 0x02 # ALS Enable
VAL_ENABLE = VAL_ENABLE_PON | VAL_ENABLE_AEN

REG_C0DATA = 0x14 # CH0 ADC low data register

# Initialize
# Reset Control Register
buf = bytearray(1)

buf[0] = VAL_CONTROL_RESET
i2c.writeto_mem(addr_tsl25721, FIELD_COMMAND | FIELD_TYPE | REG_CONTROL, buf)

# Reset Config Register
buf[0] = VAL_CONFIG_RESET
i2c.writeto_mem(addr_tsl25721, FIELD_COMMAND | FIELD_TYPE | REG_CONFIG, buf)

# Set ALS time
buf[0] = VAL_ATIME_C64
i2c.writeto_mem(addr_tsl25721, FIELD_COMMAND | FIELD_TYPE | REG_ATIME, buf)

# Power on and enable ALS
buf[0] = VAL_ENABLE
i2c.writeto_mem(addr_tsl25721, FIELD_COMMAND | FIELD_TYPE | REG_ENABLE, buf)
time.sleep(1)

def read_lux():
  atime = 0xC0 # 192
  gain = 1.0

  dat = i2c.readfrom_mem(addr_tsl25721, FIELD_COMMAND | FIELD_TYPE | REG_C0DATA, 4)
  adc0 = (dat[1] << 8) | dat[0]
  adc1 = (dat[3] << 8) | dat[2] 

  cpl = (2.73 * (256 - atime) * gain)/(60.0)
  lux1 = ((adc0 * 1.00) - (adc1 * 1.87)) / cpl
  lux2 = ((adc0 * 0.63) - (adc1 * 1.00)) / cpl
  lux = 0
  if ((lux1 <= 0) and (lux2 <= 0)) :
    lux = 0
  if (lux1 > lux2) :
    lux = lux1
  elif (lux1 < lux2) :
    lux = lux2

  return lux

while True:
  lux= read_lux()
  print("lux:{:.1f}".format(lux))
  time.sleep(1)

import machine
import time
import math

# Raspberry Pi Picoの26ピン=ADC0
pin26 = machine.ADC(0)

while True:
    value = pin26.read_u16()
    r = 100000.0 * (65535.0 / value - 1.0)
    temperature = 1.0 / (math.log10(r / 100000.0) / 4275.0 + 1 / 298.15) - 273.15

    print("temp:{:.2f}".format(temperature))
    time.sleep(1)

from bme680 import *
from machine import I2C, Pin
import time
scl = Pin(1)
sda = Pin(0)
bme = BME680_I2C(I2C(0, scl=scl, sda=sda))

while True:
    print("Temp:{}, Humidity:{}, Pressure:{}, Gas:{}".format(bme.temperature, bme.humidity, bme.pressure, bme.gas))
    time.sleep(3)

import time
from machine import Pin
from dht import DHT11, InvalidChecksum

time.sleep(1)
dht11 = DHT11(Pin(28))

while True:
    try:
        print("temp: {}".format(dht11.temperature))
        print("humidity: {}".format(dht11.humidity))
    except InvalidChecksum:
        print("invalid checksum")
    time.sleep(2)

    def _send_init_signal(self):
        self._pin.init(Pin.OUT, Pin.PULL_DOWN)
        self._pin.init(Pin.OUT)
        self._pin.value(1)
        #utime.sleep_ms(50)
        utime.sleep_ms(250)
        self._pin.value(0)
        utime.sleep_ms(18)

// Raspberry Pi Picoのベースサイズ
PICO_W=52;
PICO_D=22;

PICO_PIN_D=4;
PICO_PIN_H=9;

HOLE_SPACE_W = 2;
HOLE_SPACE_D = 4;

WALL_THICK=2;

WALL_H=16;

MICROUSB_D=9;

BOARD_THICK=1;

LEG_HEIGHT=1;
LEG_DISTANCE=8;
LEG_SIZE=3;
LEG_HOLE_DIAMETER=1.5+0.5;
LEG_OFFSET_W=1;

module pico_base()
{
    difference(){
        union(){
            // 底面
            translate([0, HOLE_SPACE_D, 0])
            linear_extrude(height=PICO_PIN_H){
                square([PICO_W, PICO_D-HOLE_SPACE_D*2]);
            }

            translate([LEG_OFFSET_W, PICO_D/2-LEG_DISTANCE/2-LEG_SIZE, PICO_PIN_H])
            linear_extrude(height=LEG_HEIGHT){
                square([LEG_SIZE, LEG_SIZE]);
            }
            translate([LEG_OFFSET_W, PICO_D/2+LEG_DISTANCE/2, PICO_PIN_H])
            linear_extrude(height=LEG_HEIGHT){
                square([LEG_SIZE, LEG_SIZE]);
            }    
            translate([PICO_W-LEG_SIZE-LEG_OFFSET_W, PICO_D/2-LEG_DISTANCE/2-LEG_SIZE, PICO_PIN_H])
            linear_extrude(height=LEG_HEIGHT){
                square([LEG_SIZE, LEG_SIZE]);
            }
            translate([PICO_W-LEG_SIZE-LEG_OFFSET_W, PICO_D/2+LEG_DISTANCE/2, PICO_PIN_H])
            linear_extrude(height=LEG_HEIGHT){
                square([LEG_SIZE, LEG_SIZE]);
            }
        }
        union(){
            translate([LEG_SIZE/2+LEG_OFFSET_W, PICO_D/2-LEG_DISTANCE/2-LEG_SIZE/2, LEG_HEIGHT])
            linear_extrude(height=PICO_PIN_H){
                circle(LEG_HOLE_DIAMETER/2, $fn=50);
            }
            translate([LEG_SIZE/2+LEG_OFFSET_W, PICO_D/2+LEG_DISTANCE/2+LEG_SIZE/2, LEG_HEIGHT])
            linear_extrude(height=PICO_PIN_H){
                circle(LEG_HOLE_DIAMETER/2, $fn=50);
            }
            translate([PICO_W-LEG_SIZE/2-LEG_OFFSET_W, PICO_D/2-LEG_DISTANCE/2-LEG_SIZE/2, LEG_HEIGHT])
            linear_extrude(height=PICO_PIN_H){
                circle(LEG_HOLE_DIAMETER/2, $fn=50);
            }
            translate([PICO_W-LEG_SIZE/2-LEG_OFFSET_W, PICO_D/2+LEG_DISTANCE/2+LEG_SIZE/2, LEG_HEIGHT])
            linear_extrude(height=PICO_PIN_H){
                circle(LEG_HOLE_DIAMETER/2, $fn=50);
            }
        }
    }
}

module pico_wall()
{
    // microusb
    translate([-WALL_THICK, -WALL_THICK, 0])
    linear_extrude(height=WALL_H){
        square([WALL_THICK, (PICO_D-MICROUSB_D)/2+WALL_THICK]);
    }
    translate([-WALL_THICK, (PICO_D-MICROUSB_D)/2, 0])
    linear_extrude(height=PICO_PIN_H+BOARD_THICK){
        square([WALL_THICK, MICROUSB_D]);
    }
    translate([-WALL_THICK, (PICO_D-MICROUSB_D)/2+MICROUSB_D, 0])
    linear_extrude(height=WALL_H){
        square([WALL_THICK, (PICO_D-MICROUSB_D)/2+WALL_THICK]);
    }

    translate([0, -WALL_THICK, 0])
    linear_extrude(height=WALL_H){
        square([PICO_W, WALL_THICK]);
    }

    translate([0, PICO_D, 0])
    linear_extrude(height=WALL_H){
        square([PICO_W, WALL_THICK]);
    }

    translate([PICO_W, -WALL_THICK, 0])
    linear_extrude(height=WALL_H){
        square([WALL_THICK, PICO_D+WALL_THICK*2]);
    }

}

pico_base();
pico_wall();

// Raspberry Pi Picoのベースサイズ
PICO_W=52;
PICO_D=22;

WALL_THICK=2;
WALL_H=2;

module nano_lid()
{
    translate([-WALL_THICK, -WALL_THICK, 0])
    linear_extrude(height=WALL_H){
        square([PICO_W+WALL_THICK*2, PICO_D+WALL_THICK*2]);
    }

    translate([0, 0, WALL_H])
    linear_extrude(height=WALL_H){
        square([PICO_W, PICO_D]);
    }

}

nano_lid();

import utime
import picodisplay

# initialize
buf = bytearray(picodisplay.get_width() * picodisplay.get_height() * 2)
picodisplay.init(buf)

# clear background
picodisplay.set_pen(0, 0, 0)
picodisplay.clear()

characters = [
    [ord('A'), 255, 0, 0],
    [ord('B'), 0, 255, 0],
    [ord('C'), 0, 0, 255]
]

px=50
py=40
for ch in characters:
    picodisplay.set_pen(ch[1], ch[2], ch[3])
    picodisplay.character(ch[0], px, py, 8)
    px+=50
picodisplay.update()

import utime
import picodisplay

# initialize
buf = bytearray(picodisplay.get_width() * picodisplay.get_height() * 2)
picodisplay.init(buf)

px=0
py=0
space=20
radius=8
while py < picodisplay.get_height():
    while px < picodisplay.get_width():
        pat = ((py/space)%2+(px/space)%2)%2
        if pat == 0:
            picodisplay.set_pen(0, 0, 0)
        else:
            picodisplay.set_pen(128, 128, 255)
        picodisplay.circle(px, py, radius)
        px += space
    px = 0
    py += space
picodisplay.update()

import utime
import picodisplay

# initialize
buf = bytearray(picodisplay.get_width() * picodisplay.get_height() * 2)
picodisplay.init(buf)

px=0
py=0
sx=16
sy=16
while py < picodisplay.get_height():
    while px < picodisplay.get_width():
        pat = ((py/sx)%2+(px/sy)%2)%2
        if pat == 0:
            picodisplay.set_pen(0, 0, 100)
        else:
            picodisplay.set_pen(200, 200, 0)
        picodisplay.rectangle(px, py, sx, sy)
        px += sx
    px = 0
    py += sy
picodisplay.update()

import utime
import picodisplay

# initialize
buf = bytearray(picodisplay.get_width() * picodisplay.get_height() * 2)
picodisplay.init(buf)


while True:
    # clear background
    picodisplay.set_pen(0, 0, 0)
    picodisplay.clear()
    picodisplay.set_pen(255, 255, 255)

    message = ''
    # A button
    if picodisplay.is_pressed(picodisplay.BUTTON_A):
        message += 'A'
    # B button
    if picodisplay.is_pressed(picodisplay.BUTTON_B):
        message += 'B'
    # X button
    if picodisplay.is_pressed(picodisplay.BUTTON_X):
        message += 'X'
    # Y button
    if picodisplay.is_pressed(picodisplay.BUTTON_Y):
        message += 'Y'
    picodisplay.text(message, 4, 4, picodisplay.get_width(), 5)
    picodisplay.update()
    utime.sleep_ms(1000)

import time
from machine import Pin, PWM
from ir_rx.nec import NEC_8

keydata = {
0xD8:"Power button",
0xF8:"A button",
0x78:"B button",
0x58:"C button",
0xB1:"Upper left button",
0xA0:"Up button",
0x21:"Upper right button",
0x10:"Left button",
0x20:"Center button",
0x80:"Right button",
0x11:"Bottom left button",
0x00:"Down button",
0x81:"Bottom right button",
0xFF:"N/A"
}
last_code=0xFF

def callback(data, addr, ctrl):
    global last_code
    if data < 0:  # repeat code
        print(keydata[last_code])
    else:
        last_code = data
        print(keydata[data])
    if last_code == 0xA0: # Up button -> foward
        pos=20
        servo1.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
        pos=-20
        servo2.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
        time.sleep_ms(1000)
        pos=0
        servo1.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
        servo2.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
    elif last_code == 0x00: # Down button -> Back
        pos=-20
        servo1.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
        pos=20
        servo2.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
        time.sleep_ms(1000)
        pos=0
        servo1.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
        servo2.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
    elif last_code == 0x10:    # Left button -> turn left
        pos=-20
        servo1.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
        pos=-20
        servo2.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
        time.sleep_ms(1000)
        pos=0
        servo1.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
        servo2.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
    elif last_code == 0x80:    # Right button -> turn right
        pos=20
        servo1.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
        pos=20
        servo2.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
        time.sleep_ms(1000)
        pos=0
        servo1.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))
        servo2.duty_u16(int((1.5 + (pos / 180)) * 65535 / 20 + 0.5))

wget https://github.com/blippy/rpi/raw/master/pico/kicad/pico_rp2040.dcm

wget https://github.com/blippy/rpi/raw/master/pico/kicad/pico_rp2040.lib

import utime
import picodisplay

# initialize
buf = bytearray(picodisplay.get_width() * picodisplay.get_height() * 2)
picodisplay.init(buf)

# clear background
picodisplay.set_pen(0, 0, 0)
picodisplay.clear()
picodisplay.update()

while True:
    # red
    picodisplay.set_led(255, 0, 0)
    utime.sleep_ms(1000)
    # green
    picodisplay.set_led(0, 255, 0)
    utime.sleep_ms(1000)
    # blue
    picodisplay.set_led(0, 0, 255)
    utime.sleep_ms(1000)
    # white
    picodisplay.set_led(255, 255, 255)
    utime.sleep_ms(1000)

import utime
import picodisplay

# initialize
buf = bytearray(picodisplay.get_width() * picodisplay.get_height() * 2)
picodisplay.init(buf)

# clear background
picodisplay.set_pen(200, 220, 255)
picodisplay.clear()

backlight=[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,
    1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1]

# change brightness of backlight...
while True:
    for brightness in backlight:
        picodisplay.set_backlight(brightness)
        picodisplay.update()
        utime.sleep_ms(200)