Deadline Beacon: Take Your Canvas Student Productivity and Turn It Into Cool LEDs

Deadline Beacon is an innovative, task management and notification system designed to ensure you never miss an important assignment again. This project integrates real-time data from your personal Canvas with a Raspberry Pi Pico W, providing both visual and audio alerts that adapt dynamically to your daily schedule. Whether you simply forgot to do an assignment, your professor added a last-minute deadline, or you catch a glance of it unintentionally you will know whether you truly completed all recent canvas assignments with deadline beacon.

Hardware Supplies

1. Raspberry Pi Pico W: Microcontroller with built‑in Wi-Fi for API communication.
2. USB Cable: For powering and programming the Pico W.
3. NeoPixel LED Strip or Ring: For visual status indicators (e.g., 30 LEDs as used in the project).
4. Speaker or Buzzer Module: For audio alerts; ensure compatibility with CircuitPython audio libraries.
5. Breadboard & Jumper Wires: For prototyping and connecting peripherals.
6. Optional – Micro SD Card & Adapter: If you plan to expand storage or audio files (note that file system limitations may apply).

Software & Online Resources

1. CircuitPython Firmware: Installed on your Pico W.
2. Development Environment: VSCode with the CircuitPython extension I used CircuitPython v2 by wmerkens (or any compatible IDE).
3. Required Libraries: Adafruit LED Animation, adafruit_requests, and other CircuitPython libraries.
4. Flask Server on fly.io: A remote server handling API calls (e.g., for Canvas and Google Calendar integration) to help Pico not crash from memory errors. Fly.io is also just a really cheap and accessible site to deploy applications in this case your backend flask server.
5. API Keys & Credentials
6. Canvas Token:
7. What: Your unique access token for Canvas.
8. How to Obtain: Go to your Canvas profile.
9. Navigate to Account > Settings.
10. Generate a new access token.
11. Copy and save it securely in your Flask server workspace.
12. Course IDs:
13. What: Unique identifiers for each course you’re registered in.
14. How to Find: Click on a course in Canvas.
15. Look at the URL—it will display as courses/{COURSE_ID}.
16. Note each ID for later use.

1. Choose an IDE:
2. Use Visual Studio Code (VSCode) for a smooth CircuitPython experience, thanks to its CircuitPython V2 extension.
3. Install CircuitPython Firmware:
4. Download the CircuitPython UF2 file.
5. Connect your Raspberry Pi Pico via USB and drag-and-drop the UF2 file to install the firmware.
6. Hardware Setup:
7. Place your Pico on a breadboard if you’re connecting multiple components.
8. Configure VSCode:
9. Open VSCode and navigate to your Pico (e.g., it may show as drive D:/).
10. Press CTRL+SHIFT+P to open the command palette.
11. Run the CircuitPython Serial Monitor command.
12. Select the correct COM port (e.g., COM10) for your Raspberry Pi Pico.
13. Confirm the connection with a notification like “CircuitPython Serial Monitor [Open] Connection to COM10.”

This setup ensures you can run code smoothly while monitoring terminal logs directly from your Pico.

1. Canvas Access Token:
2. Follow the steps in the Software & Online Resources section.
3. Locate and click the button to generate a new access token (see screenshot for reference).
4. Course IDs:
5. Collect the unique IDs for each class you want to track assignments from (found in your Canvas URL as courses/{COURSE_ID}).
6. Deployment Account:
7. Create a fly.io account (or another service like Render) for deploying your Flask server.
8. Wi-Fi Credentials:
9. Gather the SSID and password for the Wi-Fi network your Pico will use.
10. This information ensures your Pico can connect to your personal server seamlessly.
11. This step sets up all the necessary credentials to connect your project with Canvas, your server, and your network.

1. Breadboard Assembly:
2. Mount your Raspberry Pi Pico on a breadboard to simplify connections and organization.
3. LED Light Strip Wiring:
4. Power (Red Wire): Connect to the Pico’s 5V output.
5. Ground (Black Wire): Connect to a common ground on the breadboard.
6. Data (White Wire): Connect to GPIO0 on the Pico.
7. Speaker/Buzzer Wiring:
8. Speaker Ground: Connect to the Pico’s ground.
9. Speaker Signal (Tip): Connect to GPIO14 on the Pico.
10. Testing:
11. Run a simple test script to verify that the LED strip and speaker are functioning correctly.

This detailed wiring setup ensures that your LED light strip and speaker are connected correctly for optimal performance in your project.

Create Your Workspace:

1. Open your IDE (e.g., VSCode) and create a new project folder.
2. Create a file named main.py with your Flask server code.

Main.py code:

from flask import Flask, jsonify

import requests

import datetime

import pytz

import time

app = Flask(__name__)

# 🔑 Canvas API Token

CANVAS_TOKEN = "YOUR CANVAS TOKEN"

HEADERS = {"Authorization": f"Bearer {CANVAS_TOKEN}"}

