AI on the Edge LESSON 9: Make Your Raspberry Pi Talk with TTS

April 26, 2026 admin

In today’s lesson, we’re going to make a huge leap forward in giving our Raspberry Pi some real personality. We’re going to teach it how to talk using Text-to-Speech (TTS). Instead of just blinking LEDs or printing text to the screen, our Pi will now speak out loud with a clear, natural-sounding voice.

This is a really fun and important lesson because one of the main goals of this class is to build intelligent systems that can interact with us in more human ways. Being able to make your Raspberry Pi speak opens up all kinds of exciting possibilities — whether you want your robot to tell you what it sees, have your AI assistant read sensor data out loud, or just add some personality and humor to your projects.

In this video, I show you how to use the TTS capabilities on the SunFounder Fusion AI Hat. You’ll learn how to install and set up the TTS engine, speak simple sentences, change voices, and control when the Pi talks. We’ll also look at how to make the speech sound more natural and how to integrate it smoothly into your programs without freezing everything else.

By the end of this lesson, your Raspberry Pi will be able to speak clearly and confidently — which is going to make the rest of our AI on the Edge journey a lot more exciting. Voice output combined with voice input (which we’ll work on soon) is what turns a simple circuit into a real interactive AI companion.

So go ahead and grab your Fusion AI Hat, plug in a speaker, and let’s give your Raspberry Pi a voice! As always, I encourage you to code along with me in the video and then experiment. Try making it say funny things, read temperatures, announce when it detects a face — whatever sparks your creativity.

This is where your projects start to feel truly alive.

I’m really excited for you on this one — let’s make your Raspberry Pi talk!

This is the schematic we are using on these projects;

Fusion Hat Circuit Diagram — This is the circuit we will use moving forward in the class

This Schematic is explained in detail in LESSON #5.

Then this is the code we developed in today’s lesson.

from fusion_hat.adc import ADC
from fusion_hat.pwm import PWM
from fusion_hat.tts import Piper
from time import sleep
tts = Piper()
tts.set_model('en_US-amy-low')
potPin = 0
myPot = ADC(potPin)
redPin = 5
redLED = PWM(redPin)
rangeOld = 100

while True:
    potVal = myPot.read()
    writeVal=100*(potVal/4095) - .005
    if writeVal < 1:
        msg = "Your LED is Off"
        range = 0
    if writeVal >=1 and writeVal<10:
        msg = "Your LED is Brightness 1"
        range =  1
    if writeVal >=10 and writeVal<20:
        msg = "Your LED is Brightness 2"
        range=2
    if writeVal >=20 and writeVal<30:
        msg = "Your LED is Brightness 3"
        range=3
    if writeVal >=30 and writeVal<40:
        msg = "Your LED is Brightness 4"
        range=4
    if writeVal >=40 and writeVal<50:
        msg = "Your LED is Brightness 5"
        range=5
    if writeVal >=50 and writeVal<60:
        msg = "Your LED is Brightness 6"
        range=6
    if writeVal >=60 and writeVal<70:
        msg = "Your LED is Brightness 7"
        range=7
    if writeVal >=70 and writeVal<80:
        msg = "Your LED is Brightness 8"
        range=8
    if writeVal >=80 and writeVal<90:
        msg = "Your LED is Brightness 9"
        range=9
    if writeVal >=90 and writeVal<99:
        msg = "Your LED is Brightness 10"
        range=10
    if writeVal >=99:
        msg = "Your LED is full Brightness"
        range=11
    if rangeOld != range:
        tts.say(msg, stream = False)
    rangeOld=range
    redLED.pulse_width_percent(int(writeVal))
    sleep(.1)

from fusion_hat.adc import ADC

from fusion_hat.pwm import PWM

from fusion_hat.tts import Piper

from time import sleep

tts = Piper()

tts.set_model('en_US-amy-low')

potPin = 0

myPot = ADC(potPin)

redPin = 5

redLED = PWM(redPin)

rangeOld = 100

while True:

potVal = myPot.read()

writeVal=100*(potVal/4095) - .005

if writeVal < 1:

msg = "Your LED is Off"

range = 0

if writeVal >=1 and writeVal<10:

msg = "Your LED is Brightness 1"

range = 1

if writeVal >=10 and writeVal<20:

msg = "Your LED is Brightness 2"

range=2

if writeVal >=20 and writeVal<30:

msg = "Your LED is Brightness 3"

range=3

if writeVal >=30 and writeVal<40:

msg = "Your LED is Brightness 4"

range=4

