| Latest revision |
Your text |
| Line 23: |
Line 23: |
| | | | |
| | [[File:Box1.JPG|x300px]] | | [[File:Box1.JPG|x300px]] |
| − |
| |
| − |
| |
| − | == Script used to kickoff the session ==
| |
| − |
| |
| − | <syntaxhighlight lang="python" line>
| |
| − |
| |
| − | ###############################################################
| |
| − | # WS2812 RGB LED Ring Light Breathing
| |
| − | # with the Raspberry Pi Pico Microcontroller
| |
| − | #
| |
| − | # by Joshua Hrisko, Maker Portal LLC (c) 2021
| |
| − | # https://makersportal.com/blog/ws2812-ring-light-with-raspberry-pi-pico
| |
| − | #
| |
| − | # Based on the Example neopixel_ring at:
| |
| − | # https://github.com/raspberrypi/pico-micropython-examples
| |
| − | ###############################################################
| |
| − | #
| |
| − | import array, time, utime
| |
| − | from machine import Pin
| |
| − | import rp2
| |
| − |
| |
| − | #
| |
| − | ############################################
| |
| − | # RP2040 PIO and Pin Configurations
| |
| − | ############################################
| |
| − | #
| |
| − | # WS2812 LED Ring Configuration
| |
| − | led_count = 12 # number of LEDs in ring light
| |
| − | PIN_NUM = 13 # pin connected to ring light
| |
| − | brightness = 1.0 # 0.1 = darker, 1.0 = brightest
| |
| − |
| |
| − | #
| |
| − | ############################################
| |
| − | # Photoresistor declaration
| |
| − | ############################################
| |
| − | #
| |
| − | photoresistor_out = Pin(27, Pin.OUT)
| |
| − | photoresistor_out.on()
| |
| − | photoresistor_adc_read = machine.ADC(26)
| |
| − |
| |
| − | #
| |
| − | ############################################
| |
| − | # HC-SR04 distance sensor declaration
| |
| − | ############################################
| |
| − | #
| |
| − |
| |
| − | distance_echo = Pin(17, Pin.IN)
| |
| − | distance_trigger = Pin(16, Pin.OUT)
| |
| − | distance = 0
| |
| − |
| |
| − |
| |
| − | @rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT,
| |
| − | autopull=True, pull_thresh=24) # PIO configuration
| |
| − |
| |
| − | # define WS2812 parameters
| |
| − | def ws2812():
| |
| − | T1 = 2
| |
| − | T2 = 5
| |
| − | T3 = 3
| |
| − | wrap_target()
| |
| − | label("bitloop")
| |
| − | out(x, 1) .side(0) [T3 - 1]
| |
| − | jmp(not_x, "do_zero") .side(1) [T1 - 1]
| |
| − | jmp("bitloop") .side(1) [T2 - 1]
| |
| − | label("do_zero")
| |
| − | nop() .side(0) [T2 - 1]
| |
| − | wrap()
| |
| − |
| |
| − |
| |
| − | # Create the StateMachine with the ws2812 program, outputting on pre-defined pin
| |
| − | # at the 8MHz frequency
| |
| − | sm = rp2.StateMachine(0, ws2812, freq=8_000_000, sideset_base=Pin(PIN_NUM))
| |
| − |
| |
| − | # Activate the state machine
| |
| − | sm.active(1)
| |
| − |
| |
| − | # Range of LEDs stored in an array
| |
| − | ar = array.array("I", [0 for _ in range(led_count)])
| |
| − | #
| |
| − | ############################################
| |
| − | # Functions for RGB Coloring
| |
| − | ############################################
| |
| − | #
| |
| − | def pixels_show(brightness_input=brightness):
| |
| − | dimmer_ar = array.array("I", [0 for _ in range(led_count)])
| |
| − | for ii,cc in enumerate(ar):
| |
| − | r = int(((cc >> 8) & 0xFF) * brightness_input) # 8-bit red dimmed to brightness
| |
| − | g = int(((cc >> 16) & 0xFF) * brightness_input) # 8-bit green dimmed to brightness
| |
| − | b = int((cc & 0xFF) * brightness_input) # 8-bit blue dimmed to brightness
| |
| − | dimmer_ar[ii] = (g<<16) + (r<<8) + b # 24-bit color dimmed to brightness
| |
| − | sm.put(dimmer_ar, 8) # update the state machine with new colors
| |
| − | time.sleep_ms(10)
| |
| − |
| |
| − | def pixels_set(i, color):
| |
| − | ar[i] = (color[1]<<16) + (color[0]<<8) + color[2] # set 24-bit color
| |
| − |
| |
| − | def breathing_led(color):
| |
| − | step = 5
| |
| − | breath_amps = [ii for ii in range(0,255,step)]
| |
| − | breath_amps.extend([ii for ii in range(255,-1,-step)])
| |
| − | for ii in breath_amps:
| |
| − | for jj in range(len(ar)):
| |
| − | pixels_set(jj, color) # show all colors
| |
| − | pixels_show(ii/255)
| |
| − | time.sleep(0.02)
| |
| − |
| |
| − | #
| |
| − | ############################################
| |
| − | # Function for HC-SR04 readout
| |
| − | ############################################
| |
| − | #
| |
| − |
| |
| − | def ultra():
| |
| − | distance_trigger.low()
| |
| − | utime.sleep_us(2)
| |
| − | distance_trigger.high()
| |
| − | utime.sleep_us(5)
| |
| − | distance_trigger.low()
| |
| − | while distance_echo.value() == 0:
| |
| − | signaloff = utime.ticks_us()
| |
| − | while distance_echo.value() == 1:
| |
| − | signalon = utime.ticks_us()
| |
| − | timepassed = signalon - signaloff
| |
| − | global distance
| |
| − | distance = (timepassed * 0.0343) / 2
| |
| − | #print("Distance:",distance,"cm")
| |
| − |
| |
| − |
| |
| − | #
| |
| − | ############################################
| |
| − | # Main Calls and Loops
| |
| − | ############################################
| |
| − | #
| |
| − |
| |
| − | color = (255,0,0) # looping color
| |
| − | blank = (255,255,255) # color for other pixels
| |
| − | cycles = 25 # number of times to cycle 360-degrees
| |
| − | for ii in range(int(cycles*len(ar))+1):
| |
| − |
| |
| − | for jj in range(len(ar)):
| |
| − | if jj==int(ii%led_count): # in case we go over number of pixels in array
| |
| − | pixels_set(jj,color) # color and loop a single pixel
| |
| − | else:
| |
| − | pixels_set(jj,blank) # turn others off
| |
| − |
| |
| − | photoresistor_corrected_readout = photoresistor_adc_read.read_u16() - 60000
| |
| − | photoresistor_ratio = photoresistor_corrected_readout / 5535.0
| |
| − |
| |
| − | brightness = photoresistor_corrected_readout / (5535.0 * (1 / photoresistor_ratio))
| |
| − | #print(brightness)
| |
| − |
| |
| − | pixels_show(brightness) # update pixel colors
| |
| − | time.sleep(0.05) # wait 50ms
| |
| − |
| |
| − | ##below: breathing LED
| |
| − | red = (255,0,0)
| |
| − | green = (0,255,0)
| |
| − | blue = (0,0,255)
| |
| − | yellow = (255,255,0)
| |
| − | cyan = (0,255,255)
| |
| − | white = (255,255,255)
| |
| − | blank = (0,0,0)
| |
| − | colors = [blue,yellow,cyan,red,white, green]
| |
| − |
| |
| − |
| |
| − |
| |
| − | while True: # loop indefinitely
| |
| − |
| |
| − | ultra()
| |
| − |
| |
| − | MAXIMUM_DISTANCE = 120
| |
| − |
| |
| − | if distance > MAXIMUM_DISTANCE - 1:
| |
| − | distance_corrected = MAXIMUM_DISTANCE - 1
| |
| − | else:
| |
| − | distance_corrected = distance
| |
| − |
| |
| − | range_per_color = MAXIMUM_DISTANCE / len(colors)
| |
| − |
| |
| − |
| |
| − | breathing_led(colors[(int)(distance_corrected / range_per_color)])
| |
| − |
| |
| − | </syntaxhighlight>
| |