# 🎯 Course IDs (enter your course IDs here)

COURSES = {

"Software Engineering": "",

"Algorithms": "",

"Databases": "",

"Philosophy": "",

"Physical Computing": ""

}

# 🌎 Timezone Conversion (UTC to Eastern Time)

ET_ZONE = pytz.timezone("America/New_York")

UTC_ZONE = pytz.utc

def convert_to_et(due_at):

try:

utc_dt = datetime.datetime.strptime(due_at, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=UTC_ZONE)

est_dt = utc_dt.astimezone(ET_ZONE)

return time.mktime(est_dt.timetuple())

except Exception as e:

print(f"❌ Error converting {due_at}: {e}")

return None

def fetch_all_assignments(course_id):

assignments = []

url = f"https://bostoncollege.instructure.com/api/v1/courses/{course_id}/assignments"

while url:

try:

response = requests.get(url, headers=HEADERS)

response.raise_for_status()

assignments.extend(response.json())

url = response.links.get("next", {}).get("url")

except requests.exceptions.RequestException as e:

print(f"❌ Error fetching assignments for course {course_id}: {e}")

break

return assignments

def fetch_todays_assignments():

now_et = datetime.datetime.now(ET_ZONE)

assignments = []

for course_name, course_id in COURSES.items():

course_assignments = fetch_all_assignments(course_id)

print(f"📚 {course_name}: {len(course_assignments)} assignments fetched")

for assignment in course_assignments:

if "due_at" in assignment and assignment["due_at"]:

due_dt = datetime.datetime.strptime(assignment["due_at"], "%Y-%m-%dT%H:%M:%SZ").astimezone(ET_ZONE)

if due_dt >= now_et:

assignments.append({

"name": assignment["name"],

"due_at": assignment["due_at"],

"course": course_name

})

print(f" ✅ Keeping: {assignment['name']} (Due: {assignment['due_at']})")

else:

print(f" ❌ Skipping: {assignment['name']} (Past Due: {assignment['due_at']})")

print(f"✅ Total assignments collected: {len(assignments)}")

return assignments

def determine_status_for_todays_assignments(assignments):

if not assignments:

return "green", [] # No assignments due today

now_et = datetime.datetime.now(ET_ZONE)

now_epoch = time.mktime(now_et.timetuple())

urgent_assignments = []

status = "green"

for assignment in assignments:

due_epoch = convert_to_et(assignment["due_at"])

if not due_epoch:

continue

hours_left = (due_epoch - now_epoch) / 3600.0

print(f" - 📌 {assignment['name']} ({assignment['course']}) | Due: {assignment['due_at']} | Hours Left: {hours_left:.2f}")

if hours_left < 0:

continue

elif hours_left <= 4:

urgent_assignments.append(assignment)

status = "red"

elif hours_left < 24:

status = "yellow"

return status, urgent_assignments

@app.route('/status', methods=['GET'])

def get_status():

print("\n🌎 API Call: /status 🔥")

assignments = fetch_todays_assignments()

status, urgent_assignments = determine_status_for_todays_assignments(assignments)

beep_flag = status == "red"

print(f"\n🚦 STATUS: {status.upper()} | 🔔 Beep: {beep_flag} | Urgent Assignments: {len(urgent_assignments)}")

return jsonify({

"color": status,

"beep": beep_flag,

"urgent_assignments": urgent_assignments

})

if __name__ == '__main__':

app.run(host="0.0.0.0", port=5000)

1. Create a Dockerfile with the following content:

Create the requirements.txt File:

1. In your project folder, create a file named requirements.txt and add these lines:

1. This file tells your server which Python packages to install.

Deploying with fly.io:

1. Log In:
2. Open your terminal and run:

1. This will open your browser for authentication. Sign in to your fly.io account.
2. Initialize Your Application:
3. In your project directory (where your Dockerfile, main.py, and requirements.txt are located), run:

1. Follow the prompts to:
2. Name your app.
3. Select a deployment region.
4. Confirm the creation of a new fly.toml configuration file.
5. Deploy Your Application:
6. Once the app is configured, deploy it by running:

1. This command builds your Docker image using the provided Dockerfile and deploys it to fly.io.
2. Monitor Your Application:
3. To view real-time logs and verify that your server is running correctly, use:

1. Update After Changes:
2. For any code changes, simply redeploy with:

1. After you run the deploy command you will get a URL to where you an access your server you will adding this URL to your code.py for your pico to call
2. Included above is some of the Logs for one of the classes I established in COURSES Algorithms
3. The logs show specifically the assignments its keeping tracking because the deadline has not passed yet
4. In the end of the Picos call to the server it will list with push pins 📌 all assignments yet to be completed and whether it should mark them as Urgent to complete based on the due date and current date

Connect to Wi‑Fi:

1. In your Pico’s code.py, configure the Wi‑Fi credentials so the board can connect to the internet.
2. I put my wifi credentials in config.py and just imported them into code.py