if writeVal >=40 and writeVal<50:

msg = "Your LED is Brightness 5"

range=5

if writeVal >=50 and writeVal<60:

msg = "Your LED is Brightness 6"

range=6

if writeVal >=60 and writeVal<70:

msg = "Your LED is Brightness 7"

range=7

if writeVal >=70 and writeVal<80:

msg = "Your LED is Brightness 8"

range=8

if writeVal >=80 and writeVal<90:

msg = "Your LED is Brightness 9"

range=9

if writeVal >=90 and writeVal<99:

msg = "Your LED is Brightness 10"

range=10

if writeVal >=99:

msg = "Your LED is full Brightness"

range=11

if rangeOld != range:

tts.say(msg, stream = False)

rangeOld=range

redLED.pulse_width_percent(int(writeVal))

sleep(.1)

AI On the Edge, Tutorial

AI on the Edge LESSON 8: Text to Speech (TTS) on the Raspberry Pi

April 24, 2026 admin

In this video lesson I will show you how to get the Raspberry Pi to speak to you in plain English. This is our first dabbling with AI. In earlier lessons we have discussed that one of our first objectives will be to begin to audibly interact with our project through speech. The first step will be to get the Pi to talk to us. Then in future lessons we will show how to get the Pi to listen to us.

In this lesson we demonstrated simple Text to Speech (TTS) with this code.

Remember this program requires use of the AI Educational OS we flashed in LESSON #2.

from fusion_hat.tts import Piper
tts = Piper()
tts.set_model('en_US-amy-low')
msg = "Hi, I'm piper TTS. Are you Ready to Rumble? I am here to pump you up!"
tts.say(msg, stream=False)

from fusion_hat.tts import Piper

tts = Piper()

tts.set_model('en_US-amy-low')

msg = "Hi, I'm piper TTS. Are you Ready to Rumble? I am here to pump you up!"

tts.say(msg, stream=False)

As we say in the video, the first time you run the program you will get a permission error. This is because the model folders are inside a system folder and must be created as a ‘superuser’ using ‘sudo’. As shown in the video, you need to open a terminal window, and type in these commands at the command prompt (Put them in one at a time):

sudo mkdir -p /opt/piper_models
sudo chown -R pi:pi /opt/piper_models
sudo chmod -R 755 /opt/piper_models

sudo mkdir -p /opt/piper_models

sudo chown -R pi:pi /opt/piper_models

sudo chmod -R 755 /opt/piper_models

You only need to do that one time. Next time you run the program, all will work properly.

Then, in order to hear all the different voice models Piper offers, you can run this program, and each voice will introduce itself to you.

from fusion_hat.tts import Piper
from time import sleep  # Optional: for pauses between voices
tts = Piper()
# Get the dictionary of available en_US models
voiceDict = tts.available_models('en_US')
print(voiceDict)
# Flatten into a single list of full model names
allVoices = []
for voice in voiceDict.values():
    for var in voice:
        allVoices.append(var)
print(allVoices) 

msg = "Hello World. This is a test message."
for voice in allVoices:
    tts.set_model(voice)  # Auto-downloads on first use
    # Create a readable voice name (remove 'en_US-' and replace '_' with space)
    speakableName = voice.replace('en_US-', '').replace('_', ' ')
    print("Switching to: " + speakableName)
    print(voice)
    sleep(5)
    # Introduction in that voice
    intro = "This is the voice " + speakableName + "."
    tts.say("Hello There" + intro)
    #tts.say(msg, stream=False)
    sleep(.1)
print("All voices demonstrated!")
for voice in allVoices:
    print(voice)

from fusion_hat.tts import Piper

from time import sleep # Optional: for pauses between voices

tts = Piper()

# Get the dictionary of available en_US models

voiceDict = tts.available_models('en_US')

print(voiceDict)

# Flatten into a single list of full model names

allVoices = []

for voice in voiceDict.values():

for var in voice:

allVoices.append(var)

print(allVoices)

msg = "Hello World. This is a test message."

for voice in allVoices:

tts.set_model(voice) # Auto-downloads on first use

# Create a readable voice name (remove 'en_US-' and replace '_' with space)

speakableName = voice.replace('en_US-', '').replace('_', ' ')

print("Switching to: " + speakableName)

print(voice)

sleep(5)

# Introduction in that voice

intro = "This is the voice " + speakableName + "."

tts.say("Hello There" + intro)

#tts.say(msg, stream=False)

sleep(.1)

print("All voices demonstrated!")

for voice in allVoices:

print(voice)

Remember in these early lessons we are using this circuit to demo our programs. Please leave this circuit put together.

AI On the Edge, Tutorial

AI on the Edge LESSON 7: Homework Solution for Dimmable LED

April 18, 2026 admin

In Lesson 6, I gave you a homework challenge: build a dimmable LED using a potentiometer. In today’s Lesson 7, we go through the solution together step-by-step.

This lesson is all about taking analog input from a potentiometer and converting it into smooth PWM output to control the brightness of an LED. It’s a very practical project because it teaches you how to read real-world analog values and turn them into useful control signals — skills we’ll use again and again as we build smarter AI-powered projects.

In the video, I walk you through the complete working code. You’ll see how we read the potentiometer value (0 to 4095), convert that raw number into a proper brightness percentage using a bit of math (with a nice logarithmic curve so the brightness feels natural to the human eye), and then send that value to the LED using PWM. The result is a very smooth, responsive dimmer that feels professional.

Even though this seems like a simple project, it’s actually an important stepping stone. Understanding how to read sensors and smoothly control outputs is fundamental to building real AI on the Edge systems — whether you’re controlling motors, adjusting screen brightness, or varying the speed of a robot based on sensor input.

By the end of this lesson, you should have a solid understanding of how to combine the ADC (Analog to Digital Converter) with PWM output, and more importantly, how to think about mapping real-world inputs to useful outputs.

So if you did the homework, great job! If you got stuck, don’t worry — we go through the full solution together. And as always, I strongly encourage you to take the code and make it your own. Try changing the response curve, add multiple LEDs with different colors, or combine it with things we’ve learned in earlier lessons.

This is the kind of foundational hardware skill that will serve you well as we continue moving deeper into the AI on the Edge class. You’re doing great — keep going!

We are still using the schematic from our earlier project.

In this lesson, this is the code which we came up with:

#!/usr/bin/env python3
from fusion_hat.adc import ADC
from fusion_hat.pwm import PWM
from time import sleep
import math
potPin=0
myPot = ADC(0)
redPin=5
redLED=PWM(redPin)

while True:
    potVal = myPot.read()                     # 0 to 4095
    writeVal=100**(potVal/4095)-.005
    redLED.pulse_width_percent(int(writeVal))
    print(potVal,writeVal)
    sleep(0.1)

#!/usr/bin/env python3

from fusion_hat.adc import ADC

from fusion_hat.pwm import PWM

from time import sleep

import math

potPin=0

myPot = ADC(0)

redPin=5

redLED=PWM(redPin)

while True:

potVal = myPot.read() # 0 to 4095

writeVal=100**(potVal/4095)-.005

redLED.pulse_width_percent(int(writeVal))

print(potVal,writeVal)

sleep(0.1)

AI On the Edge

AI on the Edge LESSON 6: Digitial Out, Servos, Analog In and PWM on the Fusion HAT+

April 15, 2026 admin

n Lesson 6, we’re really starting to get our hands dirty with real hardware control. Today we dive into the core fundamentals of physical computing on the SunFounder Fusion AI Hat — learning how to use Digital Outputs, control Servos, read Analog Inputs, and generate PWM signals.

This is a big lesson because it bridges the gap between writing simple Python scripts and actually making the Raspberry Pi interact with the physical world. You’ll learn how to turn LEDs on and off using digital outputs, precisely control the position of a servo motor, read values from a potentiometer using the Analog-to-Digital Converter, and smoothly adjust brightness using PWM (Pulse Width Modulation).

I take my time in this video to explain not just how to do these things, but why they work the way they do. Understanding PWM is especially important because it’s a technique we’ll use heavily later in the class when controlling motors, adjusting LED brightness, generating audio tones, and more.

By the end of this lesson, you’ll have a solid foundation in hardware control using the Fusion HAT. These skills are critical as we move forward in the AI on the Edge journey — because no matter how smart your AI code is, it eventually has to do something useful in the real world, whether that’s moving a camera, turning on lights, or controlling a robot.

This lesson marks the point where we shift from just blinking LEDs to building real, useful control systems. The combination of reading sensors (Analog In) and controlling actuators (Servos + PWM) is exactly what intelligent edge devices need to sense and act.

So grab your Fusion AI Hat, hook up an LED, a servo, and a potentiometer, and let’s start giving your Raspberry Pi real physical superpowers!

As always, I strongly encourage you to code along with me in the video. Try different servo angles, change the PWM frequency, and experiment with mapping the potentiometer to different outputs. That hands-on practice is where the real learning happens.

