Presenter Guide

Session goal

Build one program in eight small steps. The audience first sees how easily Python can control a physical LED, then gradually adds blinking, joystick input, a display, a sensor, temperature colors, an alarm melody, and joystick alarm control.

These first examples intentionally use the simplest possible code. They do not include connection checks, error handling, or cleanup structures. The goal is to make the first experience with CodyNick clear and approachable.

Do not paste the final program at the beginning. Type each step live, run it, invite the audience to predict the result, and then change the existing program for the next step.

Equipment

Raspberry Pi running CodyNick
CodyJoy Pro
Temperature sensor
Stand-alone seven-segment display
Python IDE at http://10.42.0.1/code/

Presentation rhythm

For every step:

Ask the engaging question before showing the new code.
Let the audience suggest an answer.
Type the small change.
Ask the audience to predict the result.
Select Run This File and observe the hardware and live terminal.

Step 1: Light One RGB LED

Ask before starting

How many lines of Python do you think we need to control a real LED?

Explain that CodyNick.CN() creates the connection and LED number 0 is the first LED on the RGB matrix. A color is written as red, green, and blue values in hexadecimal.

import time
import CodyNick

cody = CodyNick.CN()

CodyNick.RGB_Matrix.set(cody, 0, "#00FF00")
time.sleep(3)

CodyNick.RGB_Matrix.clear(cody)

Point out

0 selects the first LED.
#00FF00 means green.
time.sleep(3) keeps it visible for three seconds.
clear turns the LED off at the end.

Step 2: Make the LED Blink

Ask before starting

A computer follows instructions very quickly. How can we make it wait long enough for our eyes to see an LED blink?

Replace the single LED command and three-second wait with this loop:

import time
import CodyNick

cody = CodyNick.CN()


for count in range(5):
    CodyNick.RGB_Matrix.set(cody, 0, "#00FF00")
    time.sleep(0.5)
    CodyNick.RGB_Matrix.set(cody, 0, "#000000")
    time.sleep(0.5)

Point out

range(5) repeats the indented instructions five times.
#000000 means no red, green, or blue, so the LED is off.
The two half-second waits create an obvious rhythm.

Invite the audience to predict what changing 0.5 to 0.1 will do.

Step 3: Control LEDs with the Joystick

Ask before starting

Can one physical control choose which light Python turns on?

Move the joystick up, right, down, and left. One LED in the corresponding part of the matrix lights up in a different color. Press the joystick to light the center LED white.

import time
import CodyNick

cody = CodyNick.CN()

while True:
    direction = CodyNick.Joystick.states(cody, "CJP")
    CodyNick.RGB_Matrix.clear(cody)

    if "CLICK" in direction:
        CodyNick.RGB_Matrix.set(cody, 6, "#FFFFFF")
    elif "UP" in direction:
        CodyNick.RGB_Matrix.set(cody, 13, "#0000FF")
    elif "RIGHT" in direction:
        CodyNick.RGB_Matrix.set(cody, 4, "#00FF00")
    elif "DOWN" in direction:
        CodyNick.RGB_Matrix.set(cody, 1, "#FF0000")
    elif "LEFT" in direction:
        CodyNick.RGB_Matrix.set(cody, 8, "#FFFF00")

    time.sleep(0.1)

Point out

states reads the current joystick direction.
Up uses LED 13 in blue.
Right uses LED 4 in green.
Down uses LED 1 in red.
Left uses LED 8 in yellow.
Clicking uses LED 6 in white.
if and elif choose only one LED at a time.
The matrix is cleared before showing the current direction.
while True keeps reading the joystick until the program is stopped.

Step 4: Show a Fixed Number

Ask before starting

If Python can control one light, can it also send a complete number to a display with one instruction?

Replace the blinking code with a seven-segment display command:

import CodyNick

cody = CodyNick.CN()

CodyNick.Seven_Segment.display(cody, "Stand-Alone", 25)

Point out

"Stand-Alone" selects the separate seven-segment display.
25 is the value sent to the display.

Step 5: Show a Counter

Ask before starting

The display is showing data from our program. What should change if we want the display to show progress instead of one fixed value?

Change the fixed display command to a loop:

