Select modules to embed

Darwin Inference Biometrix (face + gait) Speech-to-Text Text-to-Speech Translation (offline) Camera / CV pipeline MQTT bridge Local REST API

Flash instructions: Raspberry Pi 4B

System architecture

┌──────────────────────── Raspberry Pi (DarwinDNA OS) ─────────────────────────┐ │ │ │ ┌─────────────┐ ┌──────────────┐ ┌───────────────┐ ┌─────────────┐ │ │ │ Darwin │ │ Biometrix │ │ STT / TTS │ │ Local API │ │ │ │ Inference │◄──│ Face + Gait │ │ Whisper tiny │ │ :8080 │ │ │ │ (quantized)│ │ (edge model)│ │ pyttsx3 │ │ REST/WS │ │ │ └──────┬──────┘ └──────────────┘ └───────────────┘ └──────┬──────┘ │ │ │ │ │ │ ┌──────▼──────────────────────────────────────────────────────────▼──────┐ │ │ │ Darwin Kernel (systemd services) │ │ │ └──────┬────────────────────────────────────────────┬────────────────────┘ │ │ │ USB Serial / MQTT │ Ethernet / Wi-Fi │ └─────────┼─────────────────────────────────────────────┼────────────────────┘ │ │ ┌──────▼──────┐ ┌───────▼───────┐ │ Arduino │ │ ESP32 node │ │ Sensor MCU │ │ Wi-Fi AI │ │ (firmware) │ │ (firmware) │ └─────────────┘ └───────────────┘

Arduino acts as a peripheral sensor MCU — it reads sensors (PIR, ultrasonic, fingerprint scanner, IMU, microphone) and streams structured data to the Raspberry Pi Darwin brain over USB Serial or I²C. The Pi handles all AI inference; Arduino handles real-time sensor I/O.

Firmware sketch: Darwin sensor bridge

/*
 * DarwinDNA Sensor Bridge — Arduino Firmware
 * Streams sensor readings to Raspberry Pi over USB Serial
 * Protocol: JSON lines at 115200 baud
 */

#include "protocol.h"
#include "sensors.ino"

// ── Config ──────────────────────────────────────
#define BAUD_RATE     115200
#define SENSOR_TICK   50     // ms between readings
#define HEARTBEAT_MS  1000   // alive ping every 1s

unsigned long lastTick = 0;
unsigned long lastHB   = 0;

void setup() {
  Serial.begin(BAUD_RATE);
  initSensors();
  Serial.println("{\"type\":\"boot\",\"fw\":\"darwin-dna-1.0\"}");
}

void loop() {
  unsigned long now = millis();

  // Read & stream sensors
  if (now - lastTick >= SENSOR_TICK) {
    lastTick = now;
    SensorFrame f = readSensors();
    sendFrame(f);
  }

  // Heartbeat
  if (now - lastHB >= HEARTBEAT_MS) {
    lastHB = now;
    Serial.println("{\"type\":\"hb\"}");
  }

  // Handle commands from Pi
  while (Serial.available()) {
    String cmd = Serial.readStringUntil('\n');
    handleCommand(cmd);
  }
}

/*
 * protocol.h — DarwinDNA serial protocol
 * JSON-lines, newline-delimited, 115200 baud
 */

struct SensorFrame {
  float pir;          // motion presence 0/1
  float distance_cm;  // HC-SR04 ultrasonic
  float accel[3];     // IMU x/y/z g-force
  float gyro[3];      // deg/s
  float mic_rms;      // audio RMS level
  bool  fingerprint;  // AS608 match
  unsigned long ts;   // millis()
};

void sendFrame(SensorFrame& f) {
  Serial.print("{\"type\":\"sensor\",");
  Serial.print(  "\"pir\":");         Serial.print(f.pir);
  Serial.print(  ",\"dist\":");       Serial.print(f.distance_cm);
  Serial.print(  ",\"ax\":");         Serial.print(f.accel[0]);
  Serial.print(  ",\"ay\":");         Serial.print(f.accel[1]);
  Serial.print(  ",\"az\":");         Serial.print(f.accel[2]);
  Serial.print(  ",\"ts\":");         Serial.print(f.ts);
  Serial.println("}");
}

