Virtual Dad - The Parent You Never Knew You Didn't Want.

Made by joe-hawcroft / 3D Printing / Artificial intelligence / Kids & Family

About the project

Feeling down in the dumps? Need a bit of a laugh? Or a groan? Dads are the best. Always there to make you smile with a terrible joke or some completely irrelevant advice. The Dad Bot is your surrogate father. Terrible Jokes? Check! Bad advice? You betcha! Here's here to cheer you up, even if you don't want to be...

Project info

Difficulty: Moderate

Platforms: Google, Raspberry Pi

Estimated time: 4 hours

License: GNU General Public License, version 3 or later (GPL3+)

Items used in this project

Hardware components

	Google Aiy Vision Full Kit - Includes Pi Zero Wh - V1.1	x 1
	Google Aiy Vision Full Kit - Includes Pi Zero Wh - V1.1	x 1

Software apps and online services

	Raspbian - Google image for AIY Project kits
	icanhazdadjoke.com

Hand tools and fabrication machines

	Creality Ender 3 3D Printer	x 1
	Soldering Iron	x 1
	Snips/Pliers/Cutters	x 1

Story

Background

I wanted to create a lighthearted project that would make people smile, and take advantage of all the fantastic hardware included in the AIY Kits.

With the Coronavirus pandemic in full swing, then I thought we could all use a little cheering up - and honestly, what better than a cringey joke-telling robot that detects how happy you are and cracks a terrible pun.

Getting to grips with the kits

First step is to get the kits built and see what they can do. Googe have done a great job with the AIY Vision & Voice kits and construction was made really simple with a website for each dedicated to clear, step-by-step instruction that even a 10-year-old would be hard-pressed to get wrong.

That said, I only messed up about five or six times... But eventually got both kits up and running.

They''re a lot of fun - especially for the kids who delight in pulling stupid faces at the joy detector and making Google Assistant say inappropriate things. So after a few weeks of messing about with the little cardboard cubes, like a true dad - I set about getting under the hood and pretending I knew what I was doing...

Tinkering with the examples

I started with the vision kit. Interested in seeing how the code worked to trigger events when low or high levels of joy were detected, I suspected there was a routine in there somewhere that I could hijack to carry out my own stupid commands.

You can find the Joy Detector demo code buried in the Raspberry Pi at the following location:

~/AIY-projects-python/src/examples/vision/joy/joy_detector_demo.py

Because I SSH in using PuTTY, I used VIM to explore the code:

sudo vim ~/AIY-projects-python/src/examples/vision/joy/joy_detector_demo.py

And I was right - sitting there at around line 322 is the code:

    if event== ''high'' :
        logger.info(''High joy detected.'')
        player.play(JOY_SOUND)
    elif event == ''low'':
        logger.info(''Low joy detected.'')
        player.play(SAD_SOUND)

I''m not hugely familiar with Python, but I''ve been programming other languages for 25 years, and kids these days are writing games in it while they''re still in nappies, it seems, so it can''t be that hard, right?

Well, digging a little deeper it seems I''m right - after 321 lines of setup and functions and general definitions and logic, my way in to the magic of the AIY Vision kit is those 6 little lines of code.

I want my DadBot to crack an awful joke whenever it detects a face in frame that''s expressing low levels of joy. Because the internet is crammed full of talented and creative weirdos with far too much time on their hands, I came across "icanhazdadjoke.com" which is a web-based API that allows you to programatically retrieve a groan-inducing wisecrack in a variety of different data formats. I couldn''t have asked for anything better. Shout out to Brett Langdon for creating and maintaining this goldmine. Full documentation can be found here.

So, using the Python requests library, we''re able to connect to the api, send the relevant headers to retrieve a joke in plain text format, and boom! instant Dad jokes on demand... Here''s the code:

import requests
r=requests.get(''https://icanhazdadjoke.com/'', headers={''accept'':''text/plain''})
joke=r.text
print joke

This simple bit of code imports the library, creates a GET request (more information about GET and POST requests here) and sends all the relevant headers to the API. I then load the text of the joke response into the joke variable and print it out.

That''s super-simple, and seems to work a treat. Now all I need to do is plug that into the joy-detector code when it detects "low joy" and we''re one step closer to our goal, so this is what I ended up with (after adding the import to the top of the file with the other library imports):

if event== ''high'' :
        logger.info(''High joy detected.'')
        player.play(JOY_SOUND)
    elif event == ''low'':
        r=requests.get(''https://icanhazdadjoke.com/'', headers={''accept'':''text/plain''})
        joke=r.text
        print joke
        logger.info(''Low joy detected.'')
        player.play(SAD_SOUND)

Now we have a Raspberry Pi that looks at your face, and if you''re wearing a frown it''ll go find a crappy joke and print it out. Close, but not exactly what we want. We want our robot to SAY the joke out loud.

Overcoming challenges with sound

I thought of a number of approaches to this conundrum, including using the Google assistant and various online text-to-speech solutions, but they were all either too complicated, required signing up with lots of services, or didn''t sound right.

In the end I settled on using Festival Lite. I love the deadpan delivery of the stock voice, and it''s a self-contained, super simple to use little library that is easy to install on a Pi - just run the following from the console:

 sudo apt-get install flite

And once it''s done, it''s as simple as running the following code to get your Raspberry Pi chattering away...

 flite -t "your text here"

I can''t tell you how many hours I spent using this command to tell the kids they smell (they''re not included in the build time estimate for this project...).

But this is where I ran into my first issue. The Raspberry Pi Zero W has no audio jack. Sound is only available through the HDMI connection, or by connecting to a bluetooth speaker. However, though I was able to connect to a wireless speaker, I still couldn''t get the sound to work at all. The Raspberry Pi simply would not make a peep.

After a number of hours spent swearing and panicking as the competition deadline approached, I realised that the Google AIY Kit Raspbian Image is preconfigured for use with both the Vision AND the Voice kits - it expects to see the Voice Bonnet so it can use the external audio hardware for playing sound. The internal sound module is disabled deep in the Linux configuration somewhere, and it was completely beyond my limited expertise to get it working (Read: I couldn''t find the answer on Stackoverflow).

So, I dug out the pinouts of the AIY kit boards with a bit of Googling and excellent pinout.xyz website and discovered the following:

Vision Bonnet Voice Bonnet

If that''s correct, the two boards don''t share any pins except the i2c bus - and that''s MEANT to share devices, right? The Raspberry Pi must be communicating with the bonnet through i2c. So it might just work stacking the two bonnets on top of each other and keeping my fingers crossed...

So I hastily soldered a pin header on top of the vision kit bonnet and stacked the voice kit on top (unfortunately I didn''t take a picture of the unholy Frankensteined mess, so you''ll have to use your imagination) and switched it on... Booting up didn''t pose a problem at all.

But that was where the good luck ran out.

Neither bonnet wanted to work when they were both plugged in. My robot was now deaf, mute and blind. Back to drawing board.

Serial to the rescue

Okay, just one more thing to try - as an avid Arduino fan, I''m used to using the serial port to communicate between devices, and as the Raspberry Pi has pins reserved for serial communication, I figured that the only way I was going to get this to work would be to have the Vision Kit Pi work on spotting faces, and measuring the emotions, and whenever it sees a particularly high or low level of joy, then send a trigger through the serial port to the Voice Kit Pi which can then go find a joke, and say it out loud.

Simply connect the TXD pin (pin 8 - GPIO 14) on one Pi to the RXD pin (pin 10 - GPIO15) of the other, and vice versa, and connect the grounds of the two devices and you''re home and dry - your Pis can now talk to each other. I also connected the 5v rails so the Voice Kit Pi could piggy back off the Vision Kit Pi power supply. Disclaimer: This is not the recommended way to power a Raspberry Pi, so I don''t suggest you do it unless you''re willing to run the risk of damanging one of your Pis - I was being lazy and have a drawer full of spares...

As you can see - I soldered to the UART breakout on the Voice Bonnet, and the underside of the Vision Kit Pi - but soldering direct to the Pi GPIO pins will work, too.

Now there''s just a couple of small additional changes to make in the configuration, you want to enable serial communication on the Pi, so open a terminal on each Pi and run:

sudo raspi-config

This will fire up the Raspberry Pi configuration tool. Use the arrow keys to select "Interfacing Options" and hit enter. On the next screen, select "Serial" and hit enter. You will now be asked if you want the login shell to be accessible over serial. Be sure to select "No".

Then, you will be asked if you want to make use of the Serial Port Hardware. Select "Yes" and hit Enter to proceed. Once the Raspberry Pi has made the changes, you should see the following:

The serial login shell is disabled The serial interface is enabled

Then you just need to restart the Pis:

sudo reboot

Now you''re all set up. We can use the Python serial library to get our Pis talking to each other. First, we need to create a serial object and define a few things like port, byte size and timeouts. Then we can use that object to write out to the serial port:

import serial
import time
ser = serial.Serial(
        port=''/dev/Serial0'',
        baudrate = 9600,
        parity=serial.PARITY_NONE,
        stopbits=serial.STOPBITS_ONE,
        bytesize=serial.EIGHTBITS,
        timeout=1
)
counter=0
while 1:
        ser.write(counter)
        time.sleep(1)
        counter += 1

/dev/Serial0 is the port used to communicate with the GPIO serial connection.

And on the Voice Kit side, we just need to set up our serial object in the same way, and listen for any chatter on the channel...

import time
import serial
 
ser = serial.Serial(
        port=''/dev/Serial0'',
        baudrate = 9600,
        parity=serial.PARITY_NONE,
        stopbits=serial.STOPBITS_ONE,
        bytesize=serial.EIGHTBITS,
        timeout=1
)
while 1:
        x=ser.readline()
        print x,

Running both scripts on the relevant devices should result in the Voice Kit Pi sending a count, and the Vision Kit Pi receiving the number and printing it to the terminal. That means I can send a command through serial from the Vision kit every time it detects low or high joy, and the Voice Kit can carry out an action based on that command!

Finally, we have solved the audio issues, and used BOTH the kits, even if it is in the most Heath-Robinson, clumsy way possible. HAHAHA!

It''s ALIIIIVEEEEEE!

Okay, we now have all the component parts in place - all that remains is to mash it all together into a unified whole...

You can download my modified Vision Kit code and the Voice kit code at the end of this tutorial.

You will also see I''m using the os library in there to allow Python to run terminal commands. That way, when I get the relevant trigger, I can retrieve a joke from the web service, and send it directly to Flite. All the additional encoding/decoding is there to ensure all quotes/double quotes are correct and I''m not using any illegal characters that might break the script as I noticed some of the characters in the jokes returned by the API were causing me problems.

I''ve also dressed it up with a few other dadisms that are guaranteed to make you cringe regardless of your mood, and we''re done with the electronics and software.

Last steps

I decided to put everything back inside the Voice kit container and dad it up with a pipe and some socks and sandals. I got rid of the buttons, and the privacy LED (because seriously - who''s dad cares about privacy?!). And that about brings us to a wrap. Delight the kids, embarrass their friends, and generally take joy in the pinnacle of AI and face recognition technology. DadBot.

CAD, enclosures and custom parts

Socks and Sandals STL

I remixed this from a model I found on Thingiverse, linked in my witeup

Code

dad_talk.py

This is the code that runs on the Voice Kit Pi.

#!/usr/bin/env python
import time
import serial
import requests
import os
import random

happyStrings=["You look happy. For once", "Gosh, you've got a smile on your fac$
sadStrings=["Cheer up grumpy guts. How about this.", "Someone looks like they n$

os.system('flite -t "Who\'s ready for some jokes..."')

ser=serial.Serial(
        port='/dev/serial0',
        baudrate=9600,
        parity=serial.PARITY_NONE,
        stopbits=serial.STOPBITS_ONE,
        bytesize=serial.EIGHTBITS,
        timeout=1
        )
while 1:
    val=ser.readline()
    print val
    if val=='high':
        time.sleep(1)
        happyString=random.choice(happyStrings)
        os.system('flite -t "'+happyString+'"')
    elif val=='low':
        r=requests.get('https://icanhazdadjoke.com/', headers={'Accept':'text/p$
        joke=r.text
        print joke
        aJoke=joke.decode("ascii")
        aJoke=aJoke.replace('"', "'")
        #ujoke=ajoke.encode("utf-8", "ignore")
        sadString=random.choice(sadStrings)
        os.system('flite -t "'+sadString+'"')
        os.system('flite -t "'+aJoke+'"')

joy_detect.py

This is the code that runs on the vision kit. It's the edited Joy Detector code.

#!/usr/bin/env python3
# Copyright 2017 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Joy detection demo."""
import argparse
import collections
import contextlib
import io
import logging
import math
import os
import queue
import signal
import sys
import threading
import time
import serial


from PIL import Image, ImageDraw, ImageFont
from picamera import PiCamera

from aiy.board import Board
from aiy.leds import Color, Leds, Pattern, PrivacyLed
from aiy.toneplayer import TonePlayer
from aiy.vision.inference import CameraInference
from aiy.vision.models import face_detection
from aiy.vision.streaming.server import StreamingServer
from aiy.vision.streaming import svg

logger = logging.getLogger(__name__)

ser=serial.Serial(
        port='/dev/serial0',
        baudrate=9600,
        parity=serial.PARITY_NONE,
        stopbits=serial.STOPBITS_ONE,
        bytesize=serial.EIGHTBITS,
        timeout=1
        )
JOY_COLOR = (255, 70, 0)
SAD_COLOR = (0, 0, 64)

JOY_SCORE_HIGH = 0.4
JOY_SCORE_LOW = 0.02

JOY_SOUND = ('C5q', 'E5q', 'C6q')
SAD_SOUND = ('C6q', 'E5q', 'C5q')
MODEL_LOAD_SOUND = ('C6w', 'c6w', 'C6w')
BEEP_SOUND = ('E6q', 'C6q')

FONT_FILE = '/usr/share/fonts/truetype/freefont/FreeSans.ttf'

BUZZER_GPIO = 22

@contextlib.contextmanager
def stopwatch(message):
    try:
        logger.info('%s...', message)
        begin = time.monotonic()
        yield
    finally:
        end = time.monotonic()
        logger.info('%s done. (%fs)', message, end - begin)


def run_inference(num_frames, on_loaded):
    """Yields (faces, (frame_width, frame_height)) tuples."""
    with CameraInference(face_detection.model()) as inference:
        on_loaded()
        for result in inference.run(num_frames):
            yield face_detection.get_faces(result), (result.width, result.heigh$


def threshold_detector(low_threshold, high_threshold):
    """Yields 'low', 'high', and None events."""
    assert low_threshold < high_threshold

    event = None
    prev_score = 0.0
    while True:
        score = (yield event)
        if score > high_threshold > prev_score:
            event = 'high'
        elif score < low_threshold < prev_score:
            event = 'low'
        else:
            event = None
        prev_score = score


def moving_average(size):
    window = collections.deque(maxlen=size)
    window.append((yield 0.0))
    while True:
        window.append((yield sum(window) / len(window)))


def average_joy_score(faces):
    if faces:
        return sum(face.joy_score for face in faces) / len(faces)
    return 0.0


def draw_rectangle(draw, x0, y0, x1, y1, border, fill=None, outline=None):
    assert border % 2 == 1
    for i in range(-border // 2, border // 2 + 1):
        draw.rectangle((x0 + i, y0 + i, x1 - i, y1 - i), fill=fill, outline=out$


def scale_bounding_box(bounding_box, scale_x, scale_y):
    x, y, w, h = bounding_box
    return (x * scale_x, y * scale_y, w * scale_x, h * scale_y)


def svg_overlay(faces, frame_size, joy_score):
    width, height = frame_size
    doc = svg.Svg(width=width, height=height)

    for face in faces:
        x, y, w, h = face.bounding_box
        doc.add(svg.Rect(x=int(x), y=int(y), width=int(w), height=int(h), rx=10$
                         fill_opacity=0.3 * face.face_score,
                         style='fill:red;stroke:white;stroke-width:4px'))

        doc.add(svg.Text('Joy: %.2f' % face.joy_score, x=x, y=y - 10,
                         fill='red', font_size=30))

    doc.add(svg.Text('Faces: %d Avg. joy: %.2f' % (len(faces), joy_score),
            x=10, y=50, fill='red', font_size=40))
    return str(doc)


class Service:

    def __init__(self):
        self._requests = queue.Queue()
        self._thread = threading.Thread(target=self._run, daemon=True)
        self._thread.start()

    def _run(self):
        while True:
            request = self._requests.get()
            if request is None:
                self.shutdown()
                break
            self.process(request)
            self._requests.task_done()

    def process(self, request):
        pass

    def shutdown(self):
        pass

    def submit(self, request):
        self._requests.put(request)

    def close(self):
        self._requests.put(None)
        self._thread.join()

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, exc_tb):
        self.close()

class Player(Service):
    """Controls buzzer."""

    def __init__(self, gpio, bpm):
        super().__init__()
        self._toneplayer = TonePlayer(gpio, bpm)

    def process(self, sound):
        self._toneplayer.play(*sound)

    def play(self, sound):
        self.submit(sound)

class Photographer(Service):
    """Saves photographs to disk."""

    def __init__(self, format, folder):
        super().__init__()
        assert format in ('jpeg', 'bmp', 'png')

        self._font = ImageFont.truetype(FONT_FILE, size=25)
        self._faces = ([], (0, 0))
        self._format = format
        self._folder = folder

    def _make_filename(self, timestamp, annotated):
        path = '%s/%s_annotated.%s' if annotated else '%s/%s.%s'
        return os.path.expanduser(path % (self._folder, timestamp, self._format$

    def _draw_face(self, draw, face, scale_x, scale_y):
        x, y, width, height = scale_bounding_box(face.bounding_box, scale_x, sc$
        text = 'Joy: %.2f' % face.joy_score
        _, text_height = self._font.getsize(text)
        margin = 3
        bottom = y + height
        text_bottom = bottom + margin + text_height + margin
        draw_rectangle(draw, x, y, x + width, bottom, 3, outline='white')
        draw_rectangle(draw, x, bottom, x + width, text_bottom, 3, fill='white'$
        draw.text((x + 1 + margin, y + height + 1 + margin), text, font=self._f$

    def process(self, message):
        if isinstance(message, tuple):
            self._faces = message
            return

        camera = message
        timestamp = time.strftime('%Y-%m-%d_%H.%M.%S')

        stream = io.BytesIO()
        with stopwatch('Taking photo'):
            camera.capture(stream, format=self._format, use_video_port=True)

        filename = self._make_filename(timestamp, annotated=False)
        with stopwatch('Saving original %s' % filename):
            stream.seek(0)
            with open(filename, 'wb') as file:
                file.write(stream.read())

        faces, (width, height) = self._faces
        if faces:
            filename = self._make_filename(timestamp, annotated=True)
            with stopwatch('Saving annotated %s' % filename):
                stream.seek(0)
                image = Image.open(stream)
                draw = ImageDraw.Draw(image)
                scale_x, scale_y = image.width / width, image.height / height
                for face in faces:
                    self._draw_face(draw, face, scale_x, scale_y)
                del draw
                image.save(filename)

    def update_faces(self, faces):
        self.submit(faces)

    def shoot(self, camera):
        self.submit(camera)


class Animator(Service):
    """Controls RGB LEDs."""

    def __init__(self, leds):
        super().__init__()
        self._leds = leds

    def process(self, joy_score):
        if joy_score > 0:
            self._leds.update(Leds.rgb_on(Color.blend(JOY_COLOR, SAD_COLOR, joy$
        else:
            self._leds.update(Leds.rgb_off())

    def shutdown(self):
        self._leds.update(Leds.rgb_off())

    def update_joy_score(self, joy_score):
        self.submit(joy_score)


def joy_detector(num_frames, preview_alpha, image_format, image_folder,
                 enable_streaming, streaming_bitrate, mdns_name):
    done = threading.Event()
    def stop():
        logger.info('Stopping...')
        done.set()

    signal.signal(signal.SIGINT, lambda signum, frame: stop())
    signal.signal(signal.SIGTERM, lambda signum, frame: stop())

    logger.info('Starting...')
    with contextlib.ExitStack() as stack:
        leds = stack.enter_context(Leds())
        board = stack.enter_context(Board())
        player = stack.enter_context(Player(gpio=BUZZER_GPIO, bpm=10))
        photographer = stack.enter_context(Photographer(image_format, image_fol$
        animator = stack.enter_context(Animator(leds))
        # Forced sensor mode, 1640x1232, full FoV. See:
        # https://picamera.readthedocs.io/en/release-1.13/fov.html#sensor-modes
        # This is the resolution inference run on.
        # Use half of that for video streaming (820x616).
        camera = stack.enter_context(PiCamera(sensor_mode=4, resolution=(820, 6$
        stack.enter_context(PrivacyLed(leds))

        server = None
        if enable_streaming:
            server = stack.enter_context(StreamingServer(camera, bitrate=stream$
                                                         mdns_name=mdns_name))

        def model_loaded():
            logger.info('Model loaded.')
            player.play(MODEL_LOAD_SOUND)

        def take_photo():
            logger.info('Button pressed.')
            player.play(BEEP_SOUND)
            photographer.shoot(camera)

        if preview_alpha > 0:
            camera.start_preview(alpha=preview_alpha)

        board.button.when_pressed = take_photo

        joy_moving_average = moving_average(10)
        joy_moving_average.send(None)  # Initialize.
        joy_threshold_detector = threshold_detector(JOY_SCORE_LOW, JOY_SCORE_HI$
        joy_threshold_detector.send(None)  # Initialize.
        for faces, frame_size in run_inference(num_frames, model_loaded):
            photographer.update_faces((faces, frame_size))
            joy_score = joy_moving_average.send(average_joy_score(faces))
            animator.update_joy_score(joy_score)
            event = joy_threshold_detector.send(joy_score)
            #logger.info(joy_score);
            if event == 'high':
                logger.info('High joy detected.')
                player.play(JOY_SOUND)
                ser.write("high".encode())
            elif event == 'low':
                logger.info('Low joy detected.')
                player.play(SAD_SOUND)
                ser.write("low".encode())
            if server:
                server.send_overlay(svg_overlay(faces, frame_size, joy_score))

            if done.is_set():
                break

def preview_alpha(string):
    value = int(string)
    if value < 0 or value > 255:
        raise argparse.ArgumentTypeError('Must be in [0...255] range.')
    return value

def main():
    logging.basicConfig(level=logging.INFO)

    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsH$
    parser.add_argument('--num_frames', '-n', type=int, default=None,
                        help='Number of frames to run for')
    parser.add_argument('--preview_alpha', '-pa', type=preview_alpha, default=0,
                        help='Video preview overlay transparency (0-255)')
    parser.add_argument('--image_format', default='jpeg',
                        choices=('jpeg', 'bmp', 'png'),
                        help='Format of captured images')
    parser.add_argument('--image_folder', default='~/Pictures',
                        help='Folder to save captured images')
    parser.add_argument('--blink_on_error', default=False, action='store_true',
                        help='Blink red if error occurred')
    parser.add_argument('--enable_streaming', default=False, action='store_true$
                        help='Enable streaming server')
    parser.add_argument('--streaming_bitrate', type=int, default=1000000,
                        help='Streaming server video bitrate (kbps)')
    parser.add_argument('--mdns_name', default='',
                        help='Streaming server mDNS name')
    args = parser.parse_args()

    try:
        joy_detector(args.num_frames, args.preview_alpha, args.image_format, ar$
                     args.enable_streaming, args.streaming_bitrate, args.mdns_n$
    except KeyboardInterrupt:
        pass
    except Exception:
        logger.exception('Exception while running joy demo.')
        if args.blink_on_error:
            with Leds() as leds:
                leds.pattern = Pattern.blink(100)  # 10 Hz
                leds.update(Leds.rgb_pattern(Color.RED))
                time.sleep(1.0)

    return 0

if __name__ == '__main__':
    sys.exit(main())

Credits

joe-hawcroft

Multi-skilled digital idiot with a broad skill set. If it can be bodged, you'll probably find me bodging it.

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast

Virtual Dad - The Parent You Never Knew You Didn't Want.

About the project

Project info

Items used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Background

Getting to grips with the kits

Tinkering with the examples

Overcoming challenges with sound

Vision Bonnet Voice Bonnet

Serial to the rescue

It''s ALIIIIVEEEEEE!

Last steps

CAD, enclosures and custom parts

Socks and Sandals STL

Code

dad_talk.py

joy_detect.py

Credits

joe-hawcroft

Leave your feedback...

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast

Virtual Dad - The Parent You Never Knew You Didn't Want.

About the project

Project info

Items used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Background

Getting to grips with the kits

Tinkering with the examples

Overcoming challenges with sound

Vision Bonnet Voice Bonnet

Serial to the rescue

It''s ALIIIIVEEEEEE!

Last steps

CAD, enclosures and custom parts

Socks and Sandals STL

Code

dad_talk.py

joy_detect.py

Credits

joe-hawcroft

Leave your feedback...

Related products