import time
import CodyNick

cody = CodyNick.CN()


for number in range(1, 11):
    CodyNick.Seven_Segment.display(cody, "Stand-Alone", number)
    print("Count:", number)
    time.sleep(1)

Point out

range(1, 11) produces the numbers 1 through 10.
The same variable is shown on the physical display and in the live terminal.
Software variables can directly represent real-world output.

Step 6: Display the Measured Temperature

Ask before starting

So far, Python has displayed numbers that we chose. How can the physical world choose the number instead?

Replace the counter with a continuous sensor loop:

import time
import CodyNick

cody = CodyNick.CN()


while True:
    temperature = CodyNick.Temperature_Sensor.read(cody)
    temperature = round(temperature, 1)

    CodyNick.Seven_Segment.display(cody, "Stand-Alone", temperature)
    print("Temperature:", temperature, "C")

    time.sleep(1)

Point out

read(cody) gets a current measurement from the sensor.
round(..., 1) keeps one digit after the decimal point.
while True continues until the presenter stops the script.
The one-second pause gives a readable update rate.

Ask someone to gently warm the sensor and watch the number respond.

Step 7: Add Temperature Colors

Ask before starting

Can someone understand whether a temperature is cold, comfortable, or hot more quickly from a number or from a color?

Add the temperature decision and use a loop to color all 16 LEDs:

import time
import CodyNick

cody = CodyNick.CN()


while True:
    temperature = CodyNick.Temperature_Sensor.read(cody)
    temperature = round(temperature, 1)

    CodyNick.Seven_Segment.display(cody, "Stand-Alone", temperature)

    if temperature < 20:
        color = "#0000FF"
    elif temperature <= 30:
        color = "#00FF00"
    else:
        color = "#FF0000"

    for led in range(16):
        CodyNick.RGB_Matrix.set(cody, led, color)

    print("Temperature:", temperature, "C")
    time.sleep(1)

Point out

Below 20 C is blue.
From 20 C through 30 C is green.
Above 30 C is red.
if, elif, and else turn one measurement into one of three decisions.
range(16) applies the chosen color to the complete matrix.

Step 8: Add the Alarm and Joystick Inhibit

Ask before starting

A real alarm may need to be silenced while someone investigates. How can one joystick button act as both the silence control and the re-enable control?

Start with two variables that remember the alarm state:

alarm_enabled = True
was_clicked = False

Then build the final program:

import time
import CodyNick

cody = CodyNick.CN()

alarm_enabled = True
was_clicked = False


while True:
    temperature = CodyNick.Temperature_Sensor.read(cody)
    temperature = round(temperature, 1)

    CodyNick.Seven_Segment.display(cody, "Stand-Alone", temperature)

    if temperature < 20:
        color = "#0000FF"
    elif temperature <= 30:
        color = "#00FF00"
    else:
        color = "#FF0000"

    for led in range(16):
        CodyNick.RGB_Matrix.set(cody, led, color)

    is_clicked = CodyNick.Joystick.click(cody, "CJP")

    if is_clicked and not was_clicked:
        alarm_enabled = not alarm_enabled

        if alarm_enabled:
            print("Alarm enabled")
        else:
            print("Alarm inhibited")

    was_clicked = is_clicked

    if temperature > 30 and alarm_enabled:
        CodyNick.CJP_Sound_Maker.play_until_done(cody, "C6", 120)
        CodyNick.CJP_Sound_Maker.play_until_done(cody, "E6", 120)
        CodyNick.CJP_Sound_Maker.play_until_done(cody, "G6", 120)
        CodyNick.CJP_Sound_Maker.play_until_done(cody, "E6", 120)

    print("Temperature:", temperature, "C")

    time.sleep(0.3)

Point out

alarm_enabled remembers whether sound is permitted.
was_clicked allows one physical press to cause only one toggle.
not alarm_enabled changes enabled to inhibited and inhibited to enabled.
The red visual warning remains active while the audible alarm is inhibited.
The alarm melody is C6, E6, G6, E6.
The joystick is checked between complete melody cycles.

Step 9: Connect to AI and Take a Picture

Ask before starting

We have given our program sensor inputs. What new things could it understand if we gave it eyes?