void handleCommand(String& cmd) {
  // Pi can send: {"cmd":"led","val":1} etc.
  if (cmd.indexOf("\"led\"") >= 0) {
    bool on = cmd.indexOf("\"val\":1") >= 0;
    digitalWrite(LED_BUILTIN, on ? HIGH : LOW);
  }
}

/*
 * sensors.ino — Sensor init & read helpers
 */
#include <Wire.h>
#include <MPU6050.h>     // IMU
#include <NewPing.h>     // HC-SR04
#include <Adafruit_Fingerprint.h>

#define PIR_PIN      2
#define TRIG_PIN     3
#define ECHO_PIN     4
#define MIC_PIN      A0
#define MAX_DIST_CM  400

MPU6050         imu;
NewPing         sonar(TRIG_PIN, ECHO_PIN, MAX_DIST_CM);
SoftwareSerial  fpSerial(10, 11);
Adafruit_Fingerprint finger(&fpSerial);

void initSensors() {
  pinMode(PIR_PIN, INPUT);
  Wire.begin();
  imu.initialize();
  finger.begin(57600);
}

SensorFrame readSensors() {
  SensorFrame f;
  f.ts          = millis();
  f.pir         = digitalRead(PIR_PIN);
  f.distance_cm = sonar.ping_cm();

  int16_t ax, ay, az, gx, gy, gz;
  imu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
  f.accel[0] = ax / 16384.0;
  f.accel[1] = ay / 16384.0;
  f.accel[2] = az / 16384.0;

  f.mic_rms     = analogRead(MIC_PIN) / 1023.0;
  f.fingerprint = (finger.getImage() == FINGERPRINT_OK);
  return f;
}

Flashing via Arduino IDE / CLI

ESP32 runs a standalone Wi-Fi AI node — it can execute ultra-lightweight Darwin Nano inference locally (no Pi needed for simple tasks), publish sensor data via MQTT to the Pi brain, or act as a wireless camera node streaming frames for remote biometric processing.

ESP32 firmware: standalone Wi-Fi inference node

/*
 * DarwinDNA ESP32 Node — Wi-Fi MQTT + Nano inference
 * Board: esp32:esp32:esp32 · Flash: 4MB
 */
#include <WiFi.h>
#include <PubSubClient.h>     // MQTT
#include <ArduinoJson.h>
#include "darwin_nano.h"       // quantized model header

// ── Credentials ──────────────────────────────────
const char* WIFI_SSID  = "YourNetwork";
const char* WIFI_PASS  = "YourPassword";
const char* MQTT_HOST  = "darwin-brain.local"; // Pi IP
const int   MQTT_PORT  = 1883;
const char* DARWIN_KEY = "mx_live_your_key";

WiFiClient    wifiClient;
PubSubClient  mqtt(wifiClient);
DarwinNano    darwin;               // tiny on-device model

void setup() {
  Serial.begin(115200);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) delay(500);

  mqtt.setServer(MQTT_HOST, MQTT_PORT);
  mqtt.setCallback(onMqttMessage);
  darwin.begin(DARWIN_KEY);          // load quantized weights
  darwin.setMode(DARWIN_SENSOR_MODE); // optimised for sensor data
}

void loop() {
  if (!mqtt.connected()) reconnectMqtt();
  mqtt.loop();

  // Local inference every 200ms
  DarwinResult r = darwin.infer({
    .pir      = digitalRead(4),
    .distance = readUltrasonic(),
    .mic_rms  = readMic()
  });

  StaticJsonDocument<256> doc;
  doc["node"]      = WiFi.macAddress();
  doc["label"]     = r.label;
  doc["confidence"] = r.confidence;
  doc["ts"]        = millis();

  String payload;
  serializeJson(doc, payload);
  mqtt.publish("darwin/inference", payload.c_str());
  delay(200);
}

void onMqttMessage(char* topic, byte* payload, unsigned int len) {
  // Handle commands from Pi brain (e.g. model updates)
  darwin.handleCommand(String((char*)payload).substring(0, len));
}

