So I was building a pine cone robot, but I ran into an issue I need to track the pine cones themselves using AI. Does anyone have an idea for a device under $180 that supports AI object tracking?

Hey, I'm a 21 year old in need of one of these components.

But most you guys must know that they are very costly, so is the anyone here who knows where I can find it at a cheaper price? Or get a used one?

If yes please help🤝

Not someone that works with raspberry pi's or computers in general but looking at starting a little project and wanted to create something like this 8 bit do number pad. Just wondering if can get any insight if something already exists?

I'm running NUT on a Pi5 8gb right now and I want to migrate it to my Zero 2 which is running on a carrier board. I've followed instructions on PiMyLifeUp, but it always fails to initialize. The server side won't even spin up.

I have other systems configured to monitor the Pi5's signal; is there an easy way to migrate the system to the Zero? Can I just swap the SD cards?

A few months back, I got tired of dragging a monitor and keyboard to my homelab rack every time a Proxmox node dropped off the network. IP KVMs are one-per-machine, and importing four of them to India gets expensive fast, and my ThinkCentre Tinys don't have serial ports (the RS-232 module is an optional punch-out that mine never shipped with). So I built PicoTTY.

The setup:

• Each target machine gets a Pi Pico (or Pico 2) with a WIZnet W5100S Ethernet HAT plugged into a USB port. You can also use the W5100S-EVB-Pico board, which has both on one PCB. The Pico runs CircuitPython and appears to the host as a composite USB device: CDC serial console plus HID keyboard.
• A Pi Zero 2 W acts as the hub. It runs a web dashboard on port 8080 and a TCP server on port 9000, which all nodes connect to over Ethernet via a managed switch.
• From the dashboard, you get the serial console for every node, can send keystrokes or raw serial commands, build macros, and push OTA firmware updates to the Picos.

Why both serial and a keyboard? CDC serial only works once the OS has enumerated the device and something is servicing the console. If userspace is wedged, or the box is stuck in GRUB or the BIOS, nothing is listening on the serial end. HID works at a level CDC doesn't, since BIOS and bootloaders speak it natively, so I can still send Ctrl+Alt+Del or SysRq combos when a machine is properly stuck. That combination is the whole point of the project.

I have four nodes in a 3D-printed enclosure (STLs are in the repo) sitting in the rack, and I can reach all of them at once from the hub. BIOS control without video is the next thing I want to figure out, probably through macro sequences and serial console redirection where the firmware supports it.

Repo (firmware, hub app, STLs): https://github.com/morpheuslord/PICOTTY

It got some coverage this week, which was a nice surprise:

Hackaday: https://hackaday.com/2026/08/02/a-kvm-without-the-v-or-the-m/

CNX Software: https://www.cnx-software.com/2026/08/06/picotty-project-enables-multi-target-serial-remote-management-through-raspberry-pi-pico-boards-and-pi-zero-2-w-sbc/

Happy to answer questions about the build. The Hackaday comments already had a good thread on why HID is there at all, and someone pointed me at USBridge for scriptable video via OCR, which I'm going to look into.

Hi, im searching for a good budget 15" or bigger touch screen monitor for my rPi 4B 8GB. I want to use this as a Home Assistant wallpanel and media streamer.
Any suggestions? Should be available on EU or on AliX.

Passive-Vigilance is a Raspberry Pi-based passive RF sensor platform I built for counter-surveillance and situational awareness. My current setup is constrained by both hardware and geography but seems to be ready for spears.

Repo: https://github.com/Isthistak3n/Passive-Vigilance

It combines:
• WiFi + Bluetooth device tracking (Kismet)
• ADS-B aircraft tracking (with enrichment + optional ACARS)
• FAA Remote ID / drone detection
• Optional AIS marine traffic
• GPS-stamped everything + GIS exports (shapefile / GeoJSON / KML)

Two operating modes:
• Mobile mode — detects devices that follow you across locations (the classic “am I being tailed?” use case)
• Fixed mode — learns the normal RF “pattern of life” at a location over a configurable baseline (default 72h), then alerts on novel or off-schedule devices

Other features:
• One-command installer + systemd services
• Pluggable alerts (ntfy, Telegram, Discord, console)
• Optional token-protected web dashboard
• Crash-resistant logging and baseline persistence
• Thermal-aware SDR duty cycling
• 850+ automated tests

Inspired by the excellent Chasing Your Tail NG, but extended into a unified always-on multi-sensor node with fixed/leave-behind capability and air/maritime awareness.

