Tag Archives: neoPixel

Welcome back, everyone! In this lesson, we take edge AI interactivity to the next level. Up until now, we have learned how to track hand landmarks, extract pixel coordinates, and calculate distances using MediaPipe. Today, we put all those building blocks together into a self-contained, real-time hand gesture recognition system running on the Raspberry Pi 5.

We are not relying on a black-box pre-trained gesture model. Instead, we write our own mathematical feature extractor, train our custom hand poses on the fly, save those gesture profiles directly to disk, and map each gesture to a non-blocking lighting animation on a NeoPixel LED ring driven over SPI.

System Architecture Overview

The system operates in three distinct phases running simultaneously inside our main loop:

Normalized Feature Extraction: MediaPipe extracts 3D hand landmark coordinates. To make gesture detection scale-invariant and distance-invariant, we normalize the distances between the fingertips and the wrist against a reference palm dimension.
Nearest-Neighbor Gesture Matching: Live distance vectors are compared against stored gesture profiles using a mean absolute error algorithm. If the error falls below our maximum threshold, the gesture is identified; otherwise, it defaults to “Unknown.”
Non-Blocking Hardware Animation Dispatch: The recognized gesture string triggers corresponding pattern functions on the 12-LED NeoPixel ring via neopixel_spi. Animations use non-blocking time delta checks to preserve high camera preview frame rates.

Gesture-to-Hardware Animation Mapping

Our script contains predefined animation routines mapped to recognized gesture strings. Here is how each pose controls the LED ring:

Recognized Gesture	LED Animation Pattern	Visual Effect
`fist`	Red Pulse	Sinusoidal breathing effect fading in and out
`palm`	Solid Beacon	Full brightness white ring
`peace`	Dual Spinner	Dual green and blue dots rotating over a dim red background
`thumbsup`	Solid Success	Constant green feedback
`point`	Radar Sweep	A green trailing dot chasing around a red ring
`rock`	Cyan Flame	Sinusoidal green-cyan intensity modulation
`ok`	Rainbow Wheel	Rotating HSV spectrum cycle
`Unknown` / Unmatched	Clear	LEDs turn completely off

Interactive Keyboard Controls

While the camera loop is active, you can interact with the system using your keyboard in the preview window:

Spacebar: Captures the current hand pose’s normalized distance vector, assigns it to the active target gesture name, and saves the updated dataset to gestureNEOPIXEL.pkl.
t: Prompts the terminal to add a new custom gesture name to your training queue dynamically.
d: Prompts the terminal to delete a specific gesture profile from the saved dataset.
q: Clears the NeoPixel ring, closes the camera pipeline, saves training data, and terminates the program cleanly.

Hardware Wiring Reference

Ensure your Raspberry Pi 5 SPI interface is enabled before running the code (sudo raspi-config -> Interface Options -> SPI).

NeoPixel Data Input (DIN): Connect to GPIO 10 (SPI0 MOSI / Pin 19).
NeoPixel Ground: Connect to any GND pin on the Pi expansion header.
NeoPixel Power: Connect to an external 5V power supply (ensure a shared ground with the Raspberry Pi).

Homework Challenge

Now that you have a working gesture recognition system linked to hardware animations, try adding your own custom gestures! Train a brand-new gesture pose (like a “three-finger count”), write a corresponding non-blocking animation function in updateNeoPixels(), and share your video results.

Here is the code we developed in the video lesson:

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================
import cv2
import time
from picamera2 import Picamera2
import mediapipe as mp
import math
import pickle
import os
import colorsys

# ====================================================================
# NEOPIXEL CONTROL INITIALIZATION (Adafruit neopixel_spi via SPI)
# ====================================================================

import board
import neopixel_spi as neopixel

NUM_LEDS = 12  # Set to match your NeoPixel ring size (e.g., 12)
PO = neopixel.GRB

# Initialize NeoPixel ring using SPI
spi = board.SPI()
strip = neopixel.NeoPixel_SPI(
    spi, 
    NUM_LEDS, 
    pixel_order=PO, 
    auto_write=False
)

# Turn off all LEDs on startup
strip.fill(0)
strip.show()

NEOPIXEL_ENABLED = True
print("[INFO] NeoPixel SPI initialized successfully.")

# Animation state variables (non-blocking updates)
animation_step = 0
lastAnimUpdate = time.time()
# ====================================================================

DATA_FILE = "gestureNEOPIXEL.pkl"

# Function to save the trained gesture dictionary to a file using pickle
def saveTrainedData(filename, data):
    with open(filename, 'wb') as f:
        pickle.dump(data, f)
    print("[INFO] Saved gesture data to " + str(filename))

# Function to load previously saved gesture data from a file
def loadTrainedData(filename):
    if os.path.exists(filename):
        with open(filename, 'rb') as f:
            data = pickle.load(f)
            print("[INFO] Loaded " + str(len(data)) + " gesture(s) from " + str(filename))
        return data
    return {}

# --- SETUP & INITIAL TRAINING ---
trainedData = loadTrainedData(DATA_FILE)
gestureNames = []

if not trainedData:
    print("HAND GESTURE TRAINING SETUP")
    numGestures = int(input("Enter Number of Gestures to Train On: "))
    for idx in range(numGestures):
        name = input("Enter Name for Gesture #" + str(idx + 1) + ": ")
        gestureNames.append(name)

def findDistance(pt1, pt2):
    dX = pt1.x - pt2.x
    dY = pt1.y - pt2.y
    dZ = pt1.z - pt2.z
    return math.sqrt(dX*dX + dY*dY + dZ*dZ)

def getTipDistances(handLm):
    lm = handLm.landmark
    wrist = lm[0]
    indexBase = lm[5]  
    scaleFactor = findDistance(wrist, indexBase)
    tips = [lm[4], lm[8], lm[12], lm[16], lm[20]]
    tipDistances = []
    for tip in tips:
        dist = findDistance(wrist, tip) / scaleFactor
        tipDistances.append(dist)
    for startTip in range(len(tips)):
        for endTip in range(startTip + 1, len(tips)):
            dist = findDistance(tips[startTip], tips[endTip]) / scaleFactor
            tipDistances.append(dist)
    return tipDistances

def calculateError(tipDist, trainDist):
    totalError = 0
    for idx in range(len(tipDist)):
        diff = tipDist[idx] - trainDist[idx]
        totalError += abs(diff)
    return totalError

def findGesture(tipLive, trainedData, maxAllowedError):
    bestMatch = "Unknown"
    lowestError = 999999999
    for gestureName, trainedDist in trainedData.items():
        error = calculateError(tipLive, trainedDist)
        if error < lowestError:
            lowestError = error
            bestMatch = gestureName
    if lowestError > maxAllowedError:
        return "Unknown"
    return bestMatch

# ====================================================================
# NEOPIXEL CONTROL (COLOR HELPER & ANIMATION DISPATCHER)
# ====================================================================
def hsv2rgb(h):
    """ Converts HSV float (0.0-1.0) to RGB integer tuple (0-255) """
    r, g, b = colorsys.hsv_to_rgb(h, 1, 1)
    return (int(r * 255), int(g * 255), int(b * 255))