Flash via esptool / Arduino CLI

Turn your robot dog into
an AI-native companion

Replace the stock GPT integration with Darwin AI — fully local inference, biometric face recognition, Darwin STT/TTS, real-time obstacle reasoning, and emotion-mapped servo actions. No OpenAI key required.

PiDog hardware at a glance

DarwinDNA × PiDog architecture

┌───────────────────────────── Raspberry Pi (DarwinDNA OS) ────────────────────────────┐ │ │ │ ┌────────────────┐ ┌───────────────┐ ┌──────────────┐ ┌──────────────────┐ │ │ │ Darwin Inference│ │ Biometrix │ │ Darwin STT │ │ Darwin TTS │ │ │ │ (chat / reason) │◄──│ Face recog. │ │ Vosk/Whisper│ │ Piper / espeak │ │ │ └───────┬────────┘ └───────────────┘ └──────┬───────┘ └────────┬─────────┘ │ │ │ │ │ │ │ ┌───────▼────────────────────────────────────────▼────────────────────▼──────────┐ │ │ │ DarwinDog ActionFlow Engine │ │ │ │ emotion → LED colour · text → servo action · obstacle → evasion reflex │ │ │ └───────┬───────────────────────────────────────────────────────────────────────┘ │ │ │ pidog Python library │ └───────────┼──────────────────────────────────────────────────────────────────────────┘ │ Robot HAT (I²C / PWM) ┌───────┴───────────────────────────────────────────────────────────────────┐ │ 12× Servo │ Camera │ Ultrasonic │ Touch │ IMU │ LED │ Mic │ └───────────────────────────────────────────────────────────────────────────┘

Setup: from stock PiDog to Darwin-powered dog

darwin_dog.py: Full DarwinDNA × PiDog firmware Copy

"""
darwin_dog.py — DarwinDNA × SunFounder PiDog
AI-native firmware: Darwin inference + biometrix + STT/TTS + servo actions
"""
import time, threading, yaml, requests
from pidog import Pidog
from darwin_dog.stt import DarwinSTT
from darwin_dog.tts import DarwinTTS
from darwin_dog.vision import DarwinVision
from darwin_dog.action_map import ActionMap
from darwin_dog.emotion_leds import EmotionLEDs

# ── Config ───────────────────────────────────────────────────────
with open("/home/pi/darwin-dog.yml") as f:
    cfg = yaml.safe_load(f)

DARWIN_URL   = cfg["darwin_url"]
WAKE_WORD    = cfg["wake_word"]
DOG_NAME     = cfg["dog_name"]
OBS_THRESH   = cfg["obstacle_threshold_cm"]

# ── Hardware init ─────────────────────────────────────────────────
dog    = Pidog()
stt    = DarwinSTT(DARWIN_URL, language=cfg["stt_language"])
tts    = DarwinTTS(DARWIN_URL, model=cfg["tts_model"])
vision = DarwinVision(DARWIN_URL, face_recog=cfg["face_recognition"])
leds   = EmotionLEDs(dog)
actions = ActionMap(dog)

# ── State ─────────────────────────────────────────────────────────
_running       = True
_conversation  = []   # rolling context sent to Darwin
_last_face     = None
_obstacle_lock = threading.Event()

# ── Darwin chat helper ────────────────────────────────────────────
def darwin_chat(user_msg: str, image_b64: str = None) -> dict:
    """Send message to local Darwin inference, return {text, actions}"""
    _conversation.append({"role": "user", "content": user_msg})
    payload = {
        "messages": _conversation[-10:],   # keep last 10 turns
        "system": (
            f"You are {DOG_NAME}, a friendly AI robot dog. "
            "Keep replies short and dog-like. After your text reply, "
            "output ACTIONS: followed by comma-separated action names. "
            "Available actions: sit, stand, walk_forward, walk_backward, "
            "turn_left, turn_right, wag_tail, shake_head, nod, bark, "
            "lie_down, stretch, paw, jump, spin, howl, happy_dance."
        ),
        "stream": False,
    }
    if image_b64:
        payload["image"] = image_b64
    r = requests.post(f"{DARWIN_URL}/api/chat", json=payload, timeout=15)
    reply = r.json()["reply"]
    # Parse ACTIONS: tag
    text, _, action_str = reply.partition("ACTIONS:")
    action_list = [a.strip() for a in action_str.split(",")] if action_str else []
    _conversation.append({"role": "assistant", "content": reply})
    return {"text": text.strip(), "actions": action_list}