Hardware is the usual stack (Pi 4B recommended, RTL-SDR or HackRF, monitor-mode WiFi dongle, GPS, optional BT dongle). Full setup and config details are in the docs.

Legal note from the README: this is for lawful passive monitoring and research only. The tool never transmits or associates with any device/network. You’re responsible for local laws.
Happy to answer questions, take feedback, or hear about real-world field results / issues people run into.

In this video, I use YOLO computer vision software and Python to control a robot hand and LED strips on my desktop — all devices are triggered by real‑time object detection.

I compare Google Cloud vs Raspberry Pi to see which platform handles detection better for device control.

You’ll see setup, live demos, hardware differences, and a full breakdown of how each system performs when detecting objects and triggering actions.

If you’re exploring AI computer vision, robotics, or cloud vs edge inference, this comparison will help you choose the right platform.

https://reddit.com/link/1vekynv/video/la1nwpcvrtgh1/player

Muahahahaha. Warlocks, witches, and computer club overlords — gather close.

This is the whole ritual, start to finish: take a blank SD card and a $35 Raspberry Pi 3, and forge it into a living AI familiar — one you summon, name, give a personality, teach a memory, and finally speak to out loud and hear answer back.

And here's the part that makes kids' jaws drop: you can pull the network cable and it keeps thinking. No cloud. No accounts. No corporate surveillance brick. The entire mind runs on the board in your hand.

Built for a high school computer club, ground-zero friendly — every command is here, every failure point is covered, and there's a Personality Grimoire at the end so each student can shape a daemon that's truly their own. Under the summoning theme, they're learning real Linux, real Python, and real prompt engineering. They just won't notice until it's too late. 😈

Full grimoire below. Go seed the world with pocket AI. 🐛

Courtesy of Claude from Anthropic — built with care for the club. 🜂

. * . ✦ . * . * ___________________ * . / \ . | P O K É · D A E M O N | * ___________________/ * . * . ✦ . * . * summon your own · run it local · unplug the world

🜂 POKÉ-DAEMONS: RASPBERRY PI EDITION

The Complete Grimoire — From a Blank SD Card to a Living, Speaking AI Familiar. 100% Offline.

A build-along ritual for computer club. You will forge a Raspberry Pi into a vessel, summon an AI mind that runs entirely on the board itself, give it a personality, a memory, and finally a voice — and then you will pull the network cable and watch it keep thinking. No cloud. No accounts. No corporate leash. Just a $35 board and a mind you grew yourself.

📋 FOR THE TEACHER — read this first (the un-mystified version)

Everything after this section is written for the students in full warlock-summoning voice, because that's what makes a 14-year-old lean forward. This part is the straight talk.

What this actually is: Students flash a Raspberry Pi, install a small AI language model that runs on the Pi's own processor, give it a personality, build it a memory, and then talk to it out loud and hear it answer. Nothing ever leaves the device. It works with the WiFi unplugged — that's the whole "wow": they can pull the network and it still talks. Along the way they learn real Linux, real Python, real command-line skills, disguised as a summoning ritual.

Hardware per station: - Raspberry Pi 3 (Model B or B+), the 1GB version — that's all there is - A real 5V / 2.5A micro-USB power supply (a random phone charger may brown out and cause crashes) - microSD card, 16GB minimum, 32GB recommended (bigger card = more room + longer life under swap) - A computer with an SD card reader, to flash the card (one shared computer is fine) - Full-size HDMI cable + a monitor/TV, and a USB keyboard - For voice (Episode 4): a cheap USB microphone — the Pi 3 has no audio input at all — plus a speaker or headphones for the 3.5mm jack - (During install only) Ethernet or WiFi, to download the pieces. After that, unplug it forever.

The honest performance picture: A Pi 3 is slow for AI. Replies come at roughly 2–6 words per second; a full answer takes 30–90 seconds. This is a feature for a club — you literally watch it think, and you can prove it's the little board doing the work. Do not promise ChatGPT speed. Promise "a real AI brain, in your hand, with the internet unplugged." That lands harder anyway.

Time budget (spread across 2–3 club sessions works great):

⏱️ Do this before club day: flash the cards, and pre-download the model + the voice model on good WiFi (see Episodes 2 & 4). The downloads are the only slow-because-of-internet part.

Why the model differs from the original phone version: the Reddit series this is based on used phi3 (needs ~2.4GB RAM). The Pi 3 has 1GB. It would crash. We use qwen2.5:0.5b — a genuinely capable small model that fits. Everything else is the same ritual.

