Published May 23, 2020 © GPL3+

F3NR1R: Fennec Companion AI Robot (Prototype)

Version 1 of a friendly, wearable robot based on a fennec fox. Work in progress for Virtual Maker Faire :)

AdvancedWork in progress6 hours10,192

F3NR1R: Fennec Companion AI Robot (Prototype)

Things used in this project

Hardware components

Raspberry Pi 3 Model B

Seeed Studio ReSpeaker 2-Mics Pi HAT

Teensy 3.1

SG90 Micro-servo motor

Adafruit Continuous Rotation Servo

SparkFun Snappable Protoboard

Anker PowerCore 26800 (battery)

Brown Dog Gadgets Maker Tape (1/4")

Software apps and online services

Intel OpenVINO™ toolkit

Arduino IDE

Hand tools and fabrication machines

Glowforge

Story

Check out the upgraded version here!

F3NR1R is a little shoulder-mounted robot based on a fennec fox, one of the most adorable creatures I know. His AI brain consists of a Raspberry Pi 3 with a Neural Compute Stick 2, running OpenVINO. (Here's my guide for setting that up!)

If you like companion bots, check out my original owl familiar, Archimedes!

Design

I chose to laser-cut F3N's pieces, first out of cardboard, because it's much faster than 3D printing pieces, and going into the office is a very rare luxury under quarantine.

I compiled a bunch of pictures of fennecs, and used OnShape, paper, and my trusty mm ruler to draw a few layers that would sandwich the camera and servos in F3N's head. The Assembly tab allows me to place all the layers in space, see how the sizes match up, and adjust the design before sending it to the laser.

The servos are mounted diagonally, so that with a single motor for each ear, I can get the multi-axis movement required to make the ears perky or droopy – a key mode of expression for these little guys. :)

Expressive beasties!

I figured I'd give him three eyes, with the third one being the artificially intelligent camera, but for now I'm just trying to get him up and running with the one. :)

All together, F3N has 13 laser-cut parts: two back legs, two front legs, his torso (tapered toward the back), two parts per ear (to sandwich the servo horns), and four face layers (including the tiny nose nubbin). I might add more nose nubbins to give him a longer snout.

1 / 3

For this prototype, I've used hot glue and double-sided foam tape to attach parts together.

The body is encased in a sleeve cut from an old pair of tights. He'll have a little fox tail as well, which the cables will run through.

Recycled cardboard in the prototype

Brain: Pi + NCS2

F3N's brain is set inside his torso. It consists of a RasPi 3 Model B running Raspbian Buster, connected to a Neural Compute Stick 2 running OpenVINO.

There are a couple more pieces stacked on top, for hardware and audio interfacing. Back in the day, we got these Snips + Seeed Voice Interaction kits, and I never really got to use them before Snips was acquired by Sonos and readied for shutdown. But the hardware setup was beautiful. The ReSpeaker 2-Mics Pi HAT provides stereo microphones, as well as two Seeed Grove expansion ports, a mini speaker, and audio out, so it'll be a snap to add extra functionality: servos, relays, an informational LCD, or anything else I can dream up.

1 / 3 • Torso-brain (with 16-channel PWM controller, now removed)

This is going to be a bit hard for me to program, as I'm usually more about the hardware components! But if I can get it working, it'll be a great little platform that could power a huge variety of companion bots.

Motors: Teensy 3.1

F3N's ears are regular, absolute-positioning servos, while for his neck, I used a bigger one that turned out to be a continuous-rotation servo. Good practice!

The ear motors are mounted on an angle, roughly 45º, so that you can get some decent fox-ear behavior – pointing upwards, drooping down & out – with a single motor per ear.

I'm using an Arduino-based board to run all the servos, and will have the Pi interface with it over serial. This is consistently an easier way for me to get things up and running, and provides for more modularity – and thus, versatility. :)

I'm working on doing that with an Arduino Nano 33 BLE Sense, which can do its own machine learning with Edge Impulse, but that board doesn't yet consistently run the Servo library well. I'd also like to try it with the SparkFun Artemis Nano, which is another ML-friendly choice.

After a few snafus, though, for now I'm using my old friend the Teensy 3.1 . It's exciting to finally have the ears and head moving around a bit! Below is a test, to make sure the controller and servos were working properly:

Touch sensitivity

Since I swapped over to the Teensy, I get a bonus feature: capacitive touch! I've added a piece of Maker Tape running down each leg, and those plug into touch-capable analog pins (A4 and A5).