Fetch Server Data:

1. Use the adafruit_requests library to call your server’s /status endpoint (e.g., your-app-name.fly.dev/status).
2. Process the returned JSON data to determine the current state (green, yellow, red).

Update Visual Output:

1. Use the LED light strip to display the corresponding color:
2. Green: No urgent assignments.
3. Yellow: Tasks due within 24 hours.
4. Red: Urgent assignments due within 4 hours.
5. Implement an LED animation (e.g., a comet effect) that runs continuously until new data is fetched.

Trigger Audio Alerts:

1. When the pico call the server again in this case its every 5 minutes to refresh your canvas data and make sure it has not missed anything we play a designated audio file (e.g., a chime) using the connected speaker. To indicate the update.

Loop and Refresh:

1. Continuously fetch updated status from the server (e.g., every 5 minutes) to keep the display and alerts current.
2. I would add a screenshot of what the terminal output on your circuit python serial monitor will look like

Code.py :

import time

import board

import neopixel

import adafruit_requests as requests

import wifi

import ssl

import socketpool

import json

import config

import pwmio

import my_audio

from adafruit_led_animation.animation.comet import Comet

from adafruit_led_animation.color import GREEN, YELLOW, RED

# Server URL

SERVER_URL = "YOUR SERVER URL"

# Initialize NeoPixel LED

NUM_PIXELS = 30

pixel = neopixel.NeoPixel(board.GP0, NUM_PIXELS, auto_write=False)

# Setup Comet animations for each state

green_comet = Comet(pixel, speed=0.1, color=GREEN, tail_length=int(NUM_PIXELS * 0.25))

yellow_comet = Comet(pixel, speed=0.05, color=YELLOW, tail_length=int(NUM_PIXELS * 0.25))

red_comet = Comet(pixel, speed=0.02, color=RED, tail_length=int(NUM_PIXELS * 0.25))

# Connect to Wi-Fi

print("Connecting to Wi-Fi...")

wifi.radio.connect(config.WIFI_SSID, config.WIFI_PASSWORD)

print("Connected to Wi-Fi!")

# Setup requests session

pool = socketpool.SocketPool(wifi.radio)

session = requests.Session(pool, ssl.create_default_context())

def fetch_status():

"""

Fetch the status from the Flask server and return the JSON data.

"""

try:

print(f"Fetching data from {SERVER_URL}...")

response = session.get(SERVER_URL)

if response.status_code == 200:

data = response.json()

print("Server Response:", data)

return data

else:

print("Failed to fetch data, status code:", response.status_code)

return None

except Exception as e:

print("Error fetching server data:", e)

return None

def update_status(data):

"""

Process the server response and return the appropriate comet animation.

"""

course_statuses = data.get("course_statuses", {})

final_state = "green"

yellow_cause = []

red_cause = []

for course, details in course_statuses.items():

course_color = details.get("color", "green")

if course_color == "red":

final_state = "red"

red_cause.extend(details.get("urgent_assignments", []))

break # Prioritize red

elif course_color == "yellow" and final_state != "red":

final_state = "yellow"

yellow_cause.extend(details.get("yellow_assignments", []))

# Choose the appropriate animation based on the final status

if final_state == "red":

print("🔴 Red (Urgent Assignments within 4 hours!)")

for ra in red_cause:

print(f" - {ra['name']} | Due: {ra['due_at']}")

return red_comet

elif final_state == "yellow":

print("🟡 Yellow (Assignments due within 24 hours)")

for ya in yellow_cause:

print(f" - {ya['name']} | Due: {ya['due_at']}")

return yellow_comet

else:

print("🟢 Green (No urgent assignments)")

return green_comet

# Main loop: fetch data, then animate until next fetch

FETCH_INTERVAL = 300 # seconds

while True:

my_audio.play_audio("chime.wav")

data = fetch_status()

if data is None:

current_anim = green_comet

else:

current_anim = update_status(data)

start_time = time.monotonic()

while time.monotonic() - start_time < FETCH_INTERVAL:

current_anim.animate()

time.sleep(0.01)

my_audio.py:

import board,digitalio,neopixel,pwmio,time

import board

from audiocore import WaveFile

from audiopwmio import PWMAudioOut as AudioOut

audio = AudioOut(board.GP14)

path = "audio/"

def play_audio(filename):

with open(path + filename, "rb") as wave_file:

wave = WaveFile(wave_file)

audio.play(wave)

while audio.playing:

pass

config.py:

WIFI_SSID = ""

WIFI_PASSWORD = ""

1. I laser cut a foldable box to store my wiring
2. I placed the hamburger speaker on top of the box so the chimes would be clearly heard and then proceeded to glue it shut
3. The audios path was audio/chime.wav in my D:/ workspace
4. the current my_audio.py works with wav files but could be modified to mp3 if desired
5.