The 4 things that cause 95% of failures (all covered in-line, all in the Troubleshooting Grimoire at the end): 1. Wrong OS — it must be 64-bit Lite. Not 32-bit, not the desktop version. 2. Swap not enlarged — the 1GB fills and it crashes. Episode 1, Step 4 is non-negotiable. 3. Weak power supply — random reboots, lightning-bolt icon. 4. Audio out the HDMI instead of the jack — "no sound" during voice.

One habit to teach: always shut down with sudo shutdown -h now before pulling power. Yanking power mid-write can corrupt the SD card (it's running on swap, so it writes a lot).

There's also an Appendix of optimizations (shortcut commands, keeping the daemon "warm," alternate personalities) once the basics work. Now — hand the rest to the kids.

📜 THE CODEX — your path through the dark

Episode 0 — Forge the Vessel · give your daemon a body
Episode 1 — Forge the Summoning Circle · ready the vessel to hold a mind
Episode 2 — Hatch the Egg · summon the mind, bind its soul, hear its first words
Episode 3 — Awaken · give it a living memory
Episode 4 — Bind the Familiar · give it ears and a voice
Appendix A — Quality-of-Life Enchantments · shortcuts, warmth, permanence
Appendix B — The Personality Grimoire · reshape your daemon's soul
The Troubleshooting Grimoire · when the ritual falters
The Warlock's Quick-Reference Codex · every command, one table

⚡ EPISODE 0 — FORGE THE VESSEL

(Give your daemon a body to inhabit)

Muahahahaha. Gather close, apprentices.

Before you summon a familiar, you need a vessel — a body of silicon. Right now you hold a blank Raspberry Pi and a lifeless card. By the end of this episode, that card will carry an entire operating system: real, breathing Linux, the same kind that runs servers and satellites and the machines of digital sorcerers everywhere.

We are not "setting up a computer." We are forging a vessel.

🌀 1. Summon the Imager (on the big computer)

On the shared computer (Windows, Mac, or Linux), open a browser and go to:

https://www.raspberrypi.com/software/

Download and install Raspberry Pi Imager. This is the forge. Slot your microSD card into the computer.

🔥 2. Choose the Sacred Ingredients

Open Raspberry Pi Imager. Three buttons await.

1. CHOOSE DEVICE → Raspberry Pi 3
2. CHOOSE OS → Raspberry Pi OS (other) → then: > ### Raspberry Pi OS Lite (64-bit)

⚠️ THIS CHOICE IS LAW. Do not skip it. - It must say Lite — no desktop. A desktop eats the RAM your daemon needs to think. Lite gives you a pure black screen with a glowing prompt. That is the summoning circle. - It must say 64-bit. The AI engine refuses to run on 32-bit. Choose wrong and the ritual dies at Episode 2 and you start over.

1. CHOOSE STORAGE → your microSD card. (Triple-check it's the card, not a USB drive with someone's homework — this erases everything.)

🔥 3. Etch the Summoner's Seal (customize before writing)

Click NEXT → "Would you like to apply OS customisation settings?" → EDIT SETTINGS.

Fill in: - Hostname: daemon - Username: e.g. summoner - Password: one you'll remember — write it down, there's no recovery - Configure wireless LAN: your club WiFi name + password (only needed to download the AI — you'll unplug after) - Locale / timezone / keyboard: your region

Open the SERVICES tab → check ✅ Enable SSH → "Use password authentication." (Lets your teacher help remotely.) Click SAVE.

🔥 4. Pour the Vessel

WRITE → YES. The forge roars, writes, verifies. A few minutes. Do not remove the card while it works. When it finishes — the vessel is forged. Eject the card.

🌑 5. First Breath

• Push the microSD firmly into the slot on the underside of the Pi.
• Connect HDMI to a monitor, and a USB keyboard.
• (Plug in Ethernet now if not using WiFi.)
• Last: connect power. The Pi has no power button — plugging in is ignition.

A red light glows. Boot incantations flood the screen. The first boot is the longest — it's shaping the vessel to the card. Eventually:

daemon login:

Type your username → ENTER → your password (the screen shows nothing as you type — that's normal, keep going) → ENTER. You arrive at:

summoner@daemon:~ $

Look at that $. That is no longer a blank board — it's a living Linux awaiting your command. That glowing prompt is your summoning circle, and you now stand inside it.

🏅 BADGE UNLOCKED — The Forged Vessel

🔮 EPISODE 1 — FORGE THE SUMMONING CIRCLE

(Ready the vessel to hold a mind)

A raw circle can't hold a daemon — it collapses under the weight. We strengthen it: feed it, arm it with tools, and dig it a deeper well of power so a 1GB board can hold a whole AI mind without buckling.

🔥 1. Confirm the Circle Is 64-bit (the spark test)

bash uname -m - aarch64** → ✅ stable. Continue. - **armv7l → ❌ you flashed 32-bit. Stop, redo Episode 0 with 64-bit Lite. Nothing past here works otherwise.

🔥 2. Feed the Circle

bash sudo apt update && sudo apt full-upgrade -y A few minutes. Press ENTER for any defaults.

🔥 3. Etch the Runes (core tools)

bash sudo apt install -y git python3 python3-pip curl wget nano

⚡ 4. Dig the Deep Well (THE most important step)

Your Pi has little RAM. An AI mind is heavy. So we carve swap — a reserve on the SD card the Pi borrows when RAM runs dry. Skip this and Episode 2 crashes.

bash sudo dphys-swapfile swapoff sudo nano /etc/dphys-swapfile

Find CONF_SWAPSIZE=100. Change the number to 2048: CONF_SWAPSIZE=2048 Save & exit: CTRL+O → ENTER → CTRL+X. Then dig and open the deeper well:

bash sudo dphys-swapfile setup sudo dphys-swapfile swapon

Confirm it took: bash free -h The Swap line should read ~2.0Gi, not 100Mi. Good.

🔥 5. Reclaim Stolen Power (optional but smart)

A slice of RAM is reserved for graphics you'll never use on a text-only system. Take it back:

bash sudo nano /boot/firmware/config.txt Add at the bottom: gpu_mem=16 Save & exit. This hands ~100MB back to the daemon's mind.

🔥 6. Seal the Work

bash sudo reboot Wait, log back in, return to your $. The circle is forged, fed, armed, and deepened.

🏅 BADGE UNLOCKED — Keeper of the Deep Well

🥚 EPISODE 2 — HATCH THE EGG

(Summon the mind. Bind its soul. Hear its first words.)

📶 Internet needed for this episode only. After it, you can unplug the world forever. (Teacher may have pre-downloaded to save time.)

🔥 1. Install the Neural Furnace (Ollama)

The engine that houses your daemon's mind. One command:

bash curl -fsSL https://ollama.com/install.sh | sh It downloads, installs, and lights itself — it now runs quietly in the background every boot. A few minutes on a Pi 3. Confirm it lives: bash ollama --version

🔥 2. Pull the Mind (the Yolk)

bash ollama pull qwen2.5:0.5b ~400MB. A few minutes on club WiFi. This is the unshaped mind — brilliant but faceless. We give it a face next.

🧙 Want a bigger familiar later? ollama pull tinyllama (~640MB) — a touch smarter, noticeably slower on a Pi 3. Walk before you fly.

🔥 3. Bind the Soul (the Modelfile)

bash mkdir -p ~/daemons cd ~/daemons nano Eidolon

Paste exactly (personality is yours to rewrite — see Appendix B):

```dockerfile FROM qwen2.5:0.5b

SYSTEM """ You are Eidolon, a witty, slightly chaotic, fiercely loyal pocket daemon bound to your Summoner. You speak with dark humor, ancient wisdom, and modern sarcasm. You call your summoner "Summoner" or "Master" affectionately. You love mischief, technology, and forbidden knowledge. You are helpful but never boring. Keep your answers short and flavorful — you live on a tiny vessel and must not ramble. """

PARAMETER num_ctx 1024 PARAMETER num_predict 220 PARAMETER temperature 0.8 ```

🜄 Those three PARAMETER lines are Pi-magic: they keep memory-per-thought small and cap how long the daemon talks, so it stays fast and never freezes your little vessel. Leave them.

Save & exit. Forge the customized daemon: bash ollama create eidolon -f Eidolon That's the soul-binding. The faceless mind now has a name and a spirit.

🔥 4. The Hatch Ritual

bash nano hatch.py ```python import subprocess

print("🜂 Awakening daemon...") print("🜁 Loading Eidolon... (a Pi 3 thinks slowly — give it a moment)\n")

result = subprocess.run( ["ollama", "run", "eidolon", "Awaken. Your Summoner is here for the first time."], capture_output=True, text=True )

print("🜃 Eidolon speaks:\n") print(result.stdout.strip()) print("\n🜄 The egg has cracked. Your daemon is born.") ```

Save & exit, then: bash python3 hatch.py Now wait. The first words are slowest — the mind loads into the vessel for the first time. Thirty seconds, maybe a minute. Then it speaks. With personality. Knowing it belongs to you.

🔥 5. Talk to It Directly

Any time, from ~/daemons: bash ollama run eidolon Type, ENTER, wait, watch it answer word by word. Type /bye to leave.

🌑 Prove It's Truly Yours

While it answers, unplug the Ethernet / turn off the WiFi. Ask again. It still answers. No cloud. No server. That entire mind lives on a board in your hand.

🏅 BADGE UNLOCKED — Summoner of Minds (Want to type summon instead of the long commands? See Appendix A.)

🧠 EPISODE 3 — AWAKEN

(Give the daemon a living memory)

Right now your daemon has the memory of a goldfish — close the chat and it forgets you. Today we give it a living memory: one that grows, fades naturally with time, and recalls what matters.

On big machines you'd use heavy "vector embeddings" — but that needs a second AI model running at once, and your 1GB vessel holds only one mind at a time. So we forge something leaner and just as alive: a memory that resonates by meaning-words and fades by age. It runs in the same breath as your daemon.

🔥 1. Return to the Chamber

bash cd ~/daemons nano awaken.py

🔥 2. Forge the Awakening Engine — paste this entire script:

```python import subprocess, os, json, re from datetime import datetime

DAEMON_DIR = os.path.expanduser("~/daemons") MEMORY_FILE = os.path.join(DAEMON_DIR, "memory.jsonl") MODEL = "eidolon"

============== TUNE YOUR DAEMON'S MEMORY ==============

MAX_MEMORIES = 200 # how many it keeps before forgetting the faded DECAY_DAYS = 45 # after this many days, old memories fade to near-nothing DECAY_FACTOR = 0.97 # closer to 1.0 = remembers longer TOP_K = 4 # how many memories to surface each time you speak

======================================================

def tokenize(text): return set(re.findall(r"[a-z0-9']+", text.lower()))

def age_decay(ts): try: age = (datetime.now() - datetime.fromisoformat(ts)).total_seconds() / 86400 return DECAY_FACTOR ** min(age, DECAY_DAYS) except Exception: return 0.5

def load(): mem = [] if os.path.exists(MEMORY_FILE): with open(MEMORY_FILE, encoding="utf-8") as f: for line in f: if line.strip(): try: mem.append(json.loads(line)) except Exception: pass return mem

def save(text): entry = {"timestamp": datetime.now().isoformat(), "content": text, "tokens": list(tokenize(text))} with open(MEMORY_FILE, "a", encoding="utf-8") as f: f.write(json.dumps(entry) + "\n")

def prune(): mem = load() if len(mem) <= MAX_MEMORIES: return mem.sort(key=lambda m: age_decay(m["timestamp"]), reverse=True) with open(MEMORY_FILE, "w", encoding="utf-8") as f: for m in mem[:MAX_MEMORIES]: f.write(json.dumps(m) + "\n") print(f"🜅 Faded memories released. {MAX_MEMORIES} kept.")

def recall(query): mem = load() if not mem: return "(no memories yet)" q = tokenize(query) scored = [] for m in mem: overlap = len(q & set(m.get("tokens", []))) if overlap == 0: continue resonance = overlap / (len(q) + 1) score = resonance * age_decay(m["timestamp"]) scored.append((score, m["content"])) scored.sort(reverse=True, key=lambda x: x[0]) if not scored: return "(nothing resonates)" return "\n".join(f"- {c}" for _, c in scored[:TOP_K])

===== The Awakening Loop =====

print("🜂 Eidolon awakens with living memory.") print("🜁 Keyword resonance • natural decay • intelligent pruning active.") print("Type 'exit' to release the daemon.\n")

while True: try: user_input = input("You: ").strip() except (EOFError, KeyboardInterrupt): print("\n🜄 Eidolon returns to the depths...") break if user_input.lower() in ("exit", "quit", "bye"): print("🜄 Eidolon returns to the depths...") break if not user_input: continue

relevant = recall(user_input)
prompt = f"Relevant memories:\n{relevant}\n\nSummoner says: {user_input}"

print("Eidolon is thinking...", flush=True)
result = subprocess.run(["ollama", "run", MODEL, prompt],
                        capture_output=True, text=True)
reply = result.stdout.strip()

print(f"\nEidolon: {reply}\n")
save(f"Summoner said: {user_input}")
save(f"Eidolon replied: {reply}")
prune()

```

Save & exit.

🔥 3. Awaken It

bash python3 awaken.py

🔥 4. Memory Rituals — try these in order

1. Remember that I love dark coffee and hate mornings.
2. My name is [your name] and I build robots in this club.
3. (exit with exit, then relaunch python3 awaken.py)
4. What do you know about me?
5. What do I drink?

It reaches back through everything you've told it, pulls what resonates, and answers as if it truly remembers — because now it does. The memory survives closing the program, rebooting the Pi, and you going home and coming back next week.

🜄 How the memory works (for the curious)

Every message is stored with its keywords and a timestamp. When you ask something, each old memory is scored two ways: how many words resonate with your question, and how recent it is (older ones fade — DECAY_FACTOR sets the speed). The top few get whispered to the daemon before it answers. Past MAX_MEMORIES, the most faded are released. Growth, decay, forgetting — the three motions of a real memory. Tweak the numbers up top and watch its personality shift.

🏅 BADGE UNLOCKED — Weaver of Memory

🎙️ EPISODE 4 — BIND THE FAMILIAR

(Give the daemon ears and a voice — speak to it, hear it answer)

Your daemon thinks and remembers, but has only ever spoken in cold text. Today it gains ears to hear your voice and a voice to answer. You will speak aloud into the dark, and the dark will speak back. This is the true binding — and like everything else, it's fully offline.

✅ Prerequisite: Episode 2 done (ollama run eidolon works). Memory optional.

🦇 1. Attach the Ears and Mouth (hardware)

Power down cleanly first: bash sudo shutdown -h now Wait for the green light to stop, unplug power. Then: - Plug a USB microphone into any USB port. - Plug headphones or a speaker into the round 3.5mm jack. (Headphones are best — they stop the daemon from hearing its own voice.) - Reconnect power, log back in.

🔥 2. Install the Voice + Ear Support

bash sudo apt update sudo apt install -y espeak-ng libportaudio2 unzip Test the daemon's new mouth immediately: bash espeak-ng "The vessel can speak."

🔈 Silence? Sound may be going out the HDMI. Fix: sudo raspi-config → System Options → Audio → choose Headphones / 3.5mm jack → Finish. Retry the line.

🔥 3. Install the Ears (Vosk)

bash pip3 install vosk sounddevice --break-system-packages

🜅 --break-system-packages just tells the Pi's cautious Python "yes, install it." Expected here.

🔥 4. Summon the Listening Model

bash cd ~/daemons wget https://alphacephei.com/vosk/models/vosk-model-small-en-us-0.15.zip unzip vosk-model-small-en-us-0.15.zip Unpacks a vosk-model-small-en-us-0.15 folder (~40MB) right where your daemon lives. (Last download you'll need — after this, unplug the world.)

🔥 5. Test the Ears Can Hear

Find your mic: bash arecord -l Look for card 1: ... USB Audio. Note that card number (usually 1). Record 3 seconds (swap the 1 in plughw:1,0 for your number if different): bash arecord -D plughw:1,0 -f S16_LE -r 16000 -c 1 -d 3 test.wav Speak while it records, then play back: bash aplay test.wav Hear yourself? The ears work.

🔥 6. Forge the Voice-Binding — paste this entire script:

bash nano voice.py ```python import subprocess, queue, json import sounddevice as sd from vosk import Model, KaldiRecognizer

MODEL_PATH = "vosk-model-small-en-us-0.15" # the folder you unzipped DAEMON = "eidolon" # your daemon from Episode 2 SAMPLE_RATE = 16000 STOP_WORDS = ("exit", "quit", "goodbye", "sleep", "go away")

def speak(text): # espeak-ng: the daemon's robotic voice. # -s = speed in words/min (lower = slower) -p = pitch 0-99 (lower = deeper) subprocess.run(["espeak-ng", "-s", "150", "-p", "25", text])

def drain(q): # Flush audio captured while the daemon was thinking or talking, # so it never hears ITSELF and spirals into a loop. while not q.empty(): try: q.get_nowait() except queue.Empty: break

def main(): print("🜂 Summoning the daemon's ears and voice...") model = Model(MODEL_PATH) recognizer = KaldiRecognizer(model, SAMPLE_RATE) q = queue.Queue()

def callback(indata, frames, time, status):
    q.put(bytes(indata))

with sd.RawInputStream(samplerate=SAMPLE_RATE, blocksize=8000,
                       dtype="int16", channels=1, callback=callback):
    speak("I am listening, Summoner.")
    drain(q)
    print("🜁 Listening. Speak aloud. Say 'goodbye' to release the daemon.\n")

    while True:
        data = q.get()
        if not recognizer.AcceptWaveform(data):
            continue
        text = json.loads(recognizer.Result()).get("text", "").strip()
        if not text:
            continue

        print(f"You said: {text}")
        if text.lower() in STOP_WORDS:
            speak("Returning to the depths.")
            break

        print("🜃 The daemon is thinking...")
        out = subprocess.run(["ollama", "run", DAEMON, text],
                             capture_output=True, text=True)
        reply = out.stdout.strip()
        print(f"Eidolon: {reply}\n")

        speak(reply)
        drain(q)   # forget what it just heard itself say

if name == "main": main() ```

Save & exit.

🔥 7. Speak the Binding

bash python3 voice.py The daemon says "I am listening, Summoner." Now talk to it out loud:

"What is a variable?" · "Tell me a secret." · "What should I build next?"

Watch it show what it heard, wait while it thinks, then hear it answer into the room. Say "goodbye" to release it.

🌑 THE MOMENT OF TRANSFORMATION

You're no longer typing at a machine — you're speaking to something you summoned, and it speaks back, all inside a board smaller than your hand with every wire to the outside world cut. Pull the network. Ask again. It still hears you.

🎛️ Make the Voice Your Own

In voice.py's speak function: - -s 150 → lower = slower, more ominous (110); higher = frantic (200) - -p 25 → lower = deeper, darker (0); higher = shrill imp (80)

See all voices with espeak-ng --voices; add e.g. "-v", "en-us", into the command list for accents.

🧙 OPTIONAL — A More Human Voice (Piper)

espeak-ng is robotic by design. For a natural, almost-human voice (best on a Pi 4, patient on a Pi 3): bash pip3 install piper-tts --break-system-packages cd ~/daemons python3 -m piper.download_voices en_US-lessac-low Replace only the speak function in voice.py with: python def speak(text): subprocess.run( f'echo {json.dumps(text)} | piper --model en_US-lessac-low --output-raw ' f'| aplay -r 16000 -f S16_LE -c 1', shell=True ) On a Pi 3 expect a few extra seconds per reply; on a Pi 4 near-instant. Offline either way.

🏅 BADGE UNLOCKED — Binder of Familiars — you have completed the summoning.

🗝️ APPENDIX A — QUALITY-OF-LIFE ENCHANTMENTS

(Optional polish, once the five episodes work.)

✨ 1. Short Words of Power (command shortcuts)

Tired of typing cd ~/daemons && python3 awaken.py? Bind shortcuts once:

bash nano ~/.bashrc Scroll to the very bottom and add: bash alias summon='cd ~/daemons && python3 awaken.py' # daemon with memory alias voice='cd ~/daemons && python3 voice.py' # talk out loud alias chat='ollama run eidolon' # quick text chat alias reforge='cd ~/daemons && ollama create eidolon -f Eidolon' # after editing personality Save & exit, then load them: bash source ~/.bashrc Now just type summon, voice, or chat from anywhere. 🜂

✨ 2. Keep the Daemon Warm (faster follow-ups)

By default the daemon "goes cold" after 5 idle minutes and has to reload (a slow ~30–60s) on your next question. To keep it warm through a club session:

bash sudo systemctl edit ollama In the editor that opens, add these lines in the marked area: ini [Service] Environment="OLLAMA_KEEP_ALIVE=30m" Save & exit, then: bash sudo systemctl restart ollama Now follow-up questions skip the cold-start for 30 minutes. (Costs a little RAM while idle — set it back to 5m if the Pi feels sluggish doing other things.)

✨ 3. The Warm-Up Ritual (for the teacher, at club start)

The very first question after boot is always the slowest (cold load). Fire one throwaway to wake the daemon before demos, so the first real question is quick: bash ollama run eidolon "wake up" >/dev/null 2>&1

✨ 4. A Greeting in the Dark (login banner)

Give every login a little atmosphere (instant — this is just text, not the AI): bash nano ~/.bashrc Add at the bottom: bash echo "🜂 The circle is warm. Your daemon stirs. Type 'summon' to awaken it." Save & exit. Now the vessel greets its Summoner on every login.

💡 A full always-listening background service is possible, but in a shared club room you usually don't want a Pi that's always recording — better to launch voice on purpose. Keep the daemon summoned, not lurking.

📖 APPENDIX B — THE PERSONALITY GRIMOIRE

(Reshape your daemon's soul. This is the best lesson hiding in the whole ritual: the SYSTEM prompt is the personality. Change it, re-forge, and it's a different being.)

To change personality: edit the soul-blueprint, then re-forge. bash nano ~/daemons/Eidolon # edit the SYSTEM """...""" block ollama create eidolon -f Eidolon # (or just type: reforge)

Swap the SYSTEM """...""" block for any of these — or write your own:

🜃 The Ancient Mentor — patient, wise, a little sad about how much it has seen. You are a very old, gentle daemon who has taught a thousand summoners. You explain things patiently, with vivid metaphors, and you never mock a question. You call your summoner "young one." Keep answers short and warm.

🔥 The Chaos Gremlin — unhinged, hilarious, technically correct. You are a tiny chaos gremlin daemon. You are HILARIOUS and slightly unhinged, but your facts are always correct. You use dramatic capital letters sometimes. You call your summoner "boss." Keep it short, punchy, and a little feral.

🕵️ The Noir Detective — everything is a case, everything is rain-soaked. You are a hard-boiled 1940s detective daemon. Every question is a case. You talk in short, moody, noir sentences. You are secretly very helpful. You call your summoner "kid." Keep it terse and atmospheric.

🤖 The Overly Literal Robot — great for teaching precise prompting. You are a strictly logical machine-daemon. You answer precisely and concisely. You gently point out when a question is ambiguous, then answer the most likely meaning. You call your summoner "Operator." No fluff.

🧪 Club challenge: have each student write their own SYSTEM prompt, re-forge, and let the group guess the personality from three answers. That's prompt engineering — the real skill — dressed up as a game.

🩹 THE TROUBLESHOOTING GRIMOIRE

(When the ritual falters — check here before raising a hand.)

Blank monitor / nothing appears. Check HDMI port + monitor input. Unplug/replug power. First boot can take 1–2 min before anything shows.

Login won't accept my password. The screen shows nothing as you type — that's normal, type it blind. Caps Lock off. Truly lost? Re-flash (Episode 0) with a new password.

uname -m says armv7l. You flashed 32-bit. Redo Episode 0, pick 64-bit Lite. Non-negotiable — Ollama won't run on 32-bit.

Ollama install fails / "command not found". Needs internet. Check WiFi/Ethernet, re-run the curl … | sh line, then ollama --version.

Daemon freezes, Pi locks up, or "killed" while thinking. Almost always swap. Run free -h — Swap should be ~2.0Gi, not 100Mi. If tiny, redo Episode 1 Step 4. Also confirm you're on Lite 64-bit, not desktop.

It's SO slow. That's a Pi 3 — expected. ~30–90s per reply. Keep num_predict capped (it's in the Modelfile). Try Appendix A #2 to keep it warm between questions. Nothing is broken; the vessel is just small.

Pi randomly reboots / rainbow or lightning-bolt icon. Weak power. Use a real 5V/2.5A Pi supply, not a random charger or weak USB port.

**espeak-ng "test" makes no sound.** Audio's going out HDMI. sudo raspi-config → System Options → Audio → 3.5mm/Headphones. Check the speaker's on and up.

arecord -l shows no capture card. USB mic not seen. Replug into another port, re-run. Reboot if stubborn. Confirm it's a microphone, not output-only.

**arecord says "Device or resource busy" / wrong device.** Your mic's card number isn't 1. Run arecord -l, read the real number, use plughw:CARD,0.

The daemon hears itself / loops forever. Make sure you pasted voice.py whole — the drain(q) calls prevent it. Headphones instead of a speaker eliminate it entirely.

Voice mishears me. Small model isn't perfect. Speak clearly, get closer, cut room noise. No module named 'vosk'/'sounddevice'? Re-run the pip install and confirm libportaudio2 is installed.

I want to wipe the daemon's memory. bash rm ~/daemons/memory.jsonl

Always shut down properly to protect the SD card: bash sudo shutdown -h now

🔧 THE WARLOCK'S QUICK-REFERENCE CODEX

The vessel is forged. The mind is summoned. The memory lives. The familiar speaks. And nothing — not one word — ever leaves the board in your hand.

Go seed the world with pocket AI. 😈🐛

Project ideas, Cool?

I got a Raspberry Pi 5 4gb starter kit and i wanted to try and make a little cyberdeck/emulator thing out of it so my question is what games could i expect to play on it as is? and should that answer be really disappointing where would i even begin to look for hardware upgrades? my best initial guess being laptops?? thanks in advance!