For each leg, I wrapped the conductive Maker Tape around one end of a hookup wire (see above), then stuck the tape down on the robot, and bent the other end so it could fit into the breadboard next to the Teensy. This tape uses conductive adhesive, so you don't need to be all precious about how you connect it to the hookup wire: just wrap it and go! (I added some masking tape on top of each connection, so that they wouldn't come loose.)

With the Teensy 3.1 (and similar boards), you can simply use the function touchRead(PIN) to read a value off the pin. I'm printing these values to the serial monitor, so I could set a threshold for when each leg is touched. In this case, I've found that the "no touch" value hovers around 1200, and "touch" tends to be around 3700-4500. So, I set the threshold values (threshL & threshR) to 3000.

touchL = touchRead(A4);
  Serial.println(touchL);
  touchR = touchRead(A5);
  Serial.println(touchR);
  
  if (touchL >= threshL) {
    Serial.println("touch adjust left");
    headLeft();
  } else if (touchR >= threshR) {
    Serial.println("touch adjust right");
    headRight();
  } else {
    Serial.println("no touch");
    headRandom();
  }

Here's how I've got it set up, right now:

Adapter board

Since I was trying to figure out which board would be best for the motors (and may yet change my mind), I've used a SparkFun Snappable Protoboard with a mini breadboard on top to create a little adapter for swapping out the Arduino Nano 33 BLE Sense, Teensy 3.1, and/or SparkFun Artemis Nano.

I originally snapped the board so that its pin markings would roughly line up with the properly numbered pins on the Arduino Nano, when the Nano is plugged in (except offset by 10, due to space constraints: pin 12 on the protoboard is pin D2 on the Arduino). Fortunately, this also lines up well with the Teensy's analog pins: pin 12 on the protoboard is pin A2. In both cases, this applies when the USB port is just peeking over the edge of the breadboard, so the first pin on the microcontroller is also the first pin on the breadboard.

1 / 4 • Breadboard mounted on Snappable Protoboard

I soldered down a row of 11 3-pin connectors for servos (or NeoPixels, if you make a connector). In the images above and below, you can see power and ground wires going to the power and ground "rails" I constructed. This allows me to connect servos on the bottom side, with power routed from its own USB cable, and signal coming from the Arduino pins (those little orange jumpers). There's also a black common-ground wire going from one rail to the Arduino.

It's also easy for me to add other components via the breadboard – such as connecting Maker Tape to the touch pins on the Teensy (see above). I've also spliced a USB cable to the VIN and GND pins on the Teensy. This is so I don't have to have a MicroUSB cable poking out the front of F3N's chest; all three wires (motor power, Teensy power, RPi power) come out as part of the tail.

A small hair tie around the board keeps the various wires in place.

Code / Behavior

(See the "Code" section below for the Arduino code.)

I've used a bunch of custom functions to make the motor-control code legible and modular. These include a couple of switching functions, which create random combinations of behavior for F3N's head and ears. It has a little more variety than the code I usually run on Archimedes.

For now, the foxlet responds to touch signals as described above, to control the head; if there is no such signal, it chooses a head tilt option (no tilt, left, right). Then, it picks an option for the ears – pointing, drooping, or twitching the ears, individually or together (as well as "no action").

I'd like to create more complex actions, but for now, it works decently well!

Audio

I've now added a little voice functionality via the ReSpeaker 2-Mics Pi HAT and the Festival text-to-speech engine! It doesn't have a ton of personality yet, but at least it can ask me a question and repeat back the answer!

Setting up the ReSpeaker was really easy – I just followed the wiki instructions. Be warned, though: the speaker is right by the mics, so the test script they give you will create a shrieking audio feedback loop!! I also haven't figured out how to properly adjust the volume yet. 😅

Setting up Festival was pretty easy, too – I followed Adafruit's instructions and am now able to get F3N to talk to me, albeit in a Very Computer Voice. There are a bunch of other voices, as well as the option to use other languages, so I'm hoping I'll find a nicer one!

On the other end, Rhasspy has a few options for offline speech-to-text, or I might end up doing some machine learning. More on that later!

Power

I always try and provide separate power to my robot's brain and servo motors, for a couple of reasons: it's easier to troubleshoot, and I can unplug the motors if I want them to shut up for a second. :)

I like being able to hack on my bots at my desk, connected to wall power, but when I wear them, they need to run off batteries. F3N's brain (the Pi) has power broken out from its 5V and GND pins, because if he had a USB cable sticking out of his side, that would look... rather messy. I used an XT60 connector on the other end of the cable, and put its mating connector on a wall plug capable of 5V/4A for plenty of juice. I also made a USB-A cable with the complementary connector, which I can plug into my high-amperage 5V USB battery for portability.