The camera has not been connected during the earlier steps. Connect the USB camera now and wait a few seconds for the Raspberry Pi to recognize it.

Replace the previous program with this short camera program:

import CodyNick
from codynick_ai import CodyNickAI

cody = CodyNick.CN()
ai = CodyNickAI(workspace="/home/client", camera_index=0)

picture = ai.take_picture(
    "camera_demo",
    cody=cody,
    get_ready_sound=True
)

print("Picture saved:", picture)

ai.close()
cody.close()

Run the program, then open Images in the IDE and select camera_demo.jpg to show the captured picture to the audience. Running the program again replaces the same picture instead of filling the Images folder with many files.

Point out

CodyNickAI connects the student program to the installed AI tools.
cody=cody connects the camera activity to CodyJoy Pro.
get_ready_sound=True plays the get-ready and shutter sounds.
take_picture() captures one image and releases the camera after the shot.
"camera_demo" is the reusable image name.
The image is stored in /home/client/images and appears under Images in the IDE.
Taking a picture is the first step. The same picture can next be used for object detection, OCR, face tools, or another AI model.

Step 10: Detect Objects in the Picture

Ask before starting

The camera can take a picture, but can the computer tell us what is inside it?

Place a few familiar objects in front of the camera, such as a bottle, cup, chair, or person. Extend the camera program so it captures a fresh picture and analyzes it:

import CodyNick
from codynick_ai import CodyNickAI

cody = CodyNick.CN()
ai = CodyNickAI(workspace="/home/client", camera_index=0)

picture = ai.take_picture(
    "camera_demo",
    cody=cody,
    get_ready_sound=True
)

print("Picture saved:", picture)

ai.load_app("yolo", model="nano")
result = ai.detect_objects("camera_demo")

print("Objects found:", len(result["detections"]))

for item in result["detections"]:
    print(item["class_name"], item["confidence"])

ai.close()
cody.close()

After the result appears, open Images, open the results folder, and select camera_demo_objects.jpg. Show how the AI has drawn a box and label around each recognized object.

Point out

load_app("yolo", model="nano") loads the fast object-detection model.
detect_objects("camera_demo") analyzes the picture captured by the program.
result["detections"] contains the objects found by the model.
Each result includes a class name and a confidence score.
The annotated image is saved under Images → results.
The model may miss an object or label it incorrectly. Better lighting and a clear view usually improve the result.

Step 11: Control the LEDs with Your Voice

Ask before starting

We have controlled the lights with code and a joystick. Can we control them without touching the computer or the gadget at all?

Use a USB microphone, or use the microphone built into the USB camera if it has one. Keep it close enough to hear the presenter clearly.

In the IDE, open CodyNick Examples → voice_led_colors.py and select Run This File. Wait until the terminal says that offline English speech recognition is ready, then say one command at a time:

red
green
blue
yellow
white
purple
lights off
stop listening

The installed example includes useful progress messages. This shorter presenter version keeps the same commands, recognition settings, hardware behavior, and cleanup logic:

import CodyNick
from codynick_ai import CodyNickAI


COMMAND_COLORS = {
    "red": "#FF0000",
    "green": "#00FF00",
    "blue": "#0000FF",
    "yellow": "#FFFF00",
    "white": "#FFFFFF",
    "purple": "#FF00FF",
}

COMMANDS = list(COMMAND_COLORS) + ["lights off", "stop listening"]


def fill_matrix(cody, color):
    for led in range(16):
        CodyNick.RGB_Matrix.set(cody, led, color)


def main():
    cody = CodyNick.CN()
    ai = CodyNickAI(workspace="/home/client")
    listener = None

    try:
        if not cody.ensure_connected():
            raise RuntimeError("CodyNick gadget not found.")

        ai.load_app("stt", model="small", language="en")

        listener = ai.listen(
            commands=COMMANDS,
            min_confidence=0.45,
            device="auto"
        )

        for event in listener:
            if not event.get("accepted"):
                continue

            command = event["matched_command"]
            print("Heard:", command)

            if command == "stop listening":
                break
            elif command == "lights off":
                CodyNick.RGB_Matrix.clear(cody)
            else:
                fill_matrix(cody, COMMAND_COLORS[command])

    finally:
        if listener is not None:
            listener.stop()

        ai.close()
        CodyNick.RGB_Matrix.clear(cody)
        cody.close()