# ── Obstacle watchdog (background thread) ────────────────────────
def obstacle_watchdog():
    while _running:
        dist = dog.read_distance()
        if dist is not None and dist < OBS_THRESH:
            _obstacle_lock.set()
            leds.set_emotion("alert")
            dog.do_action("walk_backward", step_count=2)
            time.sleep(1)
            _obstacle_lock.clear()
        time.sleep(0.1)

# ── Touch callbacks ───────────────────────────────────────────────
def on_head_touch(position):
    # front = pet, rear = scratch
    resp = darwin_chat(f"Someone touched my {position} head sensor.")
    leds.set_emotion("happy")
    actions.run(resp["actions"])
    tts.speak(resp["text"])

dog.set_touch_callback(on_head_touch)

# ── Main voice loop ───────────────────────────────────────────────
def voice_loop():
    print(f"[darwin-dog] Listening for wake word: '{WAKE_WORD}'")
    dog.do_action("sit")
    leds.set_emotion("idle")

    while _running:
        if _obstacle_lock.is_set():
            time.sleep(0.1); continue

        phrase = stt.listen_for_wake_word(WAKE_WORD)
        if not phrase:
            continue

        # Woke up — LED breathing + stand
        leds.breathe("pink")
        dog.do_action("stand")
        tts.speak("Hi there!")

        # Capture a camera frame for vision context
        image_b64 = vision.capture_frame_b64() if cfg["face_recognition"] else None
        # Check if known face detected
        if image_b64:
            face = vision.identify_face(image_b64)
            if face:
                phrase = f"I see {face['name']}. {phrase}"

        # Listen for full command
        leds.set_emotion("listening")
        command = stt.listen_command(timeout=8)
        if not command:
            leds.set_emotion("idle")
            dog.do_action("sit")
            continue

        # Darwin thinks
        leds.set_emotion("thinking")
        resp = darwin_chat(command, image_b64=image_b64)

        # Execute servo actions + speak simultaneously
        leds.set_emotion("happy")
        t_actions = threading.Thread(target=actions.run, args=(resp["actions"],), daemon=True)
        t_actions.start()
        tts.speak(resp["text"])
        t_actions.join()

        dog.do_action("sit")
        leds.set_emotion("idle")

# ── Start ─────────────────────────────────────────────────────────
if __name__ == "__main__":
    threading.Thread(target=obstacle_watchdog, daemon=True).start()
    try:
        voice_loop()
    except KeyboardInterrupt:
        _running = False
        dog.do_action("lie_down")
        leds.off()

"""
action_map.py — Darwin action name → PiDog servo sequences
Maps LLM-generated action keywords to pidog library calls.
"""
from pidog import Pidog
import time

class ActionMap:
    ACTION_MAP = {
        "sit":          lambda d: d.do_action("sit", speed=80),
        "stand":        lambda d: d.do_action("stand", speed=80),
        "lie_down":     lambda d: d.do_action("lie_down"),
        "walk_forward": lambda d: d.do_action("walk", step_count=4, speed=85),
        "walk_backward":lambda d: d.do_action("backward", step_count=2, speed=70),
        "turn_left":    lambda d: d.do_action("turn_left", step_count=2),
        "turn_right":   lambda d: d.do_action("turn_right", step_count=2),
        "wag_tail":     lambda d: d.do_action("wag_tail", step_count=5),
        "shake_head":   lambda d: d.head.set_rpy(0, 0, -30) or time.sleep(.4) or d.head.set_rpy(0, 0, 30) or time.sleep(.4) or d.head.set_rpy(0, 0, 0),
        "nod":          lambda d: d.do_action("nod"),
        "bark":         lambda d: d.do_action("bark"),
        "stretch":      lambda d: d.do_action("stretch"),
        "paw":          lambda d: d.do_action("push_up"),
        "jump":         lambda d: d.do_action("jump"),
        "spin":         lambda d: [d.do_action("turn_right", step_count=1) for _ in range(4)],
        "howl":         lambda d: d.do_action("howl"),
        "happy_dance":  lambda d: d.do_action("trot", step_count=6, speed=100),
    }

    def __init__(self, dog: Pidog):
        self.dog = dog

    def run(self, action_names: list):
        for name in action_names:
            fn = self.ACTION_MAP.get(name)
            if fn:
                try:
                    fn(self.dog)
                except Exception as e:
                    print(f"[ActionMap] {name}: {e}")
                time.sleep(0.2)