The rechargeable USB battery has three ports, so can also supply cables directly to the servos and to the Teensy controller, as well as the Pi. It's nice to keep them all separate.

Fun fact

F3NR1R is named after one of my family dogs. He's a beautiful, floppy terror. :)

/*
  Code for F3NR1R fennec fox companion bot
  By Alex Glow
  Project notes: bit.ly/f3nr1r

  Servos for neck (continuous), left ear & right ear (absolute)
  Touch-response lines on left & right paw: adjust head tilt
  
  Pins on Teensy 3.1:
  15-19 = A1-5, touch
  20-21 = A6-7, PWM
  22-23 = A8-9, PWM, touch
    Reserve 15-19 for touch
    Reserve 20-23 for 4 servos
  Last 3 pins: 3.3V, AGND, Vin (3.7-5.5V)
  
*/

#include <Servo.h>

Servo servoN; // neck
Servo servoL; // left ear
Servo servoR; // right ear

int tilt = 0;
int ears = 0;

int touchL = 0;
int touchR = 0;
int threshL = 3000;  // calibrate touch responsiveness threshold
int threshR = 3000;

void setup()
{
  Serial.begin(9600);

  servoN.attach(20);
  servoL.attach(21);
  servoR.attach(22);

  earsUp();
  delay(500);
}

void loop() {

  // read capacitive touch values
  touchL = touchRead(A4);
  Serial.println(touchL);
  touchR = touchRead(A5);
  Serial.println(touchR);
  
  if (touchL >= threshL) {
    Serial.println("touch adjust left");
    headLeft();
  } else if (touchR >= threshR) {
    Serial.println("touch adjust right");
    headRight();
  } else {
    Serial.println("no touch");
    headRandom();
  }

  // move ears at random
  earsRandom();

  delay(random(1000,2000));
  
}

void headLeft() {   // adjust head left
  Serial.println("tilt left");
  servoN.write(60);
  delay(60);
  servoN.write(90);  // stop
}

void headRight() {  // adjust head right
  Serial.println("tilt right");
  servoN.write(120);
  delay(60);
  servoN.write(90);  // stop
}

void headRandom() {
  tilt = random(2);
  switch(tilt) {
    case 0:
      Serial.println("no movement");
      break;
    case 1:
      Serial.println("tilt left");
      servoN.write(120);
      delay(60);
      servoN.write(90);
      delay(1000);
      servoN.write(60);
      delay(60);
      servoN.write(90);
      break;
    case 2:
      Serial.println("tilt right");
      servoN.write(60);
      delay(60);
      servoN.write(90);
      delay(1000);
      servoN.write(120);
      delay(60);
      servoN.write(90);
      break;
  }
}

void earsUp() {
  servoL.write(90);
  servoR.write(90);
}

void earsRandom() {
  ears = random(4);               // random int, 0-4
  switch(ears) {
    case 0:
      Serial.println("no movement");
      break;
    case 1:
      Serial.println("ears center");
      servoL.write(90);
      servoR.write(90);
      break;
    case 2:
      Serial.println("both ears down");
      servoL.write(150);
      servoR.write(30);
      delay(500);
      break;
    case 3:
      Serial.println("left ear down");
      servoL.write(140);
      break;
    case 4:
      Serial.println("right ear down");
      servoR.write(40);
      break;
    case 5:
      Serial.println("left ear up");
      servoL.write(90);
      break;
    case 6:
      Serial.println("right ear up");
      servoR.write(90);
      break;
    case 7:
      Serial.println("left ear twitch");
      servoL.write(90);
      servoR.write(90);
      delay(500);
      servoL.write(100);
      delay(10);
      servoL.write(90);
      break;
    case 8:
      Serial.println("right ear twitch");
      servoL.write(90);
      servoR.write(90);
      delay(500);
      servoR.write(100);
      delay(10);
      servoR.write(90);
      break;
  }
}

#!/usr/bin/env python3
import serial
import time
import os

if __name__ == '__main__':
    ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)
    ser.flush()

    ser.write(b"sEarsUp\n")
    os.system("echo 'Hey! How are you?' | festival --tts")

    ser.write(b"sEarsDown\n")
    os.system("arecord -d 3 testrec.wav")
    time.sleep(2)

    ser.write(b"sEarsUp\n")
    os.system("echo 'You said' | festival --tts")
    os.system("aplay testrec.wav")
    time.sleep(1)