def updateNeoPixels(gesture):
    """ Non-blocking LED pattern update based on the current detected gesture """
    global animation_step, lastAnimUpdate
    if not NEOPIXEL_ENABLED:
        return

    now = time.time()
    gestureClean = gesture.lower()
    pattern_matched = False

    # 1. FIST / CHARGE (Red pulse)
    if gestureClean == "fist":
        pulse = int(127 + 127 * math.sin(now * 5.0))
        strip.fill((pulse, 0, 0))
        strip.show()
        pattern_matched = True

    # 2. OPEN PALM / BEACON (Solid Bright White)
    if gestureClean == "palm":
        strip.fill((255, 255, 255))
        strip.show()
        pattern_matched = True

    # 3. PEACE SIGN / DUAL SPINNER (Rotating Blue/Cyan dots)
    if gestureClean == "peace":
        if now - lastAnimUpdate > 0.08:
            animation_step = (animation_step + 1) % NUM_LEDS
            lastAnimUpdate = now
        strip.fill((40, 0, 0))  # Background red
        pos1 = animation_step
        pos2 = (animation_step + (NUM_LEDS // 2)) % NUM_LEDS
        strip[pos1] = (0, 255, 0)   # Green spinner dot
        strip[pos2] = (0, 0, 255)   # Blue spinner dot
        strip.show()
        pattern_matched = True

    # 4. THUMBS UP / SUCCESS (Solid Green)
    if gestureClean == "thumbsup":
        strip.fill((0, 255, 0))
        strip.show()
        pattern_matched = True

    # 5. POINTING / CHASER (Radar sweep)
    if gestureClean in "point":
        if now - lastAnimUpdate > 0.06:
            animation_step = (animation_step + 1) % NUM_LEDS
            lastAnimUpdate = now
        strip.fill((255, 0, 0))
        strip[animation_step] = (0, 255, 0)
        strip.show()
        pattern_matched = True

    # 6. ROCK / FIRE (Sinusoidal Green-Cyan pulse)
    if gestureClean == "rock":
        step = int((now * 100) % 360)
        brightness = (math.sin(step * math.pi / 180) + 1) / 2
        g = int(255 * brightness)
        b = int(50 * brightness)
        strip.fill((0, g, b))
        strip.show()
        pattern_matched = True

    # 7. OK SIGN / RAINBOW WHEEL (Rotating RGB spectrum)
    if gestureClean in "ok":
        if now - lastAnimUpdate > 0.03:
            animation_step = (animation_step + 1) % 100
            lastAnimUpdate = now
        hue = animation_step / 100.0
        strip.fill(hsv2rgb(hue))
        strip.show()
        pattern_matched = True

    # DEFAULT / UNKNOWN (LEDs OFF)
    if not pattern_matched:
        strip.fill((0, 0, 0))
        strip.show()
# ====================================================================

W, H = 1280, 720
tStart = time.time()
fps = 15
RES = (W, H)

piCam = Picamera2(1)
piCam.preview_configuration.main.size = RES
piCam.preview_configuration.main.format = "RGB888"
piCam.preview_configuration.controls.FrameRate = 60
piCam.preview_configuration.align()
piCam.configure("preview")
piCam.start()

textLowerLeft = (int(W * .01), int(H * .07))
fontFace = cv2.FONT_HERSHEY_SIMPLEX
fontThickness = int(W / 425)
fontScale = H * .002
fontColor = (0, 0, 255)

textFps = (int(W * .01), int(H * .07))
textGesture = (int(W * .01), int(H * .14))
textGesturePrompt = (int(W * .01), int(H * .21))

maxErrorThreshold = 3.5 

hands = mp.solutions.hands.Hands(
    model_complexity=0,
    min_detection_confidence=.5,
    min_tracking_confidence=.5,
    max_num_hands=2
)

trainIdx = 0

while True:
    deltaT = time.time() - tStart
    tStart = time.time()
    fps = fps * .95 + (1 / deltaT) * .05
    
    frame = piCam.capture_array()
    frame = cv2.flip(frame, -1)
    rgbFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = hands.process(rgbFrame)
    
    if results.multi_hand_landmarks:
        frameHeight, frameWidth, _ = frame.shape        
        for handLm in results.multi_hand_landmarks:
            for idx, landmark in enumerate(handLm.landmark):
                pixelX = int(landmark.x * frameWidth)
                pixelY = int(landmark.y * frameHeight)
                cv2.putText(
                    frame, str(idx), (pixelX, pixelY),
                    cv2.FONT_HERSHEY_SIMPLEX, .6 * fontScale, (255, 0, 0), fontThickness
                )
                
    if trainIdx < len(gestureNames):
        targetName = gestureNames[trainIdx]
        promptText = "show " + targetName + " & Press Space"
        cv2.putText(frame, promptText, textGesturePrompt, fontFace, fontScale, (0, 255, 255), fontThickness)

    detectGesture = "Unknown"
    if results.multi_hand_landmarks:
        liveDistances = getTipDistances(results.multi_hand_landmarks[0])
        detectGesture = findGesture(liveDistances, trainedData, maxErrorThreshold)

    # ====================================================================
    # EXECUTE HARDWARE PATTERN UPDATE
    # ====================================================================
    updateNeoPixels(detectGesture)
    # ====================================================================

    labelText = "Gesture: " + detectGesture
    cv2.putText(frame, labelText, textGesture, fontFace, fontScale, (0, 255, 0), fontThickness)
    myText = "FPS: " + str(round(fps, 1))
    cv2.putText(frame, myText, textLowerLeft, fontFace, fontScale, fontColor, fontThickness)
    
    cv2.imshow("Camera", frame)
    #cv2.moveWindow("Camera", 0, 60)
    
    key = cv2.waitKey(1)
    
    # Save landmark measurements when Space is pressed
    if key == ord(' '):
        if results.multi_hand_landmarks:
            if trainIdx < len(gestureNames):
                targetHand = results.multi_hand_landmarks[0]
                targetName = gestureNames[trainIdx]
                trainedData[targetName] = getTipDistances(targetHand)
                saveTrainedData(DATA_FILE, trainedData)
                trainIdx += 1

    # 't' key allows adding a NEW gesture dynamically during runtime
    if key == ord('t'):
        newGestureName = input("Enter name for new gesture to train: ").strip()
        if newGestureName:
            gestureNames.append(newGestureName)

    # 'd' key deletes a gesture
    if key == ord('d'):
        delName = input("Enter name of gesture to remove: ").strip()
        if delName in trainedData:
            del trainedData[delName]
            saveTrainedData(DATA_FILE, trainedData)
            print("[INFO] Removed " + delName + " from trained data.")
            if delName in gestureNames:
                gestureNames.remove(delName)
        if delName not in trainedData:
            print("[WARNING] Gesture: " + delName + " not found in trained data.")
        trainIdx=min(trainIdx,len(gestureNames))
    if key == ord('q'):
        break

# Clean up hardware and exit
# ====================================================================
# CLEAR LEDS ON SHUTDOWN
# ====================================================================
if NEOPIXEL_ENABLED:
    strip.fill((0, 0, 0))
    strip.show()
# ====================================================================

cv2.destroyAllWindows()
saveTrainedData(DATA_FILE, trainedData)
print('Program Terminated')

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import cv2

import time

from picamera2 import Picamera2

import mediapipe as mp

import math

import pickle

import os

import colorsys

# ====================================================================

# NEOPIXEL CONTROL INITIALIZATION (Adafruit neopixel_spi via SPI)

# ====================================================================

import board

import neopixel_spi as neopixel

NUM_LEDS = 12 # Set to match your NeoPixel ring size (e.g., 12)

PO = neopixel.GRB

# Initialize NeoPixel ring using SPI

spi = board.SPI()

strip = neopixel.NeoPixel_SPI(

spi,

NUM_LEDS,

pixel_order=PO,

auto_write=False

)

# Turn off all LEDs on startup

strip.fill(0)

strip.show()

NEOPIXEL_ENABLED = True

print("[INFO] NeoPixel SPI initialized successfully.")

# Animation state variables (non-blocking updates)

animation_step = 0

lastAnimUpdate = time.time()

# ====================================================================

DATA_FILE = "gestureNEOPIXEL.pkl"

# Function to save the trained gesture dictionary to a file using pickle

def saveTrainedData(filename, data):

with open(filename, 'wb') as f:

pickle.dump(data, f)

print("[INFO] Saved gesture data to " + str(filename))

# Function to load previously saved gesture data from a file

def loadTrainedData(filename):

if os.path.exists(filename):

with open(filename, 'rb') as f:

data = pickle.load(f)

print("[INFO] Loaded " + str(len(data)) + " gesture(s) from " + str(filename))

return data

return {}

# --- SETUP & INITIAL TRAINING ---

trainedData = loadTrainedData(DATA_FILE)

gestureNames = []

if not trainedData:

print("HAND GESTURE TRAINING SETUP")

numGestures = int(input("Enter Number of Gestures to Train On: "))

for idx in range(numGestures):

name = input("Enter Name for Gesture #" + str(idx + 1) + ": ")

gestureNames.append(name)

def findDistance(pt1, pt2):

dX = pt1.x - pt2.x

dY = pt1.y - pt2.y

dZ = pt1.z - pt2.z

return math.sqrt(dX*dX + dY*dY + dZ*dZ)

def getTipDistances(handLm):

lm = handLm.landmark

wrist = lm[0]

indexBase = lm[5]

scaleFactor = findDistance(wrist, indexBase)

tips = [lm[4], lm[8], lm[12], lm[16], lm[20]]

tipDistances = []

for tip in tips:

dist = findDistance(wrist, tip) / scaleFactor

tipDistances.append(dist)

for startTip in range(len(tips)):

for endTip in range(startTip + 1, len(tips)):

dist = findDistance(tips[startTip], tips[endTip]) / scaleFactor

tipDistances.append(dist)

return tipDistances

def calculateError(tipDist, trainDist):

totalError = 0

for idx in range(len(tipDist)):

diff = tipDist[idx] - trainDist[idx]

totalError += abs(diff)

return totalError

def findGesture(tipLive, trainedData, maxAllowedError):

bestMatch = "Unknown"

lowestError = 999999999

for gestureName, trainedDist in trainedData.items():

error = calculateError(tipLive, trainedDist)

if error < lowestError:

lowestError = error

bestMatch = gestureName

if lowestError > maxAllowedError:

return "Unknown"

return bestMatch

# ====================================================================

# NEOPIXEL CONTROL (COLOR HELPER & ANIMATION DISPATCHER)

# ====================================================================

def hsv2rgb(h):

""" Converts HSV float (0.0-1.0) to RGB integer tuple (0-255) """

r, g, b = colorsys.hsv_to_rgb(h, 1, 1)

return (int(r * 255), int(g * 255), int(b * 255))

def updateNeoPixels(gesture):

""" Non-blocking LED pattern update based on the current detected gesture """

global animation_step, lastAnimUpdate

if not NEOPIXEL_ENABLED:

return

now = time.time()

gestureClean = gesture.lower()

pattern_matched = False

# 1. FIST / CHARGE (Red pulse)

if gestureClean == "fist":

pulse = int(127 + 127 * math.sin(now * 5.0))

strip.fill((pulse, 0, 0))

strip.show()

pattern_matched = True

# 2. OPEN PALM / BEACON (Solid Bright White)

if gestureClean == "palm":

strip.fill((255, 255, 255))

strip.show()

pattern_matched = True

# 3. PEACE SIGN / DUAL SPINNER (Rotating Blue/Cyan dots)

if gestureClean == "peace":

if now - lastAnimUpdate > 0.08:

animation_step = (animation_step + 1) % NUM_LEDS

lastAnimUpdate = now

strip.fill((40, 0, 0)) # Background red

pos1 = animation_step

pos2 = (animation_step + (NUM_LEDS // 2)) % NUM_LEDS

strip[pos1] = (0, 255, 0) # Green spinner dot

strip[pos2] = (0, 0, 255) # Blue spinner dot

strip.show()

pattern_matched = True

# 4. THUMBS UP / SUCCESS (Solid Green)

if gestureClean == "thumbsup":

strip.fill((0, 255, 0))

strip.show()

pattern_matched = True

# 5. POINTING / CHASER (Radar sweep)

if gestureClean in "point":

if now - lastAnimUpdate > 0.06:

animation_step = (animation_step + 1) % NUM_LEDS

lastAnimUpdate = now

strip.fill((255, 0, 0))

strip[animation_step] = (0, 255, 0)

strip.show()

pattern_matched = True

# 6. ROCK / FIRE (Sinusoidal Green-Cyan pulse)

if gestureClean == "rock":

step = int((now * 100) % 360)

brightness = (math.sin(step * math.pi / 180) + 1) / 2

g = int(255 * brightness)

b = int(50 * brightness)

strip.fill((0, g, b))

strip.show()

pattern_matched = True

# 7. OK SIGN / RAINBOW WHEEL (Rotating RGB spectrum)

if gestureClean in "ok":

if now - lastAnimUpdate > 0.03:

animation_step = (animation_step + 1) % 100

lastAnimUpdate = now

hue = animation_step / 100.0

strip.fill(hsv2rgb(hue))

strip.show()

pattern_matched = True

# DEFAULT / UNKNOWN (LEDs OFF)

if not pattern_matched:

strip.fill((0, 0, 0))

strip.show()

# ====================================================================

W, H = 1280, 720

tStart = time.time()

fps = 15

RES = (W, H)

piCam = Picamera2(1)

piCam.preview_configuration.main.size = RES

piCam.preview_configuration.main.format = "RGB888"

piCam.preview_configuration.controls.FrameRate = 60

piCam.preview_configuration.align()

piCam.configure("preview")

piCam.start()

textLowerLeft = (int(W * .01), int(H * .07))

fontFace = cv2.FONT_HERSHEY_SIMPLEX

fontThickness = int(W / 425)

fontScale = H * .002

fontColor = (0, 0, 255)

textFps = (int(W * .01), int(H * .07))

textGesture = (int(W * .01), int(H * .14))

textGesturePrompt = (int(W * .01), int(H * .21))

maxErrorThreshold = 3.5

hands = mp.solutions.hands.Hands(

model_complexity=0,

min_detection_confidence=.5,

min_tracking_confidence=.5,

max_num_hands=2

)

trainIdx = 0

while True:

deltaT = time.time() - tStart

tStart = time.time()

fps = fps * .95 + (1 / deltaT) * .05

frame = piCam.capture_array()

frame = cv2.flip(frame, -1)

rgbFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

results = hands.process(rgbFrame)

if results.multi_hand_landmarks:

frameHeight, frameWidth, _ = frame.shape

for handLm in results.multi_hand_landmarks:

for idx, landmark in enumerate(handLm.landmark):

pixelX = int(landmark.x * frameWidth)

pixelY = int(landmark.y * frameHeight)

cv2.putText(

frame, str(idx), (pixelX, pixelY),

cv2.FONT_HERSHEY_SIMPLEX, .6 * fontScale, (255, 0, 0), fontThickness

)

if trainIdx < len(gestureNames):

targetName = gestureNames[trainIdx]

promptText = "show " + targetName + " & Press Space"

cv2.putText(frame, promptText, textGesturePrompt, fontFace, fontScale, (0, 255, 255), fontThickness)

detectGesture = "Unknown"

if results.multi_hand_landmarks:

liveDistances = getTipDistances(results.multi_hand_landmarks[0])

detectGesture = findGesture(liveDistances, trainedData, maxErrorThreshold)

# ====================================================================

# EXECUTE HARDWARE PATTERN UPDATE

# ====================================================================

updateNeoPixels(detectGesture)

# ====================================================================

labelText = "Gesture: " + detectGesture

cv2.putText(frame, labelText, textGesture, fontFace, fontScale, (0, 255, 0), fontThickness)

myText = "FPS: " + str(round(fps, 1))

cv2.putText(frame, myText, textLowerLeft, fontFace, fontScale, fontColor, fontThickness)

cv2.imshow("Camera", frame)

#cv2.moveWindow("Camera", 0, 60)

key = cv2.waitKey(1)

# Save landmark measurements when Space is pressed

if key == ord(' '):

if results.multi_hand_landmarks:

if trainIdx < len(gestureNames):

targetHand = results.multi_hand_landmarks[0]

targetName = gestureNames[trainIdx]

trainedData[targetName] = getTipDistances(targetHand)

saveTrainedData(DATA_FILE, trainedData)

trainIdx += 1

# 't' key allows adding a NEW gesture dynamically during runtime

if key == ord('t'):

newGestureName = input("Enter name for new gesture to train: ").strip()

if newGestureName:

gestureNames.append(newGestureName)

# 'd' key deletes a gesture

if key == ord('d'):

delName = input("Enter name of gesture to remove: ").strip()

if delName in trainedData:

del trainedData[delName]

saveTrainedData(DATA_FILE, trainedData)

print("[INFO] Removed " + delName + " from trained data.")

if delName in gestureNames:

gestureNames.remove(delName)

if delName not in trainedData:

print("[WARNING] Gesture: " + delName + " not found in trained data.")

trainIdx=min(trainIdx,len(gestureNames))

if key == ord('q'):

break

# Clean up hardware and exit

# ====================================================================

# CLEAR LEDS ON SHUTDOWN

# ====================================================================

if NEOPIXEL_ENABLED:

strip.fill((0, 0, 0))

strip.show()

# ====================================================================

cv2.destroyAllWindows()

saveTrainedData(DATA_FILE, trainedData)

print('Program Terminated')

Homework & Next Steps

Try setting up the circuit and running the code on your Raspberry Pi 5. Observe how the frame rate behaves when driving both the camera preview, the hand-tracking model, and the I2C OLED display simultaneously. For your homework, extend this script to include a dynamic color slider or gesture-based brightness control!

AI On the Edge

AI on the Edge LESSON 51: Gesture Control of NeoPixel Ring

September 18, 2026 admin

Welcome back, everyone! In today’s class, AI on the Edge LESSON 51: Gesture Control of NeoPixel Ring, we are bridging the gap between computer vision and physical hardware in a big way. Up until now, we have spent a lot of time tracking hands, plotting 3D landmarks, and rendering graphical user interfaces directly onto our camera feeds. But today, we take those virtual interactions and project them out into the real physical world using a 12-LED NeoPixel ring driven over SPI by our Raspberry Pi 5.

The core concept of this lesson is creating an intuitive, spatial gesture interface. Imagine looking at your monitor display where a graphical representation of a circular LED ring is overlaid onto your live camera feed. By extending your hand and placing your index finger tip over any of the twelve virtual LED nodes on screen, the system detects your hover position. When you pinch your thumb and index finger together, the program registers a toggle event, turning the corresponding physical LED on or off on the actual hardware ring sitting on your workbench.

To make this work reliably without wild bouncing or rapid flickering, we dive deep into the mechanics of gesture latching and debouncing. When a student first attempts spatial tracking, holding a pinch gesture over a target often causes the state to flip back and forth dozens of times per second. In this lesson, we implement a stateful boolean latch flag that locks down the trigger state the moment a pinch is registered. The algorithm strictly requires you to release the pinch—breaking contact between your thumb and index finger—before it will accept another command. This simple state machine logic is essential for turning noisy computer vision inputs into rock-solid physical control interfaces.

Beyond individual pixel control, we also construct a dynamic UI Mode Selection Panel on the right side of the screen. By hovering over the panel buttons and executing the same pinch gesture, you can cycle through five distinct lighting animation profiles in real time:

Static Mode: Displays fixed, custom-assigned palette colors for each active LED node.
Rainbow Mode: Distributes a static 360-degree color wheel spectrum across all twelve positions using HSV-to-RGB conversion algorithms.
Pulsate Mode: Modulates the physical brightness using a squared sine wave math function to guarantee a true black-floor fade on turned-on pixels.
Blink Mode: Synchronizes an on/off strobe animation derived from live system timestamps.
Running Rainbow Mode: Dynamically rotates the active hue spectrum around the ring by stepping the color offset frame-by-frame.

We handle all of this frame rate processing seamlessly using high-speed SPI bus communications through neopixel_spi and direct frame acquisition via Picamera2. By keeping auto-write disabled until all mathematical animation steps and hand-tracking calculations are completed for a given frame, we push smooth, flicker-free updates out to both the physical hardware and the OpenCV display overlay simultaneously.

Work through the complete Python script provided on this page, load it onto your Pi, and assemble your hardware circuit. Pay close attention to how the spatial math maps coordinates from normalized MediaPipe landmark spaces directly into circular screen coordinates using polar angle formulas. Grab your components, fire up your IDE, and let’s get building!

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================

# Import required computer vision, system, math, and hardware libraries
import cv2
import time
import numpy as np
import colorsys
import board
import neopixel_spi as neopixel
from picamera2 import Picamera2
import mediapipe as mp

# ==============================================================================
# HARDWARE & NEOPIXEL INITIALIZATION
# ==============================================================================

# Initialize SPI communication bus for high-speed LED control
spiBus = board.SPI()

# Total number of physical LEDs in the circular NeoPixel ring
ledCount = 12

# Color order setting required by NeoPixel hardware (Green-Red-Blue)
pixelOrder = neopixel.GRB

# Create the SPI NeoPixel strip object, disabling auto-write for manual updates
ledStrip = neopixel.NeoPixel_SPI(spiBus, ledCount, pixel_order=pixelOrder, auto_write=False)

# Clear any previous LED states by turning all physical pixels off initially
ledStrip.fill(0)
ledStrip.show()

print("✅ NeoPixel initialized!")

# Boolean array tracking the active power state (True = On / False = Off) for each LED
ledStates = [False] * 12

# Array tracking the active RGB color for each physical LED to sync with screen drawing
currentLedRgb = [(0, 0, 0)] * 12

# Static base RGB color mapping assigned to each individual LED index
ledColors = [
    (255, 0, 0),    # LED 0: Red
    (0, 255, 0),    # LED 1: Green
    (0, 0, 255),    # LED 2: Blue
    (0, 255, 255),  # LED 3: Cyan
    (255, 0, 255),  # LED 4: Magenta
    (255, 255, 0),  # LED 5: Yellow
    (255, 100, 0),  # LED 6: Orange
    (128, 0, 255),  # LED 7: Purple
    (0, 255, 128),  # LED 8: Spring Green
    (255, 0, 128),  # LED 9: Pink
    (128, 255, 0),  # LED 10: Chartreuse
    (0, 128, 255)   # LED 11: Light Blue
]

# ==============================================================================
# LIGHTING MODES & STATE TRACKING
# ==============================================================================

# Available animation profiles selectable from the UI panel
modes = ["Static", "Rainbow", "Pulsate", "Blink", "Running Rainbow"]

# Index tracker for the active lighting mode
currentMode = 0

# Math phase tracker used for calculating brightness modulation in Pulsate mode
pulsePhase = 0

# Degree offset tracker used for rotating hue spectrums in Rainbow modes
rainbowOffset = 0

# Degree offset for frame-by-frame 1-degree hue increment
runningHueOffset = 0

# ==============================================================================
# DEBOUNCE & GESTURE LATCHING CONTROL FLAGS
# ==============================================================================

# Stateful latch flag to require full gesture release before accepting new toggles.
# This prevents rapid re-triggering (blinking) when holding a pinch over a node.
isGestureActive = False

# ==============================================================================
# PICAMERA2 & MEDIAPIPE HAND TRACKING SETUP
# ==============================================================================

# Instantiate PiCamera2 object targeting camera device 1
piCam = Picamera2(1)

# Screen resolution settings matching camera stream aspect ratio
frameWidth = 1280
frameHeight = 720

# Configure preview window resolution and color stream formatting
piCam.preview_configuration.main.size = (frameWidth, frameHeight)
piCam.preview_configuration.main.format = "RGB888"
piCam.preview_configuration.controls.FrameRate = 60
piCam.preview_configuration.align()
piCam.configure("preview")
piCam.start()

# Load MediaPipe hand detection module components
mpHands = mp.solutions.hands
handsDetector = mpHands.Hands(
    model_complexity=1, 
    min_detection_confidence=0.7,
    min_tracking_confidence=0.7, 
    max_num_hands=1
)
mpDraw = mp.solutions.drawing_utils

# Visual overlay center coordinate and radius for rendering the circular LED ring
centerX = frameWidth // 2 
centerY = frameHeight // 2
ringRadius = 220
cv2.namedWindow("NeoPixel Ring Controller",cv2.WINDOW_GUI_NORMAL)
cv2.moveWindow("NeoPixel Ring Controller",0,65)
cv2.resizeWindow("NeoPixel Ring Controller",frameWidth,frameHeight)
# ==============================================================================
# MAIN APPLICATION LOOP
# ==============================================================================
while True:
    # Capture raw frame matrix from PiCamera stream
    frameData = piCam.capture_array()
    
    # Mirror preview display horizontally and vertically to match natural orientation
    frameData = cv2.flip(frameData, -1)
    frameData = cv2.flip(frameData, 1)
    
    # Convert image format from BGR to RGB required by MediaPipe
    rgbFrame = cv2.cvtColor(frameData, cv2.COLOR_BGR2RGB)

    # Execute hand keypoint extraction on the converted frame
    trackingResults = handsDetector.process(rgbFrame)

    # Create image copy dedicated for drawing visual UI overlays
    displayFrame = frameData.copy()

    # Capture current UNIX epoch timestamp for time-based animation calculations
    currentTime = time.time()

    # Flag tracking whether a valid action gesture occurred in the current frame
    gestureTriggeredThisFrame = False

    # Process hand gesture logic if hand landmarks are detected
    if trackingResults.multi_hand_landmarks:
        for handLandmarks in trackingResults.multi_hand_landmarks:
            # Draw skeletal connections over the detected hand on display image
            mpDraw.draw_landmarks(displayFrame, handLandmarks, mpHands.HAND_CONNECTIONS)

            # Extract full list of 3D spatial points for all key joints
            landmarksList = handLandmarks.landmark
            indexTipPoint = landmarksList[8]  # Joint landmark index 8 (Index finger tip)
            thumbTipPoint = landmarksList[4]  # Joint landmark index 4 (Thumb tip)

            # Map coordinates from normalized values (0-1) to pixel dimensions
            indexPixelX = int(indexTipPoint.x * frameWidth)
            indexPixelY = int(indexTipPoint.y * frameHeight)
            thumbPixelX = int(thumbTipPoint.x * frameWidth)
            thumbPixelY = int(thumbTipPoint.y * frameHeight)

            # Calculate Euclidean distance between index tip and thumb tip in pixels
            pinchDistance = np.hypot(indexPixelX - thumbPixelX, indexPixelY - thumbPixelY)

            # Check pointing interaction against every LED position along the circle
            for ledIdx in range(12):
                # Angle formula: Starts at +pi/2 (bottom) and rotates clockwise (- direction)
                polarAngle = (np.pi / 2) - ledIdx * (2 * np.pi / 12)
                
                # Derive 2D screen positions matching physical ring layout
                ledPixelX = int(centerX + ringRadius * np.cos(polarAngle))
                ledPixelY = int(centerY + ringRadius * np.sin(polarAngle))
                
                # Compute straight-line Euclidean distance between index finger and target LED
                pointDistance = np.hypot(indexPixelX - ledPixelX, indexPixelY - ledPixelY)

                # Determine if fingertip is hovering within interaction radius of an LED point (Relaxed to 60px)
                if pointDistance < 60:
                    # Highlight active target LED with concentric indicator rings
                    cv2.circle(displayFrame, (ledPixelX, ledPixelY), 38, (0, 255, 255), 6)
                    cv2.circle(displayFrame, (ledPixelX, ledPixelY), 22, (255, 255, 100), -1)

                    # Verify pinch condition (Relaxed to 55px threshold for easier detection)
                    if pinchDistance < 55:
                        gestureTriggeredThisFrame = True
                        
                        # Draw pinch visual feedback ring connecting index and thumb
                        cv2.circle(displayFrame, (indexPixelX, indexPixelY), 15, (0, 255, 0), -1)
                        
                        # Execute state change only if the gesture was not already latched
                        if not isGestureActive:
                            # Invert boolean state for selected LED
                            ledStates[ledIdx] = not ledStates[ledIdx]
                            
                            # Lock gesture activation state until user unpinches
                            isGestureActive = True

            # Process UI mode panel interaction if pointing inside designated top-right screen area
            if indexPixelX > frameWidth - 280:
                if indexPixelY < 420:
                    # Map vertical pixel coordinate directly to corresponding mode list index
                    modeIndexChoice = (indexPixelY - 80) // 70
                    
                    # Verify target index falls within valid bounds of the mode selection list
                    if 0 <= modeIndexChoice < len(modes):
                        # Verify pinch condition to confirm mode selection (Relaxed to 55px)
                        if pinchDistance < 55:
                            gestureTriggeredThisFrame = True
                            
                            # Draw pinch visual feedback ring connecting index and thumb
                            cv2.circle(displayFrame, (indexPixelX, indexPixelY), 15, (0, 255, 0), -1)
                            
                            # Execute mode switch only if the gesture was not already latched
                            if not isGestureActive:
                                currentMode = modeIndexChoice
                                
                                # Lock gesture activation state until user unpinches
                                isGestureActive = True

    # Reset latch flag when hand gesture is unpinched or moved off targets
    if not gestureTriggeredThisFrame:
        isGestureActive = False

    # ==========================================================================
    # DYNAMIC LIGHTING ANIMATION EFFECTS & HARDWARE COLOR UPDATES
    # ==========================================================================
    
    # MODE 0: Static colors assigned directly from preset ledColors palette
    if currentMode == 0:
        for ledIdx in range(12):
            if ledStates[ledIdx]:
                currentLedRgb[ledIdx] = ledColors[ledIdx]
            if not ledStates[ledIdx]:
                currentLedRgb[ledIdx] = (0, 0, 0)

# MODE 1: Fixed rainbow distribution (Red at LED 0, stepping by 30 degrees, static)
    if currentMode == 1:
        for ledIdx in range(12):
            if ledStates[ledIdx]:
                calculatedHue = ledIdx * 30  # 360 degrees / 12 LEDs = 30 degrees per step
                redVal, greenVal, blueVal = [int(channel * 255) for channel in colorsys.hsv_to_rgb(calculatedHue / 360.0, 1, 1)]
                currentLedRgb[ledIdx] = (redVal, greenVal, blueVal)
            if not ledStates[ledIdx]:
                currentLedRgb[ledIdx] = (0, 0, 0)

    # MODE 2: Pulsating brightness modulation (squared sine wave for true black floor fade)
    if currentMode == 2:
        pulsePhase += 0.15
        calculatedBrightness = ((np.sin(pulsePhase) + 1) / 2) ** 2
        for ledIdx in range(12):
            if ledStates[ledIdx]:
                baseRed, baseGreen, baseBlue = ledColors[ledIdx]
                currentLedRgb[ledIdx] = (
                    int(baseRed * calculatedBrightness),
                    int(baseGreen * calculatedBrightness),
                    int(baseBlue * calculatedBrightness)
                )
            if not ledStates[ledIdx]:
                currentLedRgb[ledIdx] = (0, 0, 0)

    # MODE 3: Blinking on/off light strobe animation
    if currentMode == 3:
        blinkToggleState = int(currentTime * 3) % 2
        for ledIdx in range(12):
            if ledStates[ledIdx]:
                if blinkToggleState:
                    currentLedRgb[ledIdx] = ledColors[ledIdx]
                if not blinkToggleState:
                    currentLedRgb[ledIdx] = (0, 0, 0)
            if not ledStates[ledIdx]:
                currentLedRgb[ledIdx] = (0, 0, 0)

# MODE 4: Evenly-spaced rainbow incrementing 1 degree per cycle
    if currentMode == 4:
        for ledIdx in range(12):
            if ledStates[ledIdx]:
                # Start at evenly spaced base angle (30 deg apart) and add 1-degree step offset
                calculatedHue = (ledIdx * 30 + runningHueOffset) % 360

                # Convert normalized float hue (0.0 to 1.0) to RGB
                rFloat, gFloat, bFloat = colorsys.hsv_to_rgb(calculatedHue / 360.0, 1.0, 1.0)
                currentLedRgb[ledIdx] = (
                    int(round(rFloat * 255)),
                    int(round(gFloat * 255)),
                    int(round(bFloat * 255))
                )
            if not ledStates[ledIdx]:
                currentLedRgb[ledIdx] = (0, 0, 0)

        # Increment offset by exactly 1 degree each frame cycle, wrapping 360 back to 0
        runningHueOffset = (runningHueOffset + 2) % 360
    # Push all updated mode colors out to physical NeoPixel hardware strip
    for ledIdx in range(12):
        ledStrip[ledIdx] = currentLedRgb[ledIdx]
    ledStrip.show()

    # ==========================================================================
    # ON-SCREEN GRAPHICAL RENDERING (LED RING MATCHING PHYSICAL HARDWARE)
    # ==========================================================================
    for ledIdx in range(12):
        # Angle formula: Starts at +pi/2 (bottom) and rotates clockwise (- direction)
        polarAngle = (np.pi / 2) - ledIdx * (2 * np.pi / 12)
        targetX = int(centerX + ringRadius * np.cos(polarAngle))
        targetY = int(centerY + ringRadius * np.sin(polarAngle))

        # Render illuminated state representation using exact active hardware color
        if ledStates[ledIdx]:
            # Extract current RGB hardware values
            redVal, greenVal, blueVal = currentLedRgb[ledIdx]
            
            # Convert RGB tuple to BGR tuple format required by OpenCV rendering
            openCvBgrColor = (blueVal, greenVal, redVal)
            
            # Draw illuminated circle matching active physical LED color
            cv2.circle(displayFrame, (targetX, targetY), 24, openCvBgrColor, -1)
            cv2.circle(displayFrame, (targetX, targetY), 31, (255, 255, 255), 4)

        # Render dimmed inactive state representation if turned off
        if not ledStates[ledIdx]:
            cv2.circle(displayFrame, (targetX, targetY), 20, (50, 50, 50), -1)
            cv2.circle(displayFrame, (targetX, targetY), 27, (90, 90, 90), 3)

        # Draw LED index numerical labels inside each visual circle node
        cv2.putText(
            displayFrame, str(ledIdx), (targetX - 9, targetY + 7),
            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2
        )

    # ==========================================================================
    # ON-SCREEN GRAPHICAL RENDERING (MODE SELECTION PANEL)
    # ==========================================================================
    panelPositionX = frameWidth - 260
    for modeIdx, modeName in enumerate(modes):
        panelPositionY = 80 + modeIdx * 70
        
        # Default unselected button background color in BGR (Dark Gray)
        highlightColor = (100, 100, 100)
        
        # Override background color with vibrant Blue in BGR format when mode is selected
        if modeIdx == currentMode:
            highlightColor = (255, 100, 0)

        # Draw background menu card rectangle
        cv2.rectangle(displayFrame, (panelPositionX, panelPositionY), (panelPositionX + 240, panelPositionY + 60), highlightColor, -1)
        
        # Draw outer border line around menu card rectangle
        cv2.rectangle(displayFrame, (panelPositionX, panelPositionY), (panelPositionX + 240, panelPositionY + 60), (255, 255, 255), 3)
        
        # Render string name for lighting mode into menu card
        cv2.putText(
            displayFrame, modeName, (panelPositionX + 20, panelPositionY + 40),
            cv2.FONT_HERSHEY_SIMPLEX, 0.75, (255, 255, 255), 2
        )

    # ==========================================================================
    # INSTRUCTION OVERLAYS & WINDOW MANAGEMENT
    # ==========================================================================
    cv2.putText(
        displayFrame, "Point + Pinch = Toggle LED", (30, frameHeight - 40),
        cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2
    )
    cv2.putText(
        displayFrame, "Point Right Panel + Pinch = Select Mode", (30, frameHeight - 80),
        cv2.FONT_HERSHEY_SIMPLEX, 0.65, (200, 200, 200), 2
    )

    # Render completed frame to OpenCV GUI window
    cv2.imshow("NeoPixel Ring Controller", displayFrame)
    # Read user keypress events (Wait for 1 millisecond)
    activeKey = cv2.waitKey(1) & 0xFF
    
    # Process exit program trigger if 'q' key is pressed
    if activeKey == ord('q'):
        break
        
    # Process reset/clear trigger if 'c' key is pressed
    if activeKey == ord('c'):
        ledStates = [False] * 12
        currentLedRgb = [(0, 0, 0)] * 12
        ledStrip.fill(0)
        ledStrip.show()

# ==============================================================================
# CLEANUP & SHUTDOWN PROCEDURES
# ==============================================================================
print('Program Terminated')

# Close open OpenCV GUI windows
cv2.destroyAllWindows()

# Ensure all physical NeoPixels are safely powered off on exit
ledStrip.fill(0)
ledStrip.show()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

# Import required computer vision, system, math, and hardware libraries

import cv2

import time

import numpy as np

import colorsys

import board

import neopixel_spi as neopixel

from picamera2 import Picamera2

import mediapipe as mp

# ==============================================================================

# HARDWARE & NEOPIXEL INITIALIZATION

# ==============================================================================

# Initialize SPI communication bus for high-speed LED control

spiBus = board.SPI()

# Total number of physical LEDs in the circular NeoPixel ring

ledCount = 12

# Color order setting required by NeoPixel hardware (Green-Red-Blue)

pixelOrder = neopixel.GRB

# Create the SPI NeoPixel strip object, disabling auto-write for manual updates

ledStrip = neopixel.NeoPixel_SPI(spiBus, ledCount, pixel_order=pixelOrder, auto_write=False)

# Clear any previous LED states by turning all physical pixels off initially

ledStrip.fill(0)

ledStrip.show()

print("✅ NeoPixel initialized!")

# Boolean array tracking the active power state (True = On / False = Off) for each LED

ledStates = [False] * 12

# Array tracking the active RGB color for each physical LED to sync with screen drawing

currentLedRgb = [(0, 0, 0)] * 12

# Static base RGB color mapping assigned to each individual LED index

ledColors = [

(255, 0, 0), # LED 0: Red

(0, 255, 0), # LED 1: Green

(0, 0, 255), # LED 2: Blue

(0, 255, 255), # LED 3: Cyan

(255, 0, 255), # LED 4: Magenta

(255, 255, 0), # LED 5: Yellow

(255, 100, 0), # LED 6: Orange

(128, 0, 255), # LED 7: Purple

(0, 255, 128), # LED 8: Spring Green

(255, 0, 128), # LED 9: Pink

(128, 255, 0), # LED 10: Chartreuse

(0, 128, 255) # LED 11: Light Blue

]

# ==============================================================================

# LIGHTING MODES & STATE TRACKING

# ==============================================================================

# Available animation profiles selectable from the UI panel

modes = ["Static", "Rainbow", "Pulsate", "Blink", "Running Rainbow"]

# Index tracker for the active lighting mode

currentMode = 0

# Math phase tracker used for calculating brightness modulation in Pulsate mode

pulsePhase = 0

# Degree offset tracker used for rotating hue spectrums in Rainbow modes

rainbowOffset = 0

# Degree offset for frame-by-frame 1-degree hue increment

runningHueOffset = 0

# ==============================================================================

# DEBOUNCE & GESTURE LATCHING CONTROL FLAGS

# ==============================================================================

# Stateful latch flag to require full gesture release before accepting new toggles.

# This prevents rapid re-triggering (blinking) when holding a pinch over a node.

isGestureActive = False

# ==============================================================================

# PICAMERA2 & MEDIAPIPE HAND TRACKING SETUP

# ==============================================================================

# Instantiate PiCamera2 object targeting camera device 1

piCam = Picamera2(1)

# Screen resolution settings matching camera stream aspect ratio

frameWidth = 1280

frameHeight = 720

# Configure preview window resolution and color stream formatting

piCam.preview_configuration.main.size = (frameWidth, frameHeight)

piCam.preview_configuration.main.format = "RGB888"

piCam.preview_configuration.controls.FrameRate = 60

piCam.preview_configuration.align()

piCam.configure("preview")

piCam.start()

# Load MediaPipe hand detection module components

mpHands = mp.solutions.hands

handsDetector = mpHands.Hands(

model_complexity=1,

min_detection_confidence=0.7,

min_tracking_confidence=0.7,

max_num_hands=1

)

mpDraw = mp.solutions.drawing_utils

# Visual overlay center coordinate and radius for rendering the circular LED ring

centerX = frameWidth // 2

centerY = frameHeight // 2

ringRadius = 220

cv2.namedWindow("NeoPixel Ring Controller",cv2.WINDOW_GUI_NORMAL)

cv2.moveWindow("NeoPixel Ring Controller",0,65)

cv2.resizeWindow("NeoPixel Ring Controller",frameWidth,frameHeight)

# ==============================================================================

# MAIN APPLICATION LOOP

# ==============================================================================

while True:

# Capture raw frame matrix from PiCamera stream

frameData = piCam.capture_array()

# Mirror preview display horizontally and vertically to match natural orientation

frameData = cv2.flip(frameData, -1)

frameData = cv2.flip(frameData, 1)

# Convert image format from BGR to RGB required by MediaPipe

rgbFrame = cv2.cvtColor(frameData, cv2.COLOR_BGR2RGB)

# Execute hand keypoint extraction on the converted frame

trackingResults = handsDetector.process(rgbFrame)

# Create image copy dedicated for drawing visual UI overlays

displayFrame = frameData.copy()

# Capture current UNIX epoch timestamp for time-based animation calculations

currentTime = time.time()

# Flag tracking whether a valid action gesture occurred in the current frame

gestureTriggeredThisFrame = False

# Process hand gesture logic if hand landmarks are detected

if trackingResults.multi_hand_landmarks:

for handLandmarks in trackingResults.multi_hand_landmarks:

# Draw skeletal connections over the detected hand on display image

mpDraw.draw_landmarks(displayFrame, handLandmarks, mpHands.HAND_CONNECTIONS)

# Extract full list of 3D spatial points for all key joints

landmarksList = handLandmarks.landmark

indexTipPoint = landmarksList[8] # Joint landmark index 8 (Index finger tip)

thumbTipPoint = landmarksList[4] # Joint landmark index 4 (Thumb tip)

# Map coordinates from normalized values (0-1) to pixel dimensions

indexPixelX = int(indexTipPoint.x * frameWidth)

indexPixelY = int(indexTipPoint.y * frameHeight)

thumbPixelX = int(thumbTipPoint.x * frameWidth)

thumbPixelY = int(thumbTipPoint.y * frameHeight)

# Calculate Euclidean distance between index tip and thumb tip in pixels

pinchDistance = np.hypot(indexPixelX - thumbPixelX, indexPixelY - thumbPixelY)

# Check pointing interaction against every LED position along the circle

for ledIdx in range(12):

# Angle formula: Starts at +pi/2 (bottom) and rotates clockwise (- direction)

polarAngle = (np.pi / 2) - ledIdx * (2 * np.pi / 12)

# Derive 2D screen positions matching physical ring layout

ledPixelX = int(centerX + ringRadius * np.cos(polarAngle))

ledPixelY = int(centerY + ringRadius * np.sin(polarAngle))

# Compute straight-line Euclidean distance between index finger and target LED

pointDistance = np.hypot(indexPixelX - ledPixelX, indexPixelY - ledPixelY)

# Determine if fingertip is hovering within interaction radius of an LED point (Relaxed to 60px)

if pointDistance < 60:

# Highlight active target LED with concentric indicator rings

cv2.circle(displayFrame, (ledPixelX, ledPixelY), 38, (0, 255, 255), 6)

cv2.circle(displayFrame, (ledPixelX, ledPixelY), 22, (255, 255, 100), -1)

# Verify pinch condition (Relaxed to 55px threshold for easier detection)

if pinchDistance < 55:

gestureTriggeredThisFrame = True

# Draw pinch visual feedback ring connecting index and thumb

cv2.circle(displayFrame, (indexPixelX, indexPixelY), 15, (0, 255, 0), -1)

# Execute state change only if the gesture was not already latched

if not isGestureActive:

# Invert boolean state for selected LED

ledStates[ledIdx] = not ledStates[ledIdx]

# Lock gesture activation state until user unpinches

isGestureActive = True

# Process UI mode panel interaction if pointing inside designated top-right screen area

if indexPixelX > frameWidth - 280:

if indexPixelY < 420:

# Map vertical pixel coordinate directly to corresponding mode list index

modeIndexChoice = (indexPixelY - 80) // 70

# Verify target index falls within valid bounds of the mode selection list

if 0 <= modeIndexChoice < len(modes):

# Verify pinch condition to confirm mode selection (Relaxed to 55px)

if pinchDistance < 55:

gestureTriggeredThisFrame = True

# Draw pinch visual feedback ring connecting index and thumb

cv2.circle(displayFrame, (indexPixelX, indexPixelY), 15, (0, 255, 0), -1)

# Execute mode switch only if the gesture was not already latched

if not isGestureActive:

currentMode = modeIndexChoice

# Lock gesture activation state until user unpinches

isGestureActive = True

# Reset latch flag when hand gesture is unpinched or moved off targets

if not gestureTriggeredThisFrame:

isGestureActive = False

# ==========================================================================

# DYNAMIC LIGHTING ANIMATION EFFECTS & HARDWARE COLOR UPDATES

# ==========================================================================

# MODE 0: Static colors assigned directly from preset ledColors palette

if currentMode == 0:

for ledIdx in range(12):

if ledStates[ledIdx]:

currentLedRgb[ledIdx] = ledColors[ledIdx]

if not ledStates[ledIdx]:

currentLedRgb[ledIdx] = (0, 0, 0)

# MODE 1: Fixed rainbow distribution (Red at LED 0, stepping by 30 degrees, static)

if currentMode == 1:

for ledIdx in range(12):

if ledStates[ledIdx]:

calculatedHue = ledIdx * 30 # 360 degrees / 12 LEDs = 30 degrees per step

redVal, greenVal, blueVal = [int(channel * 255) for channel in colorsys.hsv_to_rgb(calculatedHue / 360.0, 1, 1)]

currentLedRgb[ledIdx] = (redVal, greenVal, blueVal)

if not ledStates[ledIdx]:

currentLedRgb[ledIdx] = (0, 0, 0)

# MODE 2: Pulsating brightness modulation (squared sine wave for true black floor fade)

if currentMode == 2:

pulsePhase += 0.15

calculatedBrightness = ((np.sin(pulsePhase) + 1) / 2) ** 2

for ledIdx in range(12):

if ledStates[ledIdx]:

baseRed, baseGreen, baseBlue = ledColors[ledIdx]

currentLedRgb[ledIdx] = (

int(baseRed * calculatedBrightness),

int(baseGreen * calculatedBrightness),

int(baseBlue * calculatedBrightness)

)

if not ledStates[ledIdx]:

currentLedRgb[ledIdx] = (0, 0, 0)

# MODE 3: Blinking on/off light strobe animation

if currentMode == 3:

blinkToggleState = int(currentTime * 3) % 2

for ledIdx in range(12):

if ledStates[ledIdx]:

if blinkToggleState:

currentLedRgb[ledIdx] = ledColors[ledIdx]

if not blinkToggleState:

currentLedRgb[ledIdx] = (0, 0, 0)

if not ledStates[ledIdx]:

currentLedRgb[ledIdx] = (0, 0, 0)

# MODE 4: Evenly-spaced rainbow incrementing 1 degree per cycle

if currentMode == 4:

for ledIdx in range(12):

if ledStates[ledIdx]:

# Start at evenly spaced base angle (30 deg apart) and add 1-degree step offset

calculatedHue = (ledIdx * 30 + runningHueOffset) % 360

# Convert normalized float hue (0.0 to 1.0) to RGB

rFloat, gFloat, bFloat = colorsys.hsv_to_rgb(calculatedHue / 360.0, 1.0, 1.0)

currentLedRgb[ledIdx] = (

int(round(rFloat * 255)),

int(round(gFloat * 255)),

int(round(bFloat * 255))

)

if not ledStates[ledIdx]:

currentLedRgb[ledIdx] = (0, 0, 0)

# Increment offset by exactly 1 degree each frame cycle, wrapping 360 back to 0

runningHueOffset = (runningHueOffset + 2) % 360

# Push all updated mode colors out to physical NeoPixel hardware strip

for ledIdx in range(12):

ledStrip[ledIdx] = currentLedRgb[ledIdx]

ledStrip.show()

# ==========================================================================

# ON-SCREEN GRAPHICAL RENDERING (LED RING MATCHING PHYSICAL HARDWARE)

# ==========================================================================

for ledIdx in range(12):

# Angle formula: Starts at +pi/2 (bottom) and rotates clockwise (- direction)

polarAngle = (np.pi / 2) - ledIdx * (2 * np.pi / 12)

targetX = int(centerX + ringRadius * np.cos(polarAngle))

targetY = int(centerY + ringRadius * np.sin(polarAngle))

# Render illuminated state representation using exact active hardware color

if ledStates[ledIdx]:

# Extract current RGB hardware values

redVal, greenVal, blueVal = currentLedRgb[ledIdx]

# Convert RGB tuple to BGR tuple format required by OpenCV rendering

openCvBgrColor = (blueVal, greenVal, redVal)

# Draw illuminated circle matching active physical LED color

cv2.circle(displayFrame, (targetX, targetY), 24, openCvBgrColor, -1)

cv2.circle(displayFrame, (targetX, targetY), 31, (255, 255, 255), 4)

# Render dimmed inactive state representation if turned off

if not ledStates[ledIdx]:

cv2.circle(displayFrame, (targetX, targetY), 20, (50, 50, 50), -1)

cv2.circle(displayFrame, (targetX, targetY), 27, (90, 90, 90), 3)

# Draw LED index numerical labels inside each visual circle node

cv2.putText(

displayFrame, str(ledIdx), (targetX - 9, targetY + 7),

cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2

)

# ==========================================================================

# ON-SCREEN GRAPHICAL RENDERING (MODE SELECTION PANEL)

# ==========================================================================

panelPositionX = frameWidth - 260

for modeIdx, modeName in enumerate(modes):

panelPositionY = 80 + modeIdx * 70

# Default unselected button background color in BGR (Dark Gray)

highlightColor = (100, 100, 100)

# Override background color with vibrant Blue in BGR format when mode is selected

if modeIdx == currentMode:

highlightColor = (255, 100, 0)

# Draw background menu card rectangle

cv2.rectangle(displayFrame, (panelPositionX, panelPositionY), (panelPositionX + 240, panelPositionY + 60), highlightColor, -1)

# Draw outer border line around menu card rectangle

cv2.rectangle(displayFrame, (panelPositionX, panelPositionY), (panelPositionX + 240, panelPositionY + 60), (255, 255, 255), 3)

# Render string name for lighting mode into menu card

cv2.putText(

displayFrame, modeName, (panelPositionX + 20, panelPositionY + 40),

cv2.FONT_HERSHEY_SIMPLEX, 0.75, (255, 255, 255), 2

)

# ==========================================================================

# INSTRUCTION OVERLAYS & WINDOW MANAGEMENT

# ==========================================================================

cv2.putText(

displayFrame, "Point + Pinch = Toggle LED", (30, frameHeight - 40),

cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2

)

cv2.putText(

displayFrame, "Point Right Panel + Pinch = Select Mode", (30, frameHeight - 80),

cv2.FONT_HERSHEY_SIMPLEX, 0.65, (200, 200, 200), 2

)

# Render completed frame to OpenCV GUI window

cv2.imshow("NeoPixel Ring Controller", displayFrame)

# Read user keypress events (Wait for 1 millisecond)

activeKey = cv2.waitKey(1) & 0xFF

# Process exit program trigger if 'q' key is pressed

if activeKey == ord('q'):

break

# Process reset/clear trigger if 'c' key is pressed

if activeKey == ord('c'):

ledStates = [False] * 12

currentLedRgb = [(0, 0, 0)] * 12

ledStrip.fill(0)

ledStrip.show()

# ==============================================================================

# CLEANUP & SHUTDOWN PROCEDURES

# ==============================================================================

print('Program Terminated')

# Close open OpenCV GUI windows

cv2.destroyAllWindows()

# Ensure all physical NeoPixels are safely powered off on exit

ledStrip.fill(0)

ledStrip.show()

AI On the Edge, Raspberry Pi

AI on the Edge LESSON 50: Control NeoPixel Ring With Hand Gestures and MediaPipe

September 13, 2026 admin

Hey everybody, welcome back to AI on the Edge! In Lesson 50 we’re taking things to the next level — we’re combining real-time hand tracking with a physical NeoPixel ring so you can change colors just by pointing at the screen! Using MediaPipe on the Raspberry Pi, we track your index finger tip and turn the big camera view into an interactive color picker. Hover over any of the seven big colored circles (Red, Green, Blue, Cyan, Magenta, Yellow, or Black) and — boom — the NeoPixel ring instantly lights up with that color!

This lesson is super fun because it finally brings together everything we’ve been building: smooth hand detection, coordinate mapping between camera and OLED, visual feedback, and real-world hardware control. You’ll see your finger tracked with a big blue dot, watch the selected color update live on both the screen and the OLED, and control actual RGB lights with nothing but a gesture.

By the end of this lesson you’ll have a working gesture-controlled color mixer that feels like real interactive magic. This is the kind of project that makes people say “Wow, you built that on a Raspberry Pi?!”

This is also a perfect foundation for even cooler future projects — gesture-controlled lighting, touchless interfaces, interactive games, or even a full gesture-controlled robot or light show.

So grab your Raspberry Pi, hook up that NeoPixel ring, fire up the camera, and let’s start waving our hands around like we’re casting spells! As always, the complete code is right below the video. Watch along, run the code, then start tweaking it — maybe add more colors, make the ring react differently to gestures, or combine it with the hand connection drawing from earlier lessons.I’m really excited to see what you create with this one!Now go make something awesome!

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================
 
import cv2
import time
from picamera2 import Picamera2
import mediapipe as mp
import board
import adafruit_ssd1306
from PIL import Image,ImageDraw,ImageFont

wOLED = 128
hOLED = 64
I2C_ADDRESS = 0x3C
i2c = board.I2C()
oled = adafruit_ssd1306.SSD1306_I2C(wOLED, hOLED, i2c, addr = I2C_ADDRESS)

W=1280
H=720
tStart = time.time()
fps = 0

RES = (W,H)
piCam = Picamera2(1)
piCam.preview_configuration.main.size = RES
piCam.preview_configuration.main.format = "RGB888"
piCam.preview_configuration.controls.FrameRate=60
piCam.preview_configuration.align()
piCam.configure("preview")
piCam.start()

textLowerLeft = (int(W*.01),int(H*.05))
fontFace = cv2.FONT_HERSHEY_SIMPLEX
fontThickness = int(W/425)
fontScale = H*.0015
fontColor = (0,0,255)

hands = mp.solutions.hands.Hands(
    model_complexity =  0,
    min_detection_confidence = .5,
    min_tracking_confidence = .5,
    max_num_hands =2)
mpDraw = mp.solutions.drawing_utils

cv2.namedWindow('Camera',cv2.WINDOW_GUI_NORMAL)
cv2.moveWindow('Camera',0,65)
cv2.resizeWindow('Camera',W,H)

import neopixel_spi as neopixel
spi = board.SPI()
strip = neopixel.NeoPixel_SPI(spi, 12,
        pixel_order=neopixel.GRB,auto_write=False)
strip.fill(0)
strip.show()

xStart=int(W/2)
yStart=int(H/10)
margin=100
radius=25
radiusOutline=30
radiusFlash=35
boxW = 4*radius
boxH =int(.75*boxW)
xSpace= int((W-2*margin)/2/3)
colorDot= [(xStart-3*xSpace,yStart),(xStart-2*xSpace,yStart),(xStart-xSpace,yStart),(xStart,yStart),(xStart+xSpace,yStart),(xStart+2*xSpace,yStart),(xStart+3*xSpace,yStart)]
oledPOS=[]
for dot in colorDot:
    oledPOS.append((int(dot[0]/W*wOLED),int(dot[1]/H*hOLED*.4)))
oledText = ['R','G','B','C','M','Y','B']
colorLabel = 'B'
colors =[(0,0,255),(0,255,0),(255,0,0),(255,255,0),(255,0,255),(0,255,255),(0,0,0)]
xBox = xStart-3*xSpace
yBox = int(yStart*1.5)
boxUpperLeft = (int(xBox-radius-boxW/4),yBox)
boxLowerRight = (int(xBox-radius-boxW/4+boxW),yBox+boxH)
colorActive =(0,0,0)
inCircle = False
                 
while True:
    deltaT = time.time() - tStart
    tStart=time.time()
    fps = fps*.95 + (1/deltaT)*.05
    frame= piCam.capture_array()
    frame=cv2.flip(frame,-1)
    frame=cv2.flip(frame,1)
    image = Image.new('1',(wOLED,hOLED))
    draw = ImageDraw.Draw(image)
    for i in range(7):
        if inCircle:
            cv2.circle(frame,colorDot[i],radiusFlash,(255,255,255),-1)
        cv2.circle(frame,colorDot[i],radiusOutline,(200,200,200),-1)
        cv2.circle(frame,colorDot[i],radius,colors[i],-1)
        draw.text(oledPOS[i],oledText[i],fill=255)
    cv2.rectangle(frame,boxUpperLeft,boxLowerRight,colorActive,-1)
    rgbFrame= cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    handResults = hands.process(rgbFrame)
    if handResults.multi_hand_landmarks:
        for myHands in handResults.multi_hand_landmarks:
            landMarks = myHands.landmark
            x = int(landMarks[8].x*W)
            y = int(landMarks[8].y*H)
            xOLED = int(landMarks[8].x*wOLED)
            yOLED = int(landMarks[8].y*hOLED)
            cv2.circle(frame,(x,y),10,(255,0,0), -1)
            draw.ellipse((xOLED-3,yOLED-4,xOLED+3,yOLED+4),fill=255)
            cnt = 0
            for pos in colorDot:
                if abs(x-pos[0])<radius and abs(y-pos[1])<radius:
                    colorActive=colors[cnt]
                    colorLabel =oledText[cnt]
                    #draw.text((int(wOLED/2),int(hOLED/2)),oledText[cnt],fill=255)
                    strip.fill((colorActive[2],colorActive[1],colorActive[0]))
                    strip.show()
                               
                cnt=cnt+1
    draw.text((int(wOLED/2),int(hOLED/2)),colorLabel,fill=255)                    
    oled.image(image)
    oled.show()
    myText = "FPS: "+str(round(fps,1))
    cv2.putText(frame,myText,textLowerLeft,fontFace,fontScale,fontColor,fontThickness)
    cv2.imshow("Camera", frame)
    cv2.moveWindow("Camera",0,60)
    if cv2.waitKey(1)==ord('q'):
        break
cv2.destroyAllWindows()
print('Program Terminated')

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import cv2

import time

from picamera2 import Picamera2

import mediapipe as mp

import board

import adafruit_ssd1306

from PIL import Image,ImageDraw,ImageFont

wOLED = 128

hOLED = 64

I2C_ADDRESS = 0x3C

i2c = board.I2C()

oled = adafruit_ssd1306.SSD1306_I2C(wOLED, hOLED, i2c, addr = I2C_ADDRESS)

W=1280

H=720

tStart = time.time()

fps = 0

RES = (W,H)

piCam = Picamera2(1)

piCam.preview_configuration.main.size = RES

piCam.preview_configuration.main.format = "RGB888"

piCam.preview_configuration.controls.FrameRate=60

piCam.preview_configuration.align()

piCam.configure("preview")

piCam.start()

textLowerLeft = (int(W*.01),int(H*.05))

fontFace = cv2.FONT_HERSHEY_SIMPLEX

fontThickness = int(W/425)

fontScale = H*.0015

fontColor = (0,0,255)

hands = mp.solutions.hands.Hands(

model_complexity = 0,

min_detection_confidence = .5,

min_tracking_confidence = .5,

max_num_hands =2)

mpDraw = mp.solutions.drawing_utils

cv2.namedWindow('Camera',cv2.WINDOW_GUI_NORMAL)

cv2.moveWindow('Camera',0,65)

cv2.resizeWindow('Camera',W,H)

import neopixel_spi as neopixel

spi = board.SPI()

strip = neopixel.NeoPixel_SPI(spi, 12,

pixel_order=neopixel.GRB,auto_write=False)

strip.fill(0)

strip.show()

xStart=int(W/2)

yStart=int(H/10)

margin=100

radius=25

radiusOutline=30

radiusFlash=35

boxW = 4*radius

boxH =int(.75*boxW)

xSpace= int((W-2*margin)/2/3)

colorDot= [(xStart-3*xSpace,yStart),(xStart-2*xSpace,yStart),(xStart-xSpace,yStart),(xStart,yStart),(xStart+xSpace,yStart),(xStart+2*xSpace,yStart),(xStart+3*xSpace,yStart)]

oledPOS=[]

for dot in colorDot:

oledPOS.append((int(dot[0]/W*wOLED),int(dot[1]/H*hOLED*.4)))

oledText = ['R','G','B','C','M','Y','B']

colorLabel = 'B'

colors =[(0,0,255),(0,255,0),(255,0,0),(255,255,0),(255,0,255),(0,255,255),(0,0,0)]

xBox = xStart-3*xSpace

yBox = int(yStart*1.5)

boxUpperLeft = (int(xBox-radius-boxW/4),yBox)

boxLowerRight = (int(xBox-radius-boxW/4+boxW),yBox+boxH)

colorActive =(0,0,0)

inCircle = False

while True:

deltaT = time.time() - tStart

tStart=time.time()

fps = fps*.95 + (1/deltaT)*.05

frame= piCam.capture_array()

frame=cv2.flip(frame,-1)

frame=cv2.flip(frame,1)

image = Image.new('1',(wOLED,hOLED))

draw = ImageDraw.Draw(image)

for i in range(7):

if inCircle:

cv2.circle(frame,colorDot[i],radiusFlash,(255,255,255),-1)

cv2.circle(frame,colorDot[i],radiusOutline,(200,200,200),-1)

cv2.circle(frame,colorDot[i],radius,colors[i],-1)

draw.text(oledPOS[i],oledText[i],fill=255)

cv2.rectangle(frame,boxUpperLeft,boxLowerRight,colorActive,-1)

rgbFrame= cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

handResults = hands.process(rgbFrame)

if handResults.multi_hand_landmarks:

for myHands in handResults.multi_hand_landmarks:

landMarks = myHands.landmark

x = int(landMarks[8].x*W)

y = int(landMarks[8].y*H)

xOLED = int(landMarks[8].x*wOLED)

yOLED = int(landMarks[8].y*hOLED)

cv2.circle(frame,(x,y),10,(255,0,0), -1)

draw.ellipse((xOLED-3,yOLED-4,xOLED+3,yOLED+4),fill=255)

cnt = 0

for pos in colorDot:

if abs(x-pos[0])<radius and abs(y-pos[1])<radius:

colorActive=colors[cnt]

colorLabel =oledText[cnt]

#draw.text((int(wOLED/2),int(hOLED/2)),oledText[cnt],fill=255)

strip.fill((colorActive[2],colorActive[1],colorActive[0]))

strip.show()

cnt=cnt+1

draw.text((int(wOLED/2),int(hOLED/2)),colorLabel,fill=255)

oled.image(image)

oled.show()

myText = "FPS: "+str(round(fps,1))

cv2.putText(frame,myText,textLowerLeft,fontFace,fontScale,fontColor,fontThickness)

cv2.imshow("Camera", frame)

cv2.moveWindow("Camera",0,60)

if cv2.waitKey(1)==ord('q'):

break

cv2.destroyAllWindows()

print('Program Terminated')

This is the core circuit we use for the class:

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

This is the schematic to add the OLED:

Then this is the schematic to add the NeoPixel

AI On the Edge, Raspberry Pi

AI on the Edge LESSON 47: Emotion Detector Using MediaPipe, OpenCV and Raspberry Pi

September 3, 2026 admin

In this exciting lesson, we build a real-time Emotion Detector that can recognize basic human emotions using just a Raspberry Pi, a camera, and the power of MediaPipe. The system watches your face and identifies whether you look Neutral, Smiling, Surprised, or Angry — and then reacts instantly by changing the color of a NeoPixel ring and displaying the detected emotion on both the camera preview and a small OLED display.Using MediaPipe’s Face Mesh solution, the program tracks 468 facial landmarks in real time. From these points, we carefully calculate key facial ratios — such as eye openness, mouth width, and mouth height relative to head width. These measurements allow us to create simple but effective rules that distinguish between different emotional expressions. For example, a wide mouth combined with raised cheeks indicates a smile, while a small mouth opening and narrowed eyes suggests anger.The project beautifully integrates several powerful technologies:

Picamera2 for high-performance camera capture
OpenCV for image processing and on-screen text display
MediaPipe Face Mesh for accurate facial landmark detection
NeoPixel RGB ring that lights up in different colors depending on the detected emotion
SSD1306 OLED display that shows both the emotion name and a simplified wireframe of your face

One of the most satisfying parts of this project is seeing the NeoPixel ring instantly change color to match your emotion — green for happy, cyan for surprised, red for angry, and yellow for neutral. The OLED also mirrors the detected emotion, making the entire system feel alive and responsive.This lesson is a fantastic step forward in understanding how to combine computer vision with physical outputs on the edge. You will learn how to extract meaningful measurements from facial landmarks, build rule-based emotion logic, and synchronize visual feedback across multiple devices (camera preview, NeoPixel, and OLED).By the end of Lesson 47, you will have a working real-time emotion recognition system running entirely on a Raspberry Pi — a great foundation for more advanced projects like mood-reactive lights, interactive robots, or even assistive technology.

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================

import cv2
import time
from picamera2 import Picamera2
import mediapipe as mp
import numpy as np
#################################
import board
import adafruit_ssd1306
from PIL import Image, ImageDraw, ImageFont
import time

import neopixel_spi as neopixel
import colorsys
spi=board.SPI()
LC = 12
PO = neopixel.GRB
strip = neopixel.NeoPixel_SPI(spi, LC,
            pixel_order=PO,auto_write=False)
strip.fill(0)
strip.show()

wOLED = 128
hOLED = 64
I2C_ADDRESS = 0x3C
i2c = board.I2C()
oled = adafruit_ssd1306.SSD1306_I2C(wOLED, hOLED, i2c, addr = I2C_ADDRESS)
fontLarge = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",14)
#################################
W=1280
H=720
tStart = time.time()
fps = 0

piCam = Picamera2(1)
piCam.preview_configuration.main.size = (W, H)
piCam.preview_configuration.main.format = "RGB888"
piCam.preview_configuration.controls.FrameRate = 60
piCam.preview_configuration.align()
piCam.configure("preview")
piCam.start()

textLowerLeft = (int(W*.01),int(H*.05))
fontFace = cv2.FONT_HERSHEY_SIMPLEX
fontThickness = int(W/425)
fontScale = H*.0015
fontColor = (0,0,255)

faceMesh = mp.solutions.face_mesh.FaceMesh(
    
    max_num_faces=1,
    refine_landmarks=True,
    min_detection_confidence=0.5,
    min_tracking_confidence=0.5)

cv2.namedWindow('Camera',cv2.WINDOW_GUI_NORMAL)
cv2.moveWindow('Camera',0,65)
cv2.resizeWindow('Camera',W,H)
while True:
    deltaT = time.time() - tStart
    tStart=time.time()
    fps = fps*.95 + (1/deltaT)*.05
    frame = piCam.capture_array()
    frame = cv2.flip(frame, -1)

    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = faceMesh.process(rgb)
    
    if results.multi_face_landmarks:
        for faceLandMarks in results.multi_face_landmarks:
            #print(faceLandmarks)
            image = Image.new("1",(wOLED,hOLED))
            draw = ImageDraw.Draw(image)
            lmAll = []
            j=0
            for lm in faceLandMarks.landmark:
                xOLED = int(lm.x*wOLED)
                yOLED = int(lm.y*hOLED)
                draw.point((xOLED,yOLED), fill = 255)
                #print(xOLED,yOLED)
                lmAll.append((xOLED,yOLED))
                x = int(lm.x*W)
                y = int(lm.y*H)
                #cv2.putText(frame,str(j),(x,y),fontFace, .3, (0,255,0),1)
                j = j+1
            for idx in mp.solutions.face_mesh.FACEMESH_CONTOURS:
                #print(idx)
                lineStart = idx[0]
                lineEnd = idx[1]
                pt1 = lmAll[lineStart]
                pt2 = lmAll[lineEnd]
                draw.line((pt1[0],pt1[1],pt2[0],pt2[1]), width=1, fill = 255)

            keyLM = faceLandMarks.landmark
            
            headRight = 323
            headLeft = 93
            headWidth = keyLM[headRight].x -keyLM[headLeft].x
            cv2.putText(frame,str(headRight),(int(keyLM[headRight].x*W),int(keyLM[headRight].y*H)),fontFace, .3, (0,255,0),1)
            cv2.putText(frame,str(headLeft),(int(keyLM[headLeft].x*W),int(keyLM[headLeft].y*H)),fontFace, .3, (0,255,0),1)
            
            leftEyeTop = 159
            leftEyeBottom = 145
            leftEyeHeight =keyLM[leftEyeBottom].y -keyLM[leftEyeTop].y
            leftEyeLeft = 130
            leftEyeRight = 154
            leftEyeWidth = keyLM[leftEyeRight].x -keyLM[leftEyeLeft].x
            leftEyeRatio = leftEyeHeight/leftEyeWidth*100 
            
            rightEyeTop = 385
            rightEyeBottom = 253
            rightEyeHeight = keyLM[rightEyeBottom].y -keyLM[rightEyeTop].y
            rightEyeLeft = 465
            rightEyeRight = 249
            rightEyeWidth = keyLM[rightEyeRight].x -keyLM[rightEyeLeft].x
            rightEyeRatio = rightEyeHeight/rightEyeWidth*100
            
            eyeRatio = (rightEyeRatio +leftEyeRatio)/2
            
            mouthLeft = 61
            mouthRight = 291
            mouthTop = 13
            mouthBottom = 15
            mouthWidth = keyLM[mouthRight].x-keyLM[mouthLeft].x
            mouthHeight = keyLM[mouthBottom].y-keyLM[mouthTop].y
            mouthWidthRatio = mouthWidth/headWidth *100
            mouthHeightRatio = mouthHeight/headWidth*100
            
            print(round(mouthWidthRatio,1),round(mouthHeightRatio,1),round(eyeRatio,1))
            color = (255,255,0)
            emotion = 'NEUTRAL'
            if mouthWidthRatio >37 and mouthHeightRatio>4 and eyeRatio<74:
                emotion = 'SMILE'
                color = (0,255,0)
            if mouthWidthRatio <37 and mouthHeightRatio>10 and eyeRatio>70:
                emotion = 'SURPRISED'
                color = (0,255,255)
            if mouthWidthRatio <32 and mouthHeightRatio<4 and eyeRatio<57:
                emotion = 'ANGRY'
                color = (0,0,255)               
            cv2.putText(frame, emotion, (int(W*.1),int(H*.15)),
                    fontFace, 2.2, color, 4)
            strip.fill((color[2],color[1],color[0]))
            strip.show()
            #print('XXXXXXXXXXXXXXXXXXx')
            draw.text((0,0),emotion,font=fontLarge,fill=255)
            oled.image(image)
            oled.show()
        #print()

#     if results.multi_face_landmarks:
#         for faceLandmarks in results.multi_face_landmarks:
#             # Optional second pass for glow effect
#             mp.solutions.drawing_utils.draw_landmarks(
#                 image=frame,
#                 landmark_list=faceLandmarks,
#                 connections=mp.solutions.face_mesh.FACEMESH_TESSELATION,
#                 landmark_drawing_spec=None,
#                 connection_drawing_spec=mp.solutions.drawing_utils.DrawingSpec(
#                     color=(100, 100, 100),
#                     thickness=1
#                 )
#             )
#             # === Best looking translucent mesh ===
#             mp.solutions.drawing_utils.draw_landmarks(
#                 image=frame,
#                 landmark_list=faceLandmarks,
#                 connections=mp.solutions.face_mesh.FACEMESH_CONTOURS,
#                 landmark_drawing_spec=None,                    # Hide dots
#                 connection_drawing_spec=mp.solutions.drawing_utils.DrawingSpec(
#                     color=(0, 0, 180),      # Bright cyan/teal
#                     thickness=7
#                 )
#             )
# 
#             # Optional: Extra detail on irises (makes eyes look better)
#             mp.solutions.drawing_utils.draw_landmarks(
#                 image=frame,
#                 landmark_list=faceLandmarks,
#                 connections=mp.solutions.face_mesh.FACEMESH_IRISES,
#                 landmark_drawing_spec=None,
#                 connection_drawing_spec=mp.solutions.drawing_utils.DrawingSpec(
#                     color=(255, 0, 0),
#                     thickness=7
#                 )
#             )

    myText = "FPS: "+str(round(fps,1))
    cv2.putText(frame,myText,textLowerLeft,fontFace,fontScale,fontColor,fontThickness)

    cv2.imshow("Camera", frame)

    if cv2.waitKey(1) == ord('q'):
        break

cv2.destroyAllWindows()
piCam.stop()
oled.fill(0)
oled.show()
strip.fill(0)
strip.show()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import cv2

import time

from picamera2 import Picamera2

import mediapipe as mp

import numpy as np

#################################

import board

import adafruit_ssd1306

from PIL import Image, ImageDraw, ImageFont

import time

import neopixel_spi as neopixel

import colorsys

spi=board.SPI()

LC = 12

PO = neopixel.GRB

strip = neopixel.NeoPixel_SPI(spi, LC,

pixel_order=PO,auto_write=False)

strip.fill(0)

strip.show()

wOLED = 128

hOLED = 64

I2C_ADDRESS = 0x3C

i2c = board.I2C()

oled = adafruit_ssd1306.SSD1306_I2C(wOLED, hOLED, i2c, addr = I2C_ADDRESS)

fontLarge = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",14)

#################################

W=1280

H=720

tStart = time.time()

fps = 0

piCam = Picamera2(1)

piCam.preview_configuration.main.size = (W, H)

piCam.preview_configuration.main.format = "RGB888"

piCam.preview_configuration.controls.FrameRate = 60

piCam.preview_configuration.align()

piCam.configure("preview")

piCam.start()

textLowerLeft = (int(W*.01),int(H*.05))

fontFace = cv2.FONT_HERSHEY_SIMPLEX

fontThickness = int(W/425)

fontScale = H*.0015

fontColor = (0,0,255)

faceMesh = mp.solutions.face_mesh.FaceMesh(

max_num_faces=1,

refine_landmarks=True,

min_detection_confidence=0.5,

min_tracking_confidence=0.5)

cv2.namedWindow('Camera',cv2.WINDOW_GUI_NORMAL)

cv2.moveWindow('Camera',0,65)

cv2.resizeWindow('Camera',W,H)

while True:

deltaT = time.time() - tStart

tStart=time.time()

fps = fps*.95 + (1/deltaT)*.05

frame = piCam.capture_array()

frame = cv2.flip(frame, -1)

rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

results = faceMesh.process(rgb)

if results.multi_face_landmarks:

for faceLandMarks in results.multi_face_landmarks:

#print(faceLandmarks)

image = Image.new("1",(wOLED,hOLED))

draw = ImageDraw.Draw(image)

lmAll = []

j=0

for lm in faceLandMarks.landmark:

xOLED = int(lm.x*wOLED)

yOLED = int(lm.y*hOLED)

draw.point((xOLED,yOLED), fill = 255)

#print(xOLED,yOLED)

lmAll.append((xOLED,yOLED))

x = int(lm.x*W)

y = int(lm.y*H)

#cv2.putText(frame,str(j),(x,y),fontFace, .3, (0,255,0),1)

j = j+1

for idx in mp.solutions.face_mesh.FACEMESH_CONTOURS:

#print(idx)

lineStart = idx[0]

lineEnd = idx[1]

pt1 = lmAll[lineStart]

pt2 = lmAll[lineEnd]

draw.line((pt1[0],pt1[1],pt2[0],pt2[1]), width=1, fill = 255)

keyLM = faceLandMarks.landmark

headRight = 323

headLeft = 93

headWidth = keyLM[headRight].x -keyLM[headLeft].x

cv2.putText(frame,str(headRight),(int(keyLM[headRight].x*W),int(keyLM[headRight].y*H)),fontFace, .3, (0,255,0),1)

cv2.putText(frame,str(headLeft),(int(keyLM[headLeft].x*W),int(keyLM[headLeft].y*H)),fontFace, .3, (0,255,0),1)

leftEyeTop = 159

leftEyeBottom = 145

leftEyeHeight =keyLM[leftEyeBottom].y -keyLM[leftEyeTop].y

leftEyeLeft = 130

leftEyeRight = 154

leftEyeWidth = keyLM[leftEyeRight].x -keyLM[leftEyeLeft].x

leftEyeRatio = leftEyeHeight/leftEyeWidth*100

rightEyeTop = 385

rightEyeBottom = 253

rightEyeHeight = keyLM[rightEyeBottom].y -keyLM[rightEyeTop].y

rightEyeLeft = 465

rightEyeRight = 249

rightEyeWidth = keyLM[rightEyeRight].x -keyLM[rightEyeLeft].x

rightEyeRatio = rightEyeHeight/rightEyeWidth*100

eyeRatio = (rightEyeRatio +leftEyeRatio)/2

mouthLeft = 61

mouthRight = 291

mouthTop = 13

mouthBottom = 15

mouthWidth = keyLM[mouthRight].x-keyLM[mouthLeft].x

mouthHeight = keyLM[mouthBottom].y-keyLM[mouthTop].y

mouthWidthRatio = mouthWidth/headWidth *100

mouthHeightRatio = mouthHeight/headWidth*100

print(round(mouthWidthRatio,1),round(mouthHeightRatio,1),round(eyeRatio,1))

color = (255,255,0)

emotion = 'NEUTRAL'

if mouthWidthRatio >37 and mouthHeightRatio>4 and eyeRatio<74:

emotion = 'SMILE'

color = (0,255,0)

if mouthWidthRatio <37 and mouthHeightRatio>10 and eyeRatio>70:

emotion = 'SURPRISED'

color = (0,255,255)

if mouthWidthRatio <32 and mouthHeightRatio<4 and eyeRatio<57:

emotion = 'ANGRY'

color = (0,0,255)

cv2.putText(frame, emotion, (int(W*.1),int(H*.15)),

fontFace, 2.2, color, 4)

strip.fill((color[2],color[1],color[0]))

strip.show()

#print('XXXXXXXXXXXXXXXXXXx')

draw.text((0,0),emotion,font=fontLarge,fill=255)

oled.image(image)

oled.show()

#print()

# if results.multi_face_landmarks:

# for faceLandmarks in results.multi_face_landmarks:

# # Optional second pass for glow effect

# mp.solutions.drawing_utils.draw_landmarks(

# image=frame,

# landmark_list=faceLandmarks,

# connections=mp.solutions.face_mesh.FACEMESH_TESSELATION,

# landmark_drawing_spec=None,

# connection_drawing_spec=mp.solutions.drawing_utils.DrawingSpec(

# color=(100, 100, 100),

# thickness=1

# )

# # === Best looking translucent mesh ===

# mp.solutions.drawing_utils.draw_landmarks(

# image=frame,

# landmark_list=faceLandmarks,

# connections=mp.solutions.face_mesh.FACEMESH_CONTOURS,

# landmark_drawing_spec=None, # Hide dots

# connection_drawing_spec=mp.solutions.drawing_utils.DrawingSpec(

# color=(0, 0, 180), # Bright cyan/teal

# thickness=7

# )

# # Optional: Extra detail on irises (makes eyes look better)

# mp.solutions.drawing_utils.draw_landmarks(

# image=frame,

# landmark_list=faceLandmarks,

# connections=mp.solutions.face_mesh.FACEMESH_IRISES,

# landmark_drawing_spec=None,

# connection_drawing_spec=mp.solutions.drawing_utils.DrawingSpec(

# color=(255, 0, 0),

# thickness=7

# )

myText = "FPS: "+str(round(fps,1))

cv2.putText(frame,myText,textLowerLeft,fontFace,fontScale,fontColor,fontThickness)

cv2.imshow("Camera", frame)

if cv2.waitKey(1) == ord('q'):

break

cv2.destroyAllWindows()

piCam.stop()

oled.fill(0)

oled.show()

strip.fill(0)

strip.show()

These are the schematics we are using for todays project. If you are taking the class, you should already have these components connected:

AI On the Edge, Raspberry Pi

AI on the Edge LESSON 45: Adding a NeoPixel Ring To Your Raspberry Pi Project

August 26, 2026 admin

In Lesson 45 of our AI on the Edge series, we take our Fusion AI Lab Kit to the next level by adding a 12-pixel NeoPixel ring. This lesson bridges the gap between pure AI processing and vibrant physical output, showing how your edge AI projects can communicate visually with the real world in a beautiful and engaging way.

We begin by setting up the NeoPixel ring using the SPI interface on the SunFounder Fusion Hat. After importing the necessary libraries (time, board, neopixel_spi, colorsys, and math), we create a simple and reusable hsv2rgb() function that converts Hue values (0.0 to 1.0) into RGB colors that the NeoPixels can understand. This function becomes the foundation for smooth rainbow effects later in the lesson.The lesson starts with basic pixel control. We manually light up each of the 12 pixels one at a time using different colors (red, green, blue, cyan, magenta, yellow, etc.). This slow, deliberate approach lets you clearly see how individual pixel addressing works and helps students understand the coordinate system of the ring.Next, we explore full-ring control by making the entire ring blink between bright red and blue. We then move into motion with a running green pixel moving across a red background — a great introduction to animation techniques. This is followed by a more advanced chasing effect where a blue pixel chases a green pixel around a dim red background.One of the highlights of this lesson is the gentle pulsating aqua effect. Using a sine wave (math.sin), we create a smooth breathing/pulsing animation where the brightness of the color rises and falls naturally. This technique produces a very professional and visually pleasing result that students can easily adapt for future projects.

Finally, we create a rainbow effect. First, we display a uniform rainbow where all 12 pixels show the same color that cycles smoothly through the entire spectrum.

We finish the lesson by assigning the homework. The homework is for you to create the classic running rainbow (what I like to call a “Runbow”), where the colors flow continuously around the ring — one of the most popular and impressive NeoPixel animations.

This lesson reinforces important programming concepts including loops, functions, color theory (HSV vs RGB), timing control, and animation techniques, while giving students an exciting visual payoff. The skills learned here open the door to creating stunning visual feedback for future AI projects — whether it’s status indicators, emotional displays, or attention-grabbing outputs from your edge AI models.

# ====================================================================
# DISCLAIMER:
# This code is provided as-is for educational and experimental 
# purposes only. The author makes no representations or warranties of 
# any kind concerning the safety, suitability, or accuracy of this 
# code. Use at your own risk. The author assumes no liability for any 
# damages, system failures, security breaches, or network issues 
# resulting from the use or implementation of this script.
# ====================================================================
 
import time
import board
import neopixel_spi as neopixel
import colorsys
import math

def hsv2rgb(h):
    r, g, b = colorsys.hsv_to_rgb(h, 1, 1)
    return (int(r*255),int(g*255),int(b*255))

spi = board.SPI()
LED_COUNT = 12
PO = neopixel.GRB
strip = neopixel.NeoPixel_SPI(spi,
        LED_COUNT,pixel_order=PO,
        auto_write = False)
strip.fill(0)
strip.show()

strip[0] = (255,0,0)
strip.show()
ts=.1
time.sleep(ts)

strip[1] = (0,255,0)
strip.show()
time.sleep(ts)

strip[2] = (0,0,255)
strip.show()
time.sleep(.1)

strip[3] = (0,255,255)
strip.show()
time.sleep(ts)

strip[4] = (255,0,255)
strip.show()
time.sleep(.1)

strip[5] = (255,255,0)
strip.show()
time.sleep(.1)

strip[6] = (255,100,0)
strip.show()
time.sleep(ts)

strip[7] = (128,0,255)
strip.show()
time.sleep(.1)

strip[8] = (0,255,128)
strip.show()
time.sleep(.1)

strip[9] = (255,0,128)
strip.show()
time.sleep(ts)

strip[10] = (128,255,0)
strip.show()
time.sleep(ts)

strip[11] = (0,128,255)
strip.show()
time.sleep(.1)
ts2=5
for i in range(5):
    strip.fill((255,0,0))
    strip.show()

    time.sleep(ts2)
    
    strip.fill((0,0,255))
    strip.show()
    time.sleep(ts2)
    
strip.fill((255,0,0))
strip.show()
ts3=1
time.sleep(ts3)
ts4=.3
for lap in range(3):
    for i in range(12):
        strip[i] = (0,255,0)
        strip.show()
        time.sleep(ts4)
        strip[i] = (255,0,0)

strip.fill((40,0,0))
strip.show()
time.sleep(ts3)

for lap in range(4):
    for i in range(12):
        greenPos = i
        bluePos = (i + 6)%12
        
        strip[greenPos] = (0,255,0)
        strip[bluePos] = (0,0,255)
        strip.show()
        time.sleep(ts4)
        
        strip[greenPos] = (40,0,0)
        strip[bluePos] = (40,0,0)
        
for laps in range(6):
    for step in range(360):
        brightness= (math.sin(step*3.1415/180)+1)/2
        r = 0
        g = int(255*brightness)
        b = int(50*brightness)
        strip.fill((r,g,b))
        strip.show()
        time.sleep(.005)
        
for laps in range(5):
    for step in range(100):
        hue = step/100
        color = hsv2rgb(hue)
        strip.fill(color)
        strip.show()
        time.sleep(ts)


strip.fill(0)
strip.show()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

# ====================================================================

# DISCLAIMER:

# This code is provided as-is for educational and experimental

# purposes only. The author makes no representations or warranties of

# any kind concerning the safety, suitability, or accuracy of this

# code. Use at your own risk. The author assumes no liability for any

# damages, system failures, security breaches, or network issues

# resulting from the use or implementation of this script.

# ====================================================================

import time

import board

import neopixel_spi as neopixel

import colorsys

import math

def hsv2rgb(h):

r, g, b = colorsys.hsv_to_rgb(h, 1, 1)

return (int(r*255),int(g*255),int(b*255))

spi = board.SPI()

LED_COUNT = 12

PO = neopixel.GRB

strip = neopixel.NeoPixel_SPI(spi,

LED_COUNT,pixel_order=PO,

auto_write = False)

strip.fill(0)

strip.show()

strip[0] = (255,0,0)

strip.show()

ts=.1

time.sleep(ts)

strip[1] = (0,255,0)

strip.show()

time.sleep(ts)

strip[2] = (0,0,255)

strip.show()

time.sleep(.1)

strip[3] = (0,255,255)

strip.show()

time.sleep(ts)

strip[4] = (255,0,255)

strip.show()

time.sleep(.1)

strip[5] = (255,255,0)

strip.show()

time.sleep(.1)

strip[6] = (255,100,0)

strip.show()

time.sleep(ts)

strip[7] = (128,0,255)

strip.show()

time.sleep(.1)

strip[8] = (0,255,128)

strip.show()

time.sleep(.1)

strip[9] = (255,0,128)

strip.show()

time.sleep(ts)

strip[10] = (128,255,0)

strip.show()

time.sleep(ts)

strip[11] = (0,128,255)

strip.show()

time.sleep(.1)

ts2=5

for i in range(5):

strip.fill((255,0,0))

strip.show()

time.sleep(ts2)

strip.fill((0,0,255))

strip.show()

time.sleep(ts2)

strip.fill((255,0,0))

strip.show()

ts3=1

time.sleep(ts3)

ts4=.3

for lap in range(3):

for i in range(12):

strip[i] = (0,255,0)

strip.show()

time.sleep(ts4)

strip[i] = (255,0,0)

strip.fill((40,0,0))

strip.show()

time.sleep(ts3)

for lap in range(4):

for i in range(12):

greenPos = i

bluePos = (i + 6)%12

strip[greenPos] = (0,255,0)

strip[bluePos] = (0,0,255)

strip.show()

time.sleep(ts4)

strip[greenPos] = (40,0,0)

strip[bluePos] = (40,0,0)

for laps in range(6):

for step in range(360):

brightness= (math.sin(step*3.1415/180)+1)/2

r = 0

g = int(255*brightness)

b = int(50*brightness)

strip.fill((r,g,b))

strip.show()

time.sleep(.005)

for laps in range(5):

for step in range(100):

hue = step/100

color = hsv2rgb(hue)

strip.fill(color)

strip.show()

time.sleep(ts)

strip.fill(0)

strip.show()

In this class we are using this as our standard components. You should already have the core circuit built and should already have the OLED connected. Today you will add the NeoPixel array.

Our core circuit is:

Last week we also added the SSD1306 OLED Display.

And finally today we add the NeoPixel ring from the Fusion AI Lab Kit.

Technology Tutorials

Tag Archives: neoPixel

AI on the Edge LESSON 54: Custom Hand Gesture Recognition & Dynamic NeoPixel Control

System Architecture Overview

Gesture-to-Hardware Animation Mapping

Interactive Keyboard Controls

Hardware Wiring Reference

Homework Challenge

Homework & Next Steps

AI on the Edge LESSON 51: Gesture Control of NeoPixel Ring

AI on the Edge LESSON 50: Control NeoPixel Ring With Hand Gestures and MediaPipe

AI on the Edge LESSON 47: Emotion Detector Using MediaPipe, OpenCV and Raspberry Pi

AI on the Edge LESSON 45: Adding a NeoPixel Ring To Your Raspberry Pi Project

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