"""
emotion_leds.py — Darwin emotion → PiDog RGB chest LED mapping
"""
import threading, time
from pidog import Pidog

class EmotionLEDs:
    # (R, G, B) per emotion state
    EMOTION_COLORS = {
        "idle":      (0,   0,   0),    # off
        "listening": (0,   80,  255),  # blue
        "thinking":  (255, 200, 0),    # amber
        "happy":     (0,   255, 180),  # cyan-green
        "alert":     (255, 30,  0),    # red
        "excited":   (160, 0,   255),  # purple
        "sad":       (0,   0,   120),  # dim blue
    }

    def __init__(self, dog: Pidog):
        self.dog = dog
        self._breathe_thread = None
        self._stop_breathe   = threading.Event()

    def set_emotion(self, emotion: str):
        self._stop_breathe.set()
        rgb = self.EMOTION_COLORS.get(emotion, (255, 255, 255))
        self.dog.rgb_strip.set_all(*rgb)

    def breathe(self, color: str = "pink"):
        palettes = {"pink": (255, 80, 160), "cyan": (0, 220, 255), "white": (240, 240, 255)}
        rgb = palettes.get(color, (255, 80, 160))
        self._stop_breathe.clear()

        def _loop():
            while not self._stop_breathe.is_set():
                for v in [*range(0, 256, 8), *range(255, -1, -8)]:
                    if self._stop_breathe.is_set(): break
                    scale = v / 255
                    self.dog.rgb_strip.set_all(int(rgb[0]*scale), int(rgb[1]*scale), int(rgb[2]*scale))
                    time.sleep(0.02)

        self._breathe_thread = threading.Thread(target=_loop, daemon=True)
        self._breathe_thread.start()

    def off(self):
        self._stop_breathe.set()
        self.dog.rgb_strip.set_all(0, 0, 0)

# /etc/systemd/system/darwin-dog.service
# Auto-starts DarwinDog agent on boot

[Unit]
Description=DarwinDNA × PiDog AI Agent
After=network.target darwin-core.service
Requires=darwin-core.service

[Service]
Type=simple
User=pi
WorkingDirectory=/home/pi
ExecStart=/usr/bin/python3 /home/pi/darwin_dog.py
Restart=on-failure
RestartSec=5
Environment=PYTHONUNBUFFERED=1
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

# Install & enable:
# sudo cp darwin-dog.service /etc/systemd/system/
# sudo systemctl daemon-reload
# sudo systemctl enable darwin-dog
# sudo systemctl start darwin-dog

DarwinDNA capabilities on PiDog

Capability	Darwin module	PiDog hardware used	Offline
Voice wake-word + command	darwin/speech_to_text	Microphone (i2S HAT)	✅
Natural language reasoning	darwin/inference	—	✅
Voice response (TTS)	darwin/text_to_speech	Speaker (Robot HAT)	✅
Face recognition + greeting	biometrix/face	Camera (snout)	✅
Obstacle detection + evasion	darwin/inference	Ultrasonic (head) + servos	✅
Touch emotion responses	darwin/inference	Dual touch sensors	✅
Visual scene description	darwin/inference (vision)	Camera (snout)	✅
Multilingual (60+ languages)	darwin/translation	Mic + Speaker	opt-in

Generic Raspberry Pi Robot

Custom Build