You’re doing great — we’re building something special here. Let’s keep going!

The schematic for the circuit we will be using in today’s lesson if below. We describe it in more detail in the video. The schematic is:

In the video lesson we demonstrated the following programs:

Digital output to blink an LED:

from fusion_hat.pin import Pin, Mode
import time
LEDPin=17
redLED = Pin(LEDPin,mode=Mode.OUT)
while True:
    
            redLED.high()
            time.sleep(.1)
            redLED.low()
            time.sleep(.1)

from fusion_hat.pin import Pin, Mode

import time

LEDPin=17

redLED = Pin(LEDPin,mode=Mode.OUT)

while True:

redLED.high()

time.sleep(.1)

redLED.low()

time.sleep(.1)

PWM Example to Control RGB LED Color and Brightness.

from fusion_hat.pwm import PWM
from time import sleep

redPin = 5
greenPin = 6
bluePin = 7

redLED = PWM(redPin)          
greenLED=PWM(greenPin)
blueLED=PWM(bluePin)
redLED.freq(200)
greenLED.freq(200)
blueLED.freq(200)

while True:
    for bright in range(0, 101, 1):
        redLED.pulse_width_percent(bright)
        sleep(0.01)
        print(bright)
    for bright in range(99, 0, -1):
        redLED.pulse_width_percent(bright)
        sleep(0.01)
        print(bright)

from fusion_hat.pwm import PWM

from time import sleep

redPin = 5

greenPin = 6

bluePin = 7

redLED = PWM(redPin)

greenLED=PWM(greenPin)

blueLED=PWM(bluePin)

redLED.freq(200)

greenLED.freq(200)

blueLED.freq(200)

while True:

for bright in range(0, 101, 1):

redLED.pulse_width_percent(bright)

sleep(0.01)

print(bright)

for bright in range(99, 0, -1):

redLED.pulse_width_percent(bright)

sleep(0.01)

print(bright)

Reading Analog Voltages on the Pi 5 Using the Fusion HAT+

from fusion_hat.adc import ADC
from time import sleep

potPin=0
myPot = ADC(potPin)       # A0–A3 on HAT

while True:
    analogIn = myPot.read()
    voltage=analogIn*(3.3/4095)
    print("Analog In: ",analogIn,"Voltage: ",round(voltage,2))
    sleep(0.1)

from fusion_hat.adc import ADC

from time import sleep

potPin=0

myPot = ADC(potPin) # A0–A3 on HAT

while True:

analogIn = myPot.read()

voltage=analogIn*(3.3/4095)

print("Analog In: ",analogIn,"Voltage: ",round(voltage,2))

sleep(0.1)

Controlling Servos With the Fusion AI HAT+

from fusion_hat.servo import Servo   # Import the Servo class for controlling servos
import time
# Import sleep for timing delays
panPin=2
tiltPin=3
servoPan = Servo(panPin)
servoTilt=Servo(tiltPin)
servoPan.angle(0)
servoTilt.angle(0)

from fusion_hat.servo import Servo # Import the Servo class for controlling servos

import time

# Import sleep for timing delays

panPin=2

tiltPin=3

servoPan = Servo(panPin)

servoTilt=Servo(tiltPin)

servoPan.angle(0)

servoTilt.angle(0)

AI On the Edge

AI on the Edge LESSON 5: Understanding Fusion AI Hat+ For Raspberry Pi

April 9, 2026 admin

In today’s lesson we will become familiar with the capabilities of the Fusion AI Hat+ for the Raspberry Pi. This hat will be a core part of our class moving forward. The hat makes it easy to get data from the outside world, and to control things in the outside would. We will get an understanding of the core capabilities of the board, and your homework will be to build the first circuit with the board. This schematic shows the various parts of the board:

Fusion AI Hat for Raspberry Pi Schematic

Then for the homework, we need you to go ahead and build this circuit. This circuit will allow us to learn how to make Digital Output commands, PWM commands, and how to read analog inputs.

Technology Tutorials

AI on the Edge LESSON 9: Make Your Raspberry Pi Talk with TTS

AI on the Edge LESSON 8: Text to Speech (TTS) on the Raspberry Pi

AI on the Edge LESSON 7: Homework Solution for Dimmable LED

AI on the Edge LESSON 6: Digitial Out, Servos, Analog In and PWM on the Fusion HAT+

AI on the Edge LESSON 5: Understanding Fusion AI Hat+ For Raspberry Pi

Making The World a Better Place One High Tech Project at a Time. Enjoy!