Add initial source only examples (requires clean up, just copied source blocks from .ipynb's)

Author: malcolm-sparkfun

source_only_examples/project1_a.py

@@ -0,0 +1,20 @@
+from machine import Pin
+
+led_pin = Pin(34, Pin.OUT)
+led_pin.high()
+led_pin.low()
+
+from time import sleep
+led_pin.high()
+sleep(1)
+led_pin.low()
+sleep(1)
+led_pin.high()
+sleep(1)
+led_pin.low()
+
+for i in range(10):
+    led_pin.high()
+    sleep(1)
+    led_pin.low()
+    sleep(1)

source_only_examples/project1_b.py

@@ -0,0 +1,36 @@
+from machine import Pin # Allows us to use "Pin" to use code to interface with the pins on our board
+
+from machine import ADC # Allows us to use "ADC" (analog-to-digital conversion) to read from our analog pin
+
+led_pin = Pin(34, Pin.OUT) # Create a pin variable for the led pin (pin 34)
+potentiometer = ADC(Pin.board.A0) # Create an ADC variable for reading the potentiometer value from analog pin A0
+
+# Try moving the potentiometer and re-running this cell and you should see this value change.
+print(potentiometer.read_u16()) # Use the "read_u16" method to read the value of our potentiometer.
+
+# Now, let's blink the LED with different speeds based on the potentiometer input
+import time # Allows us to use "time.sleep()" to delay for a certain number of seconds
+
+# Infinite loop so this cell keeps running until we stop it.
+while True:
+    potPosition = potentiometer.read_u16() # Get the new potentiometer position (0 - 65535)
+
+    # Lets choose a delay that is proportional to the potentiometer reading
+    # Since the range of the potentiometer is 0-65535 and we want delays between 0-2 seconds, 
+    # we will divide by (65535 / 2 ) = 32767.5
+    delay = (potPosition / 32767.5) 
+
+    # We will comment out the print for now since it can spam our console when the delay is fairly low
+    # print(f"Potentiometer Value: {potPosition : 5}", end='\r') # Print our potentiometer reading (don't mind the fanciness of this line it just makes the print format nicely)
+
+    # Turn on the LED
+    led_pin.high()
+
+    # Delay based on potentiometer position
+    time.sleep(delay)
+    
+    # Turn off the LED
+    led_pin.low()
+    
+    # Delay based on potentiometer position
+    time.sleep(delay)

source_only_examples/project1_c.py

@@ -0,0 +1,31 @@
+from machine import Pin # Allows us to use "Pin" to use code to interface with the pins on our board
+
+from machine import ADC # Allows us to use "ADC" (analog-to-digital conversion) to read from our analog pin
+
+led_pin = Pin(34, Pin.OUT) # Create a pin variable for the led pin (pin 34)
+photoresistor = ADC(Pin.board.A0) # Create an ADC variable for reading the photoresistor value from analog pin A0
+
+# Try moving the potentiometer and re-running this cell and you should see this value change.
+print(photoresistor.read_u16()) # Use the "read_u16" method to read the value of our potentiometer.
+
+# Now, let's turn the LED on and off based on the photoresistor value.
+import time # Allows us to use "time.sleep()" to delay for a certain number of seconds
+
+# We'll set our threshold to half of the maximum value of the ADC reading (65535)
+threshold = 65535 / 2 
+
+# Infinite loop so this cell keeps running until we stop it.
+while True:
+    photoValue = photoresistor.read_u16() # Get the new photoresistor value (0 - 65535)
+
+    print(f"Photoresistor Value: {photoValue : 5}", end='\r') # Print our Photoresistor reading (don't mind the fanciness of this line it just makes the print format nicely)
+
+    # Turn on the LED but only if the photoresistor value is above the threshold
+    if photoValue > threshold:
+        led_pin.high()
+    else:
+        led_pin.low()
+
+    # A short delay to make the printout easier to read
+    time.sleep(0.250)
+

source_only_examples/project1_d.py

@@ -0,0 +1,104 @@
+from machine import Pin # Allows us to use "Pin" to use code to interface with the pins on our board
+
+from machine import ADC # Allows us to use "ADC" (analog-to-digital conversion) to read from our analog pin
+
+from machine import PWM # Allows us to use "PWM" (pulse-width modulation) to control the brightness of our LED
+
+import time # Import the time module to use sleep for delays
+
+pwmBlue  = PWM(Pin(32), freq=1000, duty_u16=0) # Create a PWM object on pin 28 with a frequency of 1000Hz and an initial "on time" of 0 (off)
+pwmGreen = PWM(Pin(30), freq=1000, duty_u16=0) # Create a PWM object on pin 27 with a frequency of 1000Hz and an initial "on time" of 0 (off)
+pwmRed   = PWM(Pin(28), freq=1000, duty_u16=0) # Create a PWM object on pin 26 with a frequency of 1000Hz and an initial "on time" of 0 (off)
+
+# Let's create functions for various colors that we can call later
+
+# Since our PWM "on time" or duty cycle is 16 bits, it is a value between 0 and 65535.
+# It's useful to store a variable for maximum brightness so we can use percentages of it easily.
+kMaximumBrightness = 65535  # Maximum brightness value for PWM
+
+# These are "functions" that we can "call" to set the color of the LED.
+# Notice the "def" keyword, which is used to define a function in Python.
+# Now, we can call these later by just typing their names like `red()`, `green()`, etc.
+# And all the code inside the function will run.
+
+def red():
+    # The "duty_u16" method sets the duty cycle or "on time" for the PWM pin.
+    pwmRed.duty_u16(kMaximumBrightness)  # Set the red LED to full brightness
+    pwmGreen.duty_u16(0)    # Turn off the green LED
+    pwmBlue.duty_u16(0)     # Turn off the blue LED
+
+def orange():
+    pwmRed.duty_u16(kMaximumBrightness)  # Set the red LED to full brightness
+    pwmGreen.duty_u16(int(kMaximumBrightness * 0.25))  # Set the green LED to quarter brightness (by multiplying by 0.5)
+    pwmBlue.duty_u16(0)     # Turn off the blue LED
+
+def yellow():
+    pwmRed.duty_u16(kMaximumBrightness)  # Set the red LED to full brightness
+    pwmGreen.duty_u16(kMaximumBrightness)  # Set the green LED to full brightness
+    pwmBlue.duty_u16(0)     # Turn off the blue LED
+
+def green():
+    pwmRed.duty_u16(0)      # Turn off the red LED
+    pwmGreen.duty_u16(kMaximumBrightness)  # Set the green LED to full brightness
+    pwmBlue.duty_u16(0)     # Turn off the blue LED
+
+def cyan():
+    pwmRed.duty_u16(0)      # Turn off the red LED
+    pwmGreen.duty_u16(kMaximumBrightness)  # Set the green LED to full brightness
+    pwmBlue.duty_u16(kMaximumBrightness)  # Set the blue LED to full brightness
+
+def blue():
+    pwmRed.duty_u16(0)      # Turn off the red LED
+    pwmGreen.duty_u16(0)    # Turn off the green LED
+    pwmBlue.duty_u16(kMaximumBrightness)  # Set the blue LED to full brightness
+
+def magenta():
+    pwmRed.duty_u16(kMaximumBrightness)  # Set the red LED to full brightness
+    pwmGreen.duty_u16(0)    # Turn off the green LED
+    pwmBlue.duty_u16(kMaximumBrightness)  # Set the blue LED to full brightness
+
+def turnOff():
+    pwmRed.duty_u16(0)      # Turn off the red LED
+    pwmGreen.duty_u16(0)    # Turn off the green LED
+    pwmBlue.duty_u16(0)     # Turn off the blue LED
+
+
+# Remember, we've already defined our RGB pins and functions above. 
+# Make sure you have run the cells above this one first!!!
+photoresistor = ADC(Pin.board.A0) # Create an ADC variable for reading the photoresistor value from analog pin A0
+potentiometer = ADC(Pin.board.A1) # Create an ADC variable for reading the potentiometer value from analog pin A1
+
+# We'll set our photo-resistor threshold to a quarter of the maximum value of the ADC reading (65535)
+threshold = 65535 / 4
+potentiometerMax = 65535  # Maximum value for the potentiometer reading 
+
+# Infinite loop to continously read the photoresistor and potentiometer values
+while True:
+    photoValue = photoresistor.read_u16()  # Read the photoresistor value (0 to 65535)
+    potPosition = potentiometer.read_u16()  # Read the potentiometer value (0 to 65535)
+    # Print the values to the console
+    print(f"Photoresistor Value: {photoValue: 5}, Potentiometer Value: {potPosition : 5}", end='\r') # Print our readings (don't mind the fanciness of this line it just makes the print format nicely)
+
+    # Check if the photoresistor value is below the threshold
+    if photoValue < threshold:
+        # If the photoresistor value is below the threshold, set the LED color based on the potentiometer position
+        # Let's split the range 0 - 65535 into 7 equal(ish) parts for different colors
+        if potPosition > 0 and potPosition < 9362: 
+            red()
+        if potPosition >= 9362 and potPosition < 18725: 
+            orange()
+        if potPosition >= 18725 and potPosition < 28087:
+            yellow()
+        if potPosition >= 28087 and potPosition < 37450:
+            green()
+        if potPosition >= 37450 and potPosition < 46812:
+            cyan()
+        if potPosition >= 46812 and potPosition < 56175:
+            blue()
+        if potPosition >= 56175 and potPosition <= 65535:
+            magenta()
+
+    else: # Note that this "else" aligns with the photovalue < Threshold condition above.
+        turnOff()  # Turn off the LED if the photoresistor value is above the threshold
+    
+    time.sleep(0.250)  # Sleep for 0.25 seconds to avoid flooding the console with prints

source_only_examples/project2_a.py

@@ -0,0 +1,73 @@
+from machine import Pin # Allows us to use "Pin" to use code to interface with the pins on our board
+from machine import PWM # Allows us to use "PWM" (pulse-width modulation) to control the brightness of our LED
+
+pwmSpeaker  = PWM(Pin(34), freq=0, duty_u16=0) # Create a PWM object on pin 34 with a frequency of 0Hz and an initial "on time" of 0 (off)
+
+from time import sleep # Import the sleep function to pause execution for a specified duration
+beatLength = 0.25 # Define the length of a beat in seconds (0.5 seconds). Change this to adjust the tempo of the music.
+restLength = 0.05 # Define the length of a rest in seconds (0.25 seconds). Change this to adjust the length of pauses in the music.
+
+def play(note, beats):
+    # To define a list we put it in square brackets []
+    # These list is used to look up the frequency of each note
+    notes = ['c', 'd', 'e', 'f', 'g', 'a', 'b', 'C', 'D', 'E', 'F', 'G', 'A', 'B', ' ']
+    # This list contains the frequencies corresponding to the notes in the "notes" list
+    # For example the 4th item in the "notes" list is 'f' and the 4th item in the "frequencies" list is 175Hz, its frequency
+    frequencies = [131, 147, 165, 175, 196, 220, 247, 262, 294, 330, 349, 392, 440, 494, 0]
+    
+    # We will now search our lists for a match
+    frequency = 0 
+
+    # This loop will step through each note in the "notes" list and look for a match with the "note" variable
+    # Notice the len(notes) function returns the number of items in the "notes" list
+    # The range function creates a sequence of numbers from 0 to len(notes) - 1
+    # The "for" loop will repeat for each number in that sequence
+    for i in range(len(notes)):
+        if notes[i] == note:  # If the note matches the current note in the list
+            frequency = frequencies[i]  # Get the corresponding frequency
+    
+    pwmSpeaker.freq(frequency)   # Set the frequency of the PWM signal to the specified frequency
+    if frequency == 0: # If the frequency is 0, it means we are playing a rest (no sound)
+        pwmSpeaker.duty_u16(0)  # Set the duty cycle to 0 (off)
+    else:  # If the frequency is not 0, we are playing a note
+        pwmSpeaker.duty_u16(32768)   # Set the duty cycle to 50% on time (half as loud as possible)
+    sleep(beats * beatLength)    # Wait for the specified number of beats (0.5 seconds per beat)
+    pwmSpeaker.duty_u16(0)       # Turn off the speaker by setting duty cycle to 0
+    sleep(beats * restLength)  # Wait for the specified number of rests (0.25 seconds per rest)
+
+# Happy Birthday melody using the play() function
+play('g', 2)    # ha
+play('g', 1)    # ppy
+play('a', 4)    # birth
+play('g', 4)    # day
+play('C', 4)    # to
+play('b', 4)    # you
+
+play(' ', 2)    # pause for 2 beats
+
+play('g', 2)    # ha
+play('g', 1)    # ppy
+play('a', 4)    # birth
+play('g', 4)    # day
+play('D', 4)    # to
+play('C', 4)    # you
+
+play(' ', 2)    # pause for 2 beats
+
+play('g', 2)    # ha
+play('g', 1)    # ppy
+play('G', 4)    # birth
+play('E', 4)    # day
+play('C', 4)    # dear
+play('b', 4)    # your
+play('a', 6)    # name
+
+play(' ', 2)    # pause for 2 beats
+
+play('F', 2)    # ha
+play('F', 1)    # ppy
+play('E', 4)    # birth
+play('C', 4)    # day
+play('D', 4)    # to
+play('C', 6)    # you
+

source_only_examples/project2_b.py

@@ -0,0 +1,34 @@
+from machine import Pin # Allows us to use "Pin" to use code to interface with the pins on our board
+from machine import PWM # Allows us to use "PWM" (pulse-width modulation) to control the brightness of our LED
+
+firstKeyPin = Pin(33, Pin.IN, Pin.PULL_UP) # Create a Pin object for the first key on pin 33, set as input with pull-up resistor
+secondKeyPin = Pin(32, Pin.IN, Pin.PULL_UP) # Create a Pin object for the second key on pin 32, set as input with pull-up resistor
+thirdKeyPin = Pin(31, Pin.IN, Pin.PULL_UP) # Create a Pin object for the third key on pin 35, set as input with pull-up resistor
+
+pwmSpeaker  = PWM(Pin(34), freq=0, duty_u16=0) # Create a PWM object on pin 34 with a frequency of 0Hz and an initial "on time" of 0 (off)
+
+# In an infinite loop, we will check the state of the keys and play a note when a key is pressed
+while True:
+    if firstKeyPin.value() == 0: # If the first key is pressed (value is low)
+        pwmSpeaker.freq(262) # Play the note C (262Hz)
+        pwmSpeaker.duty_u16(32768) # Set the duty cycle to 50% (half as loud as possible)
+    elif secondKeyPin.value() == 0: # If the second key is pressed (value is low)
+        pwmSpeaker.freq(330) # Play the note E (330Hz)
+        pwmSpeaker.duty_u16(32768) # Set the duty cycle to 50% (half as loud as possible)
+    elif thirdKeyPin.value() == 0: # If the third key is pressed (value is low)
+        pwmSpeaker.freq(392) # Play the note G (392Hz)
+        pwmSpeaker.duty_u16(32768) # Set the duty cycle to 50% (half as loud as possible)
+    else: # If no key is pressed
+        pwmSpeaker.freq(0)
+        pwmSpeaker.duty_u16(0) # turn off the speaker    
+
+# Frequency Table: Feel free to change the frequencies for each button press to play different notes.
+# note  frequency
+# c     262 Hz
+# d     294 Hz
+# e     330 Hz
+# f     349 Hz
+# g     392 Hz
+# a     440 Hz
+# b     494 Hz
+# C     523 Hz