main()

Point out

load_app("stt", ...) loads offline speech-to-text. The spoken audio does not need to be sent to an internet service.
COMMANDS limits recognition to the phrases used by this demonstration.
device="auto" selects an available USB or camera microphone.
min_confidence=0.45 rejects uncertain matches below the selected confidence level.
lights off clears the LEDs but keeps the microphone listening.
stop listening ends the program and turns the LEDs off.
The finally section releases the microphone and clears the hardware even when the program is stopped unexpectedly.

Demonstration tips

Wait for the ready message before speaking.
Speak one command clearly, then pause briefly for the result.
Reduce nearby conversation and music while demonstrating recognition.
If a command is rejected, move closer to the microphone and repeat it normally.

Step 12: Hold a Voice Conversation

Ask before starting

The system can recognize one spoken command. Could it stay awake, understand several different questions, and answer us with a different response each time?

Watch the completed demonstration before presenting this step:

Open or download the voice conversation demo video

Connect a USB microphone and speaker. Keep CodyJoy Pro connected for the LED and buzzer feedback.

Prepare the answers once

In the IDE, open CodyNick Examples → generate_conversation_answers.py and select Run This File. Wait until all 27 messages have been generated. They are stored in:

/home/client/audio/conversation_answers

The answers are generated in advance so the live conversation can respond immediately. Running the generator again safely builds a complete replacement set before replacing the old files. It does not delete unrelated recordings.

Start the live conversation

Open CodyNick Examples → voice_conversation.py and select Run This File. Wait for Ready. Say: wake up, then demonstrate this sequence:

Say wake up or please wake up. Wait for the ready sound and a spoken response such as I am listening. Ask several questions without saying the wake phrase again. Say sleep or go to sleep to return immediately to wake mode. Say wake up again and continue the conversation. Stop speaking for ten seconds and show that it returns to wake mode automatically.

Try questions from these groups:

Topic Example phrases Greeting hello, hi, good morning, good afternoon, good evening, good night Identity what is your name, who are you, tell me about yourself Well-being how are you, how are you today, are you okay Capabilities what can you do, how can you help me, what do you do Favorite color what is your favorite color, which color do you like Feelings are you happy, how do you feel, are you sad Goodbye goodbye, bye, see you later

Watch the gadget emotions

State CodyJoy Pro feedback Waiting One dim blue LED Wake phrase accepted Green LEDs and two rising notes Listening Four cyan center LEDs; buzzer remains silent Processing Yellow side LEDs Answering Green pattern and a short opening note Question not understood Two orange flashes and descending notes Goodbye Purple LEDs and a farewell melody

Point out

The speech recognition and generated answers work offline after installation. Each topic has three prerecorded answers, selected without immediately repeating the previous answer. Unique playback names prevent the audio cache from replaying an earlier response. The microphone stops while the buzzer or speaker is active, so the program does not recognize its own sounds. The program remains awake across several questions and sleeps only after a command, goodbye, or ten seconds of silence. Pressing Stop releases the microphone, speech worker, serial connection, and LEDs.

Demonstration tips

Run the answer generator before the audience arrives; it loads the large TTS model and is intentionally slower than normal playback. Keep the microphone away from the speaker and reduce nearby conversation. Pause after the wake phrase so the ready response can finish before asking a question. Ask one short supported question at a time and wait for the answer. If a question is not recognized, repeat it clearly using one of the listed phrases.

Closing audience questions

Which thresholds would you use for a refrigerator, greenhouse, or classroom?
What other sensor could replace the temperature sensor?
What could the joystick control besides the alarm?
How could the dashboard or cloud record the temperature history?
What could an AI model discover in the picture we just captured?
How could the program react when it recognizes a particular object?
What other spoken commands could control a CodyNick project?
What new questions and emotions would you add to the conversation?

Presenter reminder

Keep the code visible while demonstrating the hardware response. The purpose is not to memorize every command; it is to show the repeated pattern:

Read an input.
Make a decision.
Control an output.
Repeat safely.