————— PROJECT 1 —————

import board
import digitalio
import time

led = digitalio.DigitalInOut(board.D13)
led.direction = digitalio.Direction.OUTPUT

while True:
        led.value = True
        time.sleep(0.5)
        led.value = False
        time.sleep(0.5)

————— PROJECT 2 —————

# Gives access to the board hardware

import board
# digitalio : Module that provides classes you can use to interact
# with digital components
# DigitalInOut : Digital pin object that provides functions and
# parameters you can set for a digital pin
# Direction : Define if digital pin excepts input or provides output
# Pull : Define default for input (Up : High, Down: Low)
from digitalio import DigitalInOut, Direction, Pull
# Allows us to work with NeoPixels
# You need to put the library in the lib folder
import neopixel
# Allows use to pause code execution
import time

# Assign led to pin D13

led = DigitalInOut(board.D13)
# Set that the led will output (Turn on and off)
led.direction = Direction.OUTPUT

# Say we want to manipulate up to 1 NeoPixel

pixels = neopixel.NeoPixel(board.NEOPIXEL, 2, brightness=0.1)

# Assign a_but to pin / button D4

a_but = DigitalInOut(board.D4)
# Set that it is an input pin
a_but.direction = Direction.INPUT
# Set it to low by default
a_but.pull = Pull.DOWN

# Do the same for button b

b_but = DigitalInOut(board.D5)
b_but.direction = Direction.INPUT
b_but.pull = Pull.DOWN

# Do the same for the switch except set pull to UP

switch = DigitalInOut(board.D7)
switch.direction = Direction.INPUT
switch.pull = Pull.UP

# This loops forever

while True:
        # If A button is pressed the led turns on
        if a_but.value:
                led.value = True
                print("A Pressed")
        else:
                led.value = False
                print("A Not Pressed")
        
        # If B button is pressed the NeoPixel lights up Red
        # 0 refers to the 1st pixel
        if b_but.value:
                pixels[0] = (255, 0, 0)
                print("B Pressed")
        # Otherwise it turns off
        else:
                pixels[0] = (0, 0, 0)
                print("A Not Pressed")
        
        if switch.value:
                pixels[1] = (0, 255, 0)
                print("Switch On")
        else:
                pixels[1] = (0, 0, 0)
                print("Switch Off")
        
        time.sleep(0.2)

————— PROJECT 3 —————

import math
import time
# Accurate to 5 digits
f1 = 1.111111
f2 = 1.111111
print(f1 + f2)
# Cast with int, float, str
print("Cast ", int(f1))
# Math Operators
print("5 + 2 =", 5 + 2)
# Formatted print with 2 decimals or less
print("5 - 2 = {:.2f}".format(5 - 2))
print("5 * 2 =", 5 * 2)
print("5 / 2 =", 5 / 2)
print("5 % 2 =", 5 % 2)
print("5 ** 2 =", 5 ** 2)
print("5 // 2 =", 5 // 2)

# ----- Math Functions -----

print("abs(-1) ", abs(-1))
print("max(5, 4) ", max(5, 4))
print("min(5, 4) ", min(5, 4))
print("pow(2, 2) ", pow(2, 2))
print("ceil(4.5) ", math.ceil(4.5))
print("floor(4.5) ", math.floor(4.5))
print("round(4.5) ", round(4.5))
print("exp(1) ", math.exp(1))    # e**x
print("log(e) ", math.log(math.exp(1)))
print("log(100) ", math.log(100, 10))    # Base 10 Log
print("sqrt(100) ", math.sqrt(100))
print("sin(0) ", math.sin(0))
print("cos(0) ", math.cos(0))
print("tan(0) ", math.tan(0))
print("asin(0) ", math.asin(0))
print("acos(0) ", math.acos(0))
print("atan(0) ", math.atan(0))
print("radians(0) ", math.radians(0))
print("degrees(pi) ", math.degrees(math.pi))

# Random number between 1 and 100

print("Random", random.randint(1, 101))

————— PROJECT 4 —————

import time
import board
from analogio import AnalogIn
import neopixel

# Connect A1 as an analog input

analog_in = AnalogIn(board.A3)

# Holds the pixel count before changes

px_prev_num = 0

# Holds changing pixel count

px_cur_num = 0

# Create a pixel list with a maximum of 10 pixels

pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=0.1)

def update_pixels():
        # If number of pixels to light changed clear
        # and redraw with new value
        if px_prev_num is not px_cur_num:
                pixels.fill(0)
        # Cycles through and lights pixels as voltage changes
        for i in range(num_pixels):
                pixels[i] = (255, 0, 0)

while True:
        # Readings range from 0 to 65535
        a_val = analog_in.value
        # Convert to a range from 0 to 3.3V
        print((a_val * 3.3) / 65536)

        # Put analog value into values of 0 to 10

        px_cur_num = int(a_val / 6553)
        update_pixels()
        time.sleep(.2)

————— PROJECT 5 —————

# Tons of display functions

import displayio
# Provides font
import terminalio
# Provides label
from adafruit_display_text import label
# Functions for the Gizmo display
from adafruit_gizmo import tft_gizmo
# Used for sleep
import time
# Access to analogio hardware
import analogio
# Access to CPB Hardware
import board
# Temperature sensor
import adafruit_thermistor
# Used for sound sensor
from adafruit_circuitplayground import cp

# Create the TFT Gizmo display object

display = tft_gizmo.TFT_Gizmo()

# Create a group we can add 10 elements to

splash = displayio.Group(max_size=30)
# Display the group of elements
display.show(splash)

# Get temperature data in F

temp_f = cp.temperature * 9 / 5 + 32
temp_str = "Temp: " + str(temp_f) + "\n"

# Get sound volume

sound_str = "Sound: " + str(cp.sound_level) + "\n"

# Get access to light sensor data

light_str = "Light: " + str(cp.light) + "\n"

# Get tilt information

x, y, z = cp.acceleration
tilt_str = "X: " + str(x) + "\nY: " + str(y) + "\nZ: " + str(z)

# Draw a label
# Set size and scale it by 2 placing it at x/y position
text_group = displayio.Group(max_size=10, scale=2, x=10, y=10)
# Text to display
text = temp_str + sound_str + light_str + tilt_str
# Use the terminalio font in yellow
text_area = label.Label(terminalio.FONT, text=text, color=0xFFFF00)
# Append to a subgroup
text_group.append(text_area)
# Add text to screen
splash.append(text_group)
# Infinite loop that updates data and display
while True:
        # Sleep for 1 second and then update data and screen
        time.sleep(1)

        temp_f = cp.temperature * 9 / 5 + 32
        temp_str = "Temp: " + str(temp_f) + "\n"
        sound_str = "Sound: " + str(cp.sound_level) + "\n"
        light_str = "Light: " + str(cp.light) + "\n"
        x, y, z = cp.acceleration
        tilt_str = "X: " + str(x) + "\nY: " + str(y) + "\nZ: " + str(z)

        text_area.text = temp_str + sound_str + light_str + tilt_str

        display.show(splash)
        display.refresh()

————— PROJECT 6 —————

# ----- Conditionals -----

# Comparison Operators : < > <= >= == !=
# Logical Operators : and or not
age = 6
if age < 5:
        print("Stay Home")
elif (age >= 5) and (age < 6):
        print("Kindergarten")
elif (age >= 6) and (age <= 17):
        print("Grade {:d}".format(age - 5))
else:
        print("College")

————— PROJECT 7 —————

# Tons of hardware functions

from adafruit_circuitplayground import cp
import time

# Define that we react based on 1 tap

# Can also be set to 2
cp.detect_taps = 1

NOTE_C4 = 261.63
NOTE_D4 = 293.66
NOTE_E4 = 329.63
# List of Mary Lil Lamb Notes
l1 = [NOTE_E4, NOTE_D4, NOTE_C4, NOTE_D4, NOTE_E4, NOTE_E4, NOTE_E4]

while True:
        # Mary Lil Lamb : E D C D E E E
        # D D D E G G    E D C D E E E    E D D E D C
        if cp.tapped:
                print("Tap")
                # Frequency for middle C4 with 1s duration
                cp.play_tone(261.63, .5)
        # D4
        if cp.button_a:
                cp.play_tone(293.66, .5)
        # E4
        if cp.button_b:
                cp.play_tone(329.63, .5)
        # G4
        if cp.touch_A1:
                cp.play_tone(392.00, .5)
        if cp.touch_A2:
                for i in range(len(l1)):
                        cp.play_tone(l1[i], .5)

————— PROJECT 8 —————

# Provides functions for reading IR input

import pulseio
import board
# Provides functions for decoding IR input
import adafruit_irremote

# Read IR input from pin IR Receiver,

# record up to 120 pulses and turn idle state on
pulsein = pulseio.PulseIn(board.IR_RX, maxlen=120, idle_state=True)
# Decodes infrared signals
decoder = adafruit_irremote.GenericDecode()

while True:
        # Read pulses until they stop
        pulses = decoder.read_pulses(pulsein)
        try:
                # Decodes the pulses into bits
                received_code = decoder.decode_bits(pulses)
                print("Decoded : ", received_code)
        except adafruit_irremote.IRNECRepeatException:
                print("Received Strange Code")
                continue
        except adafruit_irremote.IRDecodeException as e:
                print("Failed to decode")
                continue

# Power : [255, 0, 93, 162]

# 1 : [255, 0, 207, 48]
# 2 : [255, 0, 231, 24]
# 3 : [255, 0, 133, 122]
# 5 : [255, 0, 199, 56]

————— PROJECT 9 —————

import time
from adafruit_crickit import crickit

print("Test Servo")
crickit.servo_1.angle = 15
time.sleep(1)
crickit.servo_1.angle = 90
time.sleep(1)
crickit.servo_1.angle = 165
time.sleep(1)

while True:
        print("Repeat")
        crickit.servo_1.angle = 15            # right
        time.sleep(1)
        crickit.servo_1.angle = 90          # middle
        time.sleep(1)
        crickit.servo_1.angle = 165        # left
        time.sleep(1)
        crickit.servo_1.angle = 90          # middle
        time.sleep(1)
        # and repeat!

————— PROJECT 10 —————

import time
import board
import pwmio
from adafruit_motor import servo
# Creates a PWMOut object and assigns pin A3 to it
# The duty cycle is the percent in which the pulse is high
# Frequency in hertz
pwm = pwmio.PWMOut(board.A3, duty_cycle=2 ** 15, frequency=50)

# Creates a servo object that is passed all the data

# assigned to the PWMOut object
my_servo = servo.Servo(pwm)

while True:
        for angle in range(15, 165, 5):    # 15 - 165 degrees, 5 degrees at a time.
                my_servo.angle = angle
                time.sleep(0.05)
        for angle in range(165, 15, -5): # 165 - 15 degrees, 5 degrees at a time.
                my_servo.angle = angle
                time.sleep(0.05)

————— PROJECT 11 —————

import time
import board
import adafruit_hcsr04

# For the library to work you just define where the trigger and echo pins
# are connected
# A2 is D9 and A3 is D10
sonar = adafruit_hcsr04.HCSR04(trigger_pin=board.D9, echo_pin=board.D10)

while True:
        try:
                # Returns distance in cms
                print(sonar.distance)
        except RuntimeError:
                print("Retrying!")
        time.sleep(0.1)

————— PROJECT 12 —————

import time
import board
import adafruit_hcsr04
# Needed for the Crickit
from adafruit_crickit import crickit

# For the library to work you just define where the trigger and echo pins
# are connected
# A2 is D9 and A3 is D10
sonar = adafruit_hcsr04.HCSR04(trigger_pin=board.D9, echo_pin=board.D10)

# Allows us to manipulate motor speed and direction

m_1 = crickit.dc_motor_1
m_2 = crickit.dc_motor_2

while True:
        try:
                # Go forward 100% with both tires
                m_1.throttle = -1
                m_2.throttle = 1
                # Returns the distance in cms
                s_dist = sonar.distance
        
                if s_dist <= 20:
                        m_1.throttle = 1
                        m_2.throttle = 0
                        print(s_dist)
                        time.sleep(1.5)
                else:
                        m_1.throttle = -1
                        m_2.throttle = 1
        
        except RuntimeError:
                print("Error")

————— PROJECT 13 —————

# Provides functions for reading IR input

import pulseio
import board
# Provides functions for decoding IR input
import adafruit_irremote
from adafruit_crickit import crickit

is_off = True

m_1 = crickit.dc_motor_1
m_2 = crickit.dc_motor_2

pow_b = 162
left_b = 48
forward_b = 24
right_b = 122
back_b = 56

# Read IR input from pin D2, record up to 120 pulses and turn idle state on
pulsein = pulseio.PulseIn(board.IR_RX, maxlen=120, idle_state=True)
# Decodes infrared signals
decoder = adafruit_irremote.GenericDecode()

while True:
        # Read pulses until they stop
        pulses = decoder.read_pulses(pulsein)
        # Output number of pulses and their values in a list
        print("Heard", len(pulses), "Pulses:", pulses)
        try:
                # Decodes the pulses into bits
                code = decoder.decode_bits(pulses)
                print("Decoded:", code)
        
                if (code[3] == pow_b) and is_off:
                        print("On")
                        is_off = False
                        m_1.throttle = -1
                        m_2.throttle = 1
                        continue
            
                if (code[3] == pow_b) and not is_off:
                        print("Off")
                        is_off = True
                        m_1.throttle = 0
                        m_2.throttle = 0
                        continue
            
                if (code[3] == left_b) and not is_off:
                        print("Left")
                        is_off = False
                        m_1.throttle = -1
                        m_2.throttle = 0
                        continue
            
                if (code[3] == right_b) and not is_off:
                        print("Right")
                        is_off = False
                        m_1.throttle = 0
                        m_2.throttle = 1
                        continue
            
                if (code[3] == forward_b) and not is_off:
                        print("Forward")
                        is_off = False
                        m_1.throttle = -1
                        m_2.throttle = 1
                        continue
            
                if (code[3] == back_b) and not is_off:
                        print("Backward")
                        is_off = False
                        m_1.throttle = 1
                        m_2.throttle = -1
                        continue
        
        except adafruit_irremote.IRNECRepeatException: # unusual short code!
                print("NEC repeat!")
        except adafruit_irremote.IRDecodeException as e: # failed to decode
                print("Failed to decode: ", e.args)

————— MORE NOT IN VIDEO —————

1. Import board -> dir(board) : Lists hardware on your board

2. There are Pins that are easy to identify
3. The CPB and CPX come with an accelerometer that provide acceleration data in
the X, Y, Z direction as well as taps and shakes in m/s2 (Measured by attaching a mass
to a spring that is between plates. Capacitance changes between the plates and the
mass when moved. )
4. The microcontroller communicates with slave components like the accelerometer
using the Inter-Integrated Circuit protocol (I2C) I Squared C.
5. Each slave component has a unique address. When the microcontroller wants a
slave to do something it sends a message to every slave with a unique address so the
slave knows which one is supposed to respond to the message.
6. The interrupt can signal to the microprocessor that it needs to be addressed
7. SCL : Clock Pin that sends a clock signal.
8. SDA : Data pin that is used to send and receive data.
9. The SCL and SDA fluctuate in specific ways to signal when a message begins
and ends
10. A Start Signal is sent : SDA folds while SCL stays high
11. Then send the component address which is a 7 digit binary number unique to
each component
12. 0 if write to slave or 1 to read from slave
13. Then bytes (8 bits) of data are sent.
14. A Stop Condition ends the transfer
15. Audio is the A0 port, which you can connect to a headphone or speaker
16. Buttons and digital pins
17. I talked about what I2C, SCL and SDA are
18. L is the D13 LED
19. Light is the light sensor
20. Microphone clock and data (Sound Sensor)
21. The Serial Peripheral Interface (SPI) is also used to send and receive data
a. It uses 3 to 4 wires for sending and receiving data
b. MISO : Main Input Secondary Output
c. MOSI : Main Output Secondary Input
d. SCK : SPI Clock Line
22. Neopixel can interact with any NeoPixel
23. Universal Asynchronous Receiver Transmitter (UART)
a. Transferring of data between 2 devices using only 2 wires asynchronously
b. Asynchronous transfer is when there is no clock signal (Synchronized)
c. The transmitting UART adds start and stop bits to data packets
d. When a start bit is detected data is read in a defined bit per second rate (Baud
Rate)
e. The receiving UART reads data at its RX Pin
f. Data is sent from the TX Pin
24. There is also the power switch, slide switch, speaker and temperature sensor