今までになかったコンセプトの製品で、昨今のAIブームとも相性が良く、音声インターフェースを使ったガジェットを手軽に作れる点が魅力です。

この記事では、Whisplay HATを使い、AIチャットボットとニュース読み上げガジェットの作り方を解説します。ラズパイの可能性がさらに広がる感覚をつかめるはずです。

私が購入した時点では、Amazonで在庫がなく、公式サイトから購入しました。

Whisplay HATは音声アシスタントに特化

Whisplay HATは、Raspberry Pi Zero 2 WやRaspberry Pi 5に対応した、音声と表示をまとめて扱える拡張ボードです。Raspberry Piに取り付けることで、以下の機能が使えるようになります。

Raspberry PiのGPIOにそのまま差し込むだけで利用できる便利な設計です。複雑な配線を行う手間がなく、使い始められます。

Raspberry Pi Zero 2 Wと同サイズなので、一体感のあるスマートな見た目に仕上がる点が気に入っています。

Whisplay HATの使用準備

Raspberry Pi OSはTrixieのデスクトップ版を選択しました。

Whisplay HATの取り付け

Raspberry PiのGPIOピンに差し込みます。この際、LCD部分を押さえないように注意しましょう。

Whisplay HATの初期設定

Raspberry Piを起動して、Whisplay HATの使用準備をします。

Whisplay HATのプログラムをダウンロードします。--depth 1は最新版だけを取得する指定です。以下を入力したあとにEnterキーを押すと実行されます。

git clone https://github.com/PiSugar/Whisplay.git --depth 1

フォルダを移動します。

cd Whisplay/Driver

以下を実行すると、音声チップの設定や、I2C・I2Sといった通信機能の有効化が自動で行われます。先頭のyesは、途中で表示される確認メッセージに対して自動的に「yes」と答えるためのものです。

yes | sudo bash install_wm8960_drive.sh

Raspberry Piを再起動して、設定を反映させます。

sudo reboot

Whisplay HATの動作確認

再起動したら、Whisplay HATの動作を確認するためのテストプログラムを実行してみましょう。以下のコマンドでtest.pyを起動します。

cd /home/pi/Whisplay/example && python3 test.py

プログラムを起動すると、data/test.pngの画像がLCDに表示されます。Whisplay HATの右側面に付いている白いボタンを押すと、サンプルの音声が再生され、画面とLEDの色が赤・緑・青の順に切り替わります。

この動作により、画面表示、音声再生、LED制御、ボタン入力といった機能が正常に動いているかを確認できます。テストコードの中身を確認することで、Whisplay HATの動かし方が理解でき、オリジナルのプロジェクトを作る際のヒントにもなります。

音量の調整

スピーカーの音量は、デスクトップ画面右上のスピーカーのアイコンをクリックして変更できます。

AIチャットボットを動かす

メーカーが公開している音声チャットボット「Whisplay AI Chatbot」を使うことで、会話デバイスを簡単に構築できます。ボタンを押して話しかけると、AIが音声で返答する仕組みです。

Whisplay AI Chatbotは、複数のAIサービスに対応しています。クラウド型ではOpenAIやGeminiなどが使えます。ローカル型ではOllamaやWhisper、Piperなどを使ってオフライン動作も可能です。

そぞら

ここでは、最も簡単に設定できるOpenAIのサービスを使って設定します。

まずはGitHubに公開されているソースコード（プログラム一式）をダウンロードします。whisplay-ai-chatbotフォルダが作成され、その中にソースコードが保存されます。

git clone https://github.com/PiSugar/whisplay-ai-chatbot.git

ダウンロードしたフォルダへ移動します。

cd whisplay-ai-chatbot

プログラムを動かすために必要なソフトをまとめてインストールします。以下を実行すると、音声処理やAIの動作に必要なライブラリ、Node.jsやPython関連のパッケージが自動でインストールされます。

bash install_dependencies.sh

設定ファイル（.bashrc）の内容を反映します。

source ~/.bashrc

.env.templateをコピーして.envというファイルを作成します。

cp .env.template .env

そぞら

チャットボットは、設定が書かれた.envというファイルを読み込んで動きます。

次のコマンドで.envを開きます。nanoはターミナル上でテキストファイルを編集できるシンプルなエディタです。

nano .env

APIキーを準備する

ここでは詳細を説明しませんが、以下の手順でOpenAIのAPIキーを作成します。事前にAPI利用料金も確認しておきましょう。使用するモデルはデフォルトでgpt-4oが設定されています。

1. 管理画面（APIプラットフォーム）を開く
2. アカウントを作成またはログインする
3. 金額を選んでクレジットを購入（$5 creditsで十分）
4. OpenAI developer platformの画面右上の歯車マークをクリック
5. 「API keys」ページに移動する
6. 「Create new secret key」をクリックしてAPIキーを発行する
7. 表示されたキーをコピーして保存する

APIキーを設定する

テンプレートはデフォルトで音声認識・会話処理・音声出力のすべてをOpenAIで行う設定になっています。.envの下の方までスクロールして、OpenAIのAPIキーを入力します。

OPENAI_API_KEY=ここに自分のAPIキー

nano .envで編集したあと、Ctrlキーを押しながらOを押して保存します。画面下にファイル名が表示されるので、そのままEnterキーを押すと保存が確定します。その後、Ctrlキーを押しながらXを押すとnanoが終了します。

プロジェクトをビルドします。依存パッケージの準備や必要なファイルの生成が行われ、チャットボットを起動できる状態になります。

bash build.sh

チャットボットを動かしてみる

以下のコマンドでチャットボットが起動します。

bash run_chatbot.sh

起動後は、Whisplay HATの右側面に付いている白いボタンを押している間に話しかけます。話し終えたらボタンを離すと、音声がOpenAIに送信され、内容が解析されます。

その後、AIが返答を生成し、その内容が音声として再生されます。

終了する場合は、ターミナルでCtrlキーとCを押すと停止します。

Raspberry Piを再起動したあとは、以下のコマンドでチャットボットを起動できます。

cd ~/whisplay-ai-chatbot && bash run_chatbot.sh

ニュースを読み上げるガジェットを作ろう

ここからはWhisplay HATの独自の使い方を紹介します。API料金を気にせず使える方法として、ローカル環境だけで音声を生成する構成を考えました。今回はインターネットからニュースを取得し、その見出しを音声で読み上げるガジェットを作成します。

テキストをしゃべらせてみよう

OpenJTalkをインストールします。OpenJTalkは、名古屋工業大学を中心に開発された、日本語の文章を音声に変換して読み上げるオープンソースの音声合成エンジンです。

sudo apt install -y open-jtalk open-jtalk-mecab-naist-jdic hts-voice-nitech-jp-atr503-m001

音声対話ソフトMMDAgentのサンプルに含まれる音声を取得します。

wget https://downloads.sourceforge.net/project/mmdagent/MMDAgent_Example/MMDAgent_Example-1.8/MMDAgent_Example-1.8.zip

ZIP形式のファイル「MMDAgent_Example-1.8.zip」を解凍します。

unzip MMDAgent_Example-1.8.zip

meiフォルダをシステムの音声データ用ディレクトリ（/usr/share/hts-voice/）にコピーします。

sudo cp -r MMDAgent_Example-1.8/Voice/mei /usr/share/hts-voice/

Thonnyを開いて、Pythonのプログラムを実行します。

以下のコードをコピーペーストして実行してみましょう。Whisplay HATのスピーカーから「こんにちは」の音声が流れるはずです。

import subprocess

def speak_japanese(text, voice="normal", speed=0.8):
    # voiceで選択できる種類
    # "normal"   : 標準
    # "happy"    : 明るい
    # "angry"    : 怒り
    # "sad"      : 悲しい
    # "bashful"  : 照れ
    voice_path = f"/usr/share/hts-voice/mei/mei_{voice}.htsvoice"

    subprocess.run(
        [
            "open_jtalk",
            "-x", "/var/lib/mecab/dic/open-jtalk/naist-jdic",
            "-m", voice_path,
            "-r", str(speed),
            "-ow", "/tmp/test.wav"
        ],
        input=text,
        text=True
    )

    subprocess.run(["aplay", "/tmp/test.wav"])

speak_japanese("こんにちは", "happy")

エラーが出る場合

Whisplay HATのテストプログラム実行後の場合などは、音声デバイス（/dev/snd）が解放されず、以下のエラーが出ることがあります。

この場合は、以下のコマンドで使用中のプロセスを強制終了してデバイスを解放します。

sudo fuser -k /dev/snd/*

プログラムの解説

日本語テキストをOpenJTalkで音声に変換し、/tmp/test.wavに保存してから再生する処理です。読み上げる内容はtextに入れた文字で決まり、voiceで声の種類（normal・happyなど）を選べます。speedで話す速さを調整でき、数値が小さいほどゆっくり、大きいほど速くなります。

最後のspeak_japanese("こんにちは", "happy")は、「こんにちは」を明るい声で再生する指定です。

ニュースを取得してみよう

NHKのRSSを使い、ニュースの見出しを取得する手順を確認します。RSSはニュースサイトが更新情報を公開している仕組みで、その中に含まれる見出しデータを読み取ることでニュースの見出しを取得できます。

仮想環境を作成

python3 -m venv venv --system-site-packages

仮想環境を有効化

source venv/bin/activate

RSSはXML形式なので、解析用ライブラリをインストールします。

pip install feedparser

Thonnyを仮想環境に切り替える

「Python executable」の右側にある「…」ボタンをクリックして、使用するPython（仮想環境のpython）を選択します。

ホームをクリック。

venvを選択

binを選択。

pythonを選択。

OKをクリック。

仮想環境に切り替えたら、Thonnyで以下を実行します。

import feedparser

url = "https://www.nhk.or.jp/rss/news/cat0.xml"

feed = feedparser.parse(url)

for entry in feed.entries[:5]:
    print(entry.title)

このコードは、インターネット上のニュースを取得して表示するプログラムです。まず、NHKが公開しているRSSのURLからニュース情報を読み込みます。URLに含まれるcat0はニュースのカテゴリを表しており、主要ニュース（総合）の見出しを取得できます。この数値を変更すれば、さまざまなジャンルのニュースに切り替え可能です。

eedparser.parse(url)でデータを取得すると、その中にニュースの一覧が含まれます。feed.entriesには記事ごとの情報が入っており、[:5]とすることで最初の5件だけを取り出しています。

動画とアイコンを準備する

ニュースの取得方法がわかったら、画面表示の準備をします。ニュースの文字を表示するだけでは味気ないので、アイコンと背景動画で気分を盛り上げることにしました。

映画マトリックス風の動画は、Pixabayで公開されているものをダウンロードして使用します。Pixabayは著作権フリーの画像、動画、音声などを共有するサイトです。サイズは640×360のものをダウンロードしました。

スピーカーのアイコン画像は以下からダウンロードできます。私がCanvaで作成したものです。

スピーカーアイコン

1 ファイル 4.69 KB

ダウンロード

動画とアイコンはRaspberry Piの「/home/pi」ディレクトリに保存します。動画のファイル名はmatrix.mp4に必ず変更してください。スクリプトから参照できなくなります。

Pythonで画像や映像を扱えるOpenCVライブラリをインストールします。

sudo apt install -y python3-opencv

日本語フォントの準備

LCDにニュースをテキスト表示するために、日本語対応のフォント（Noto）をインストールします。

sudo apt install -y fonts-noto-cjk

完成したプログラム

以下はWhisplay HATを使い、RSSから取得したニュースを音声で読み上げながらテキスト表示するプログラムです。

import cv2
import time
import sys
import os
import numpy as np
from PIL import Image, ImageDraw, ImageFont
import subprocess
import feedparser
import unicodedata
import threading

mode = 0
speech_ready = False

sys.path.append(os.path.abspath("/home/pi/Whisplay/Driver"))
from WhisPlay import WhisPlayBoard

# =========================
# TTS
# =========================
def speak(text, voice="normal", speed=0.9):

    voice_path = f"/usr/share/hts-voice/mei/mei_{voice}.htsvoice"

    subprocess.run(
        [
            "open_jtalk",
            "-x", "/var/lib/mecab/dic/open-jtalk/naist-jdic",
            "-m", voice_path,
            "-r", str(speed),
            "-ow", "/tmp/test.wav"
        ],
        input=text,
        text=True
    )

    subprocess.run(["aplay", "/tmp/test.wav"])
    
# =========================
# Init
# =========================
board = WhisPlayBoard()
board.set_backlight(100)

VIDEO_PATH = "/home/pi/matrix.mp4"

font = ImageFont.truetype(
    "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc", 26
)

show_text = False
current_text = ""

# RSS source list (expandable)
RSS_FEEDS = [
    "https://www3.nhk.or.jp/rss/news/cat5.xml"
    #"https://news.yahoo.co.jp/rss/topics/it.xml"
]

def fetch_news():
    headlines = []

    for url in RSS_FEEDS:
        feed = feedparser.parse(url)
        for entry in feed.entries:
            headlines.append(entry.title)

    return headlines

def get_headlines(n=1):
    news = fetch_news()
    return news[:n]

# =========================
# Overlay icon
# =========================
def overlay_icon(frame, icon_path, x, y, size=None):
    base = Image.fromarray(frame).convert("RGBA")
    icon = Image.open(icon_path).convert("RGBA")

    if size:
        icon = icon.resize(size)

    datas = icon.getdata()
    new_data = []
    for item in datas:
        if item[0] > 240 and item[1] > 240 and item[2] > 240:
            new_data.append((255, 255, 255, 0))
        else:
            new_data.append(item)
    icon.putdata(new_data)

    base.paste(icon, (x, y), icon)
    return np.array(base.convert("RGB"))


# =========================
# Button handler
# =========================
def on_button():
    global show_text, current_text, mode, speech_ready

    if mode == 0:
        mode = 1
        show_text = False
        speech_ready = False

        headlines = get_headlines(3)

        for text in headlines:
            current_text = text
            print(text)
            
            speech_ready = True
            show_text = True
            speak(text)

    else:
        mode = 0
        show_text = False
        current_text = ""

board.on_button_press(on_button)

# =========================
# Image processing
# =========================
def zoom_center(frame, zoom=1.2):
    h, w, _ = frame.shape
    new_w = int(w / zoom)
    new_h = int(h / zoom)
    x1 = (w - new_w) // 2
    y1 = (h - new_h) // 2
    cropped = frame[y1:y1+new_h, x1:x1+new_w]
    return cv2.resize(cropped, (w, h))

def frame_to_rgb565(frame):
    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    r = (frame[:, :, 0] >> 3).astype('uint16')
    g = (frame[:, :, 1] >> 2).astype('uint16')
    b = (frame[:, :, 2] >> 3).astype('uint16')
    rgb565 = (r << 11) | (g << 5) | b
    high = (rgb565 >> 8).astype('uint8')
    low = (rgb565 & 0xFF).astype('uint8')
    return np.dstack((high, low)).flatten().tolist()

def resize_and_crop(frame):
    h, w, _ = frame.shape
    screen_w = board.LCD_WIDTH
    screen_h = board.LCD_HEIGHT
    aspect = w / h
    screen_aspect = screen_w / screen_h

    if aspect > screen_aspect:
        new_h = screen_h
        new_w = int(new_h * aspect)
        frame = cv2.resize(frame, (new_w, new_h))
        x = (new_w - screen_w) // 2
        frame = frame[:, x:x + screen_w]
    else:
        new_w = screen_w
        new_h = int(new_w / aspect)
        frame = cv2.resize(frame, (new_w, new_h))
        y = (new_h - screen_h) // 2
        frame = frame[y:y + screen_h, :]

    return frame

def split_text(text, max_width=18):
    lines = []
    current = ""
    width = 0

    for ch in text:
        w = 2 if unicodedata.east_asian_width(ch) in "FWA" else 1

        if width + w > max_width:
            lines.append(current)
            current = ch
            width = w
        else:
            current += ch
            width += w

    if current:
        lines.append(current)

    return lines

# =========================
# Draw text
# =========================
def draw_text(frame, text, x, y):
    pil_img = Image.fromarray(frame)
    draw = ImageDraw.Draw(pil_img)

    lines = split_text(text, max_width=18)

    for i, line in enumerate(lines):
        draw.text((x, y + i * 40), line, font=font, fill=(180, 255, 255))

    return np.array(pil_img)

# =========================
# Main loop
# =========================
cap = cv2.VideoCapture(VIDEO_PATH)

if not cap.isOpened():
    print("Failed to open video")
    sys.exit()

try:
    while True:
        ret, frame = cap.read()

        if not ret:
            cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
            continue
        frame = cv2.resize(frame, (160, 120))
        frame = resize_and_crop(frame)
        frame = zoom_center(frame, 1.5)

        if show_text and speech_ready:
            frame = overlay_icon(
                frame,
                "/home/pi/icon_speaker.png",
                75,
                0
            )

            frame = draw_text(frame, current_text, 5, 110)

        rgb565 = frame_to_rgb565(frame)

        board.draw_image(
            0, 0,
            board.LCD_WIDTH,
            board.LCD_HEIGHT,
            rgb565
        )

        time.sleep(0.08)

except KeyboardInterrupt:
    pass

finally:
    cap.release()
    board.cleanup()

ボタンを押すとRSSからニュースを3件取得し、見出しを順番に処理します。取得件数はget_headlines(3)で指定しており、この数値を変更することで取得するニュースの件数を調整できます。取得したテキストはOpen JTalkで音声に変換され、スピーカーから再生されます。表示処理ではOpenCVで動画を再生し、その上にPillowでテキストとアイコンを重ねて描画します。

再度ボタンを押すと表示がリセットされ、ニュースの表示が終了します。その後にもう一度ボタンを押すことで、最新のニュースを再取得できます。つまり、ボタン操作のたびに最新のニュースを取得できる仕様にしました。

ローカル環境でチャットボットを動かす

Raspberry Pi上で音声入力からAIの応答生成、音声出力までを一通り動かすことで、ローカル環境だけで会話できるチャットボットを構築してみました。マイクで入力した音声をテキストに変換し、LLMで応答を生成し、その結果を音声として再生する仕組みです。

今回の構成ではRaspberry Pi 5とAI HAT＋2を使用しています。処理性能の関係からRaspberry Pi Zero 2での動作は現実的ではありません。

認識精度や返答内容はまだ高いとは言えず、意図しない変換や不自然な応答になることもありますが、ローカル環境でここまでの処理が実現できる点は大きな魅力です。今後のモデルや音声認識技術の進化によって、より自然な会話ができるようになることが期待されます。

音声インターフェースが変えるラズパイ活用

以前から音声で操作・応答できるデバイス制作に興味があったものの、なかなかコンパクトなスピーカーが見つからずに二の足を踏んでいました。Whisplay HATはLCD、ボタンまで一体化されており、この1枚で表示と音声の両方を手軽に扱える点が大きな魅力です。

ニュースの取得と音声読み上げを組み合わせることで、実用的なガジェットも無理なく作れました。

今後はエッジAIの進化により、音声インターフェースを活用する場面はさらに増えていくことが予想されます。これまでクラウドに依存していた処理も、ローカルで完結できるケースが増えてきました。Raspberry Piの可能性を広げる一歩として、ぜひ体験してみてはいかがでしょうか。

そんな中で登場したのが、Raspberry Pi 5に取り付けて使うRaspberry Pi AI HAT+ 2です。従来のAI HAT+が画像認識などの推論AIを得意としてきたのに対し、本製品はLLM（大規模言語モデル）やVLM（視覚言語モデル）といった生成AIの実行を主目的に設計されています。

今回、Raspberry Pi Ltdさまより製品の提供をいただき、実機を試用する機会を賜りました。本記事では実際に触ってみて分かった処理時間の感覚や使い勝手を中心に、AI HAT+ 2の可能性に迫ります。

AI HAT+ 2 は Raspberry Pi 5 専用の拡張ボード

近年、クラウドに頼らずデバイス単体でAI処理を行うエッジAIが注目されています。通信遅延やプライバシーの問題を避けられる点から、Raspberry PiにはAI処理を担うプラットフォームとしての期待が高まっています。AI HAT+ 2 は、その流れの中で登場した拡張ボードです。

そぞら

Hailoは、エッジデバイス向けに高性能かつ低消費電力のAIアクセラレータを開発している半導体メーカーです。

従来の AI HAT+ との違い

項目	AI HAT+	AI HAT+ 2
搭載チップ	Hailo-8 / Hailo-8L	Hailo-10H
処理性能	13 TOPS / 26 TOPS	40 TOPS
対応機種	Raspberry Pi 5	Raspberry Pi 5
専用オンボードRAM	なし	8GB 搭載
価格	13 TOPS：$70 26 TOPS：$110	$130
販売ページ	詳細を見る	詳細を見る

AI HAT+ 2はRaspberry Pi 5の上部に取り付け、PCIe（PCI Express）で接続して高速にデータ通信を行う拡張ボードです。

AI HAT+ 2は、従来モデルの単なる上位版ではありません。推論AIを高速に処理するための製品から、生成AIを扱うための製品へと役割が分かれたと考えるのが適切です。

従来のAI HAT+ が推論処理でRaspberry Pi本体のメモリを使用するのに対して、AI HAT+ 2は8GBの専用オンボードRAMを搭載しており、AI処理用のメモリが独立しています。そのため、メモリ競合が起きにくく、AI処理そのものが安定して高速に動作します。

Hailo-10H を搭載した AI アクセラレーター

従来の AI HAT+ が採用していた Hailo-8 / 8L は、画像認識などの推論AIを主用途としていました。一方、AI HAT+ 2 のHailo-10H は、より大規模で複雑なAI処理を扱うことを前提に設計されたチップです。AI HAT+ 2 は、このチップの特性を生かすための構成になっています。

AI HAT+ 2の取り付け

今回、Raspberry Pi本体はRaspberry Pi 5を使用しました。

カメラを使用する場合はこの段階で取り付けておきます。僕はRaspberry Pi Camera Module 3を使用しました。Raspberry Pi Active Cooler（別売り）を装着します。AI HAT+ 2は十分な性能を発揮するため、Active Coolerと一緒に使うことが推奨されています。

付属のネジでスペーサーを取り付け、GPIOピン延長用ヘッダをRaspberry PiのGPIOピンに差し込みます。

AI HAT+ 2本体にチップを冷却するためのヒートシンクを取り付けます。

フラットケーブルをRaspberry Pi側のPCIeポートに入れつつ、GPIOピン延長用ヘッダに差し込みます。

スペーサー部分をネジで固定したら取付完了です。

GPIOピンを使用する場合

キットに付属しているスペーサーを使うと、GPIOピンが隠れてしまい、電子パーツをピンに接続できなくなります。

そこで、別売りのM2.5×11mmのスペーサーに交換することで、GPIOピンの先端を外に出せます。

ただし、この方法ではRaspberry PiとAI HAT+ 2の間隔が狭くなり、Active Coolerが基板に接触するおそれがあります。そのため、Active Coolerは取り外して使用する方が無難です。

セットアップ手順

AI HAT+ 2を使う場合、32GBのmicroSDカードでは途中で容量が足りなくなりました。ファイルサイズの大きいモデルを複数ダウンロードしていくため、余裕を持って使うなら64GB以上のmicroSDカードをおすすめします。

Raspberry Pi OS Trixie を新しくインストールした状態から作業を進めます。別の用途で使っていた環境では、過去の設定などが影響し、AI HAT+ 2 がうまく動作しないことがあるようです。

準備ができたら、Hailo関連のソフトをインストールするための設定を行います。

以下のコマンドは途中で分けず、最初から最後までの行を一度に実行します。aptが参照するソフト配布先の一覧にHailo用のパッケージ配布先が追加されます。

sudo tee /etc/apt/sources.list.d/hailo.sources <<EOF
Types: deb
URIs: https://hailo:chahy5Zo@extranet.raspberrypi.org/hailo
Suites: trixie
Components: main
Signed-By: /usr/share/keyrings/raspberrypi-archive-keyring.pgp
EOF

ここで使っているEOFは、「ここまでを書き込む」という区切りを示す目印です。 <<EOF から始まり、最後に書かれた EOFまでの内容が保存されます。

次に、Raspberry Piに登録した内容を反映し、システムを最新の状態に更新します。

sudo apt update

そぞら

Raspberry Pi ではaptという管理システムを使ってソフトを管理しています。

必要な更新をまとめて適用します。

sudo apt full-upgrade -y

Raspberry Piを再起動し、更新内容を反映させます。

sudo reboot

Dockerのインストール

ブラウザから生成AIを操作するためのWebUI（Webベースの操作画面）を使うには、Dockerのインストールが必須です。WebUIの土台となる Dockerを、Hailoを入れる前に準備しておきます。

そぞら

Dockerは必要なソフトや設定をまとめて用意し、Raspberry Pi OSの違いに影響されずにプログラムを実行するための仕組みです。

まず、環境の競合を防ぐため、すでに入っている Docker 関連パッケージを削除します。

sudo apt remove $(dpkg --get-selections docker.io docker-compose docker-doc podman-docker containerd runc | cut -f1)

Dockerを正しくインストールするため、公式リポジトリを追加します。HTTPS通信に必要な証明書と、データ取得用のツール（curl）をインストールします。

sudo apt install ca-certificates curl

リポジトリの署名キーを保存するためのディレクトリを作成します。

sudo install -m 0755 -d /etc/apt/keyrings

Dockerの公式署名キーをダウンロードして保存します。

sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc

保存した署名キーをシステムから読み取れるように設定します。

sudo chmod a+r /etc/apt/keyrings/docker.asc

Docker の配布先を apt に登録します。

sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF

パッケージ一覧を更新します。

sudo apt update

Docker 本体と関連ツールをインストールします。

sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Docker を起動します。

sudo systemctl start docker

Docker が正しく動作するかを確認します。

sudo docker run hello-world

「Hello from Docker!」を含むメッセージが表示されれば、Dockerのセットアップは完了です。

Hailo-10Hドライバとランタイムの導入

Hailo-10HをOSから利用できるようにします。ドライバを自動で再構築する仕組み（DKMS）を導入します。

sudo apt install dkms

Hailo-10H を使用するためのドライバとランタイム一式をインストールします。

sudo apt install -y hailo-h10-all

そぞら

この処理は7分かかりました。

再起動します。

sudo reboot

Hailo Gen-AI Model Zooのインストール

Hailoが提供するGen-AI Model Zooを導入します。Gen-AI Model ZooはCLIやREST APIから利用できる、事前学習済みの生成AIモデルを集めたライブラリです。

この手順は内容が更新される可能性があるため、公式の手順に従ってインストールします。2026年1月11日時点では以下のコマンドを1行づつ実行してインストールしました。

sudo apt install -y libssl-dev
git clone https://github.com/hailo-ai/hailo_model_zoo_genai.git
cd /home/pi/hailo_model_zoo_genai
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
cmake --build .
mkdir -p ~/.local/bin
cp ./src/apps/server/hailo-ollama ~/.local/bin/
mkdir -p ~/.config/hailo-ollama/
cp ../config/hailo-ollama.json ~/.config/hailo-ollama/
mkdir -p ~/.local/share/hailo-ollama
cp -r ../models/ ~/.local/share/hailo-ollama
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

hailo-ollamaサーバーの起動

LLMのリクエストを受け付けるサーバーを起動します。hailo-ollamaは、Hailo-10H上でLLMやVLMを動かすためのサーバープログラムです。

hailo-ollama

新しいターミナルを開き、次を実行します。使用可能な LLMモデルの一覧が表示されます。

curl --silent http://localhost:8000/hailo/v1/list

上記で表示された使用可能なモデルを以下にまとめました。

私が実際に使ってみたところ、qwen2:1.5bモデルが日本語のやり取りにおいて最も安定しており、回答精度が高いと感じました。他のモデルでは、日本語で質問しても英語で返ってきたり、不自然な日本語になったりすることが多いです。

LLMを動かしてみる

Qwen2 1.5Bモデルをダウンロードします。モデル名は先ほど表示された一覧にあるものへ変更できます。

curl --silent http://localhost:8000/api/pull \
     -H 'Content-Type: application/json' \
     -d '{ "model": "qwen2:1.5b", "stream" : true }'

そぞら

ダウンロードは10分程度かかります。

以下のコマンドを実行すると、LLMに直接質問できます。

curl --silent http://localhost:8000/api/chat \
     -H 'Content-Type: application/json' \
     -d '{"model": "qwen2:1.5b", "messages": [{"role": "user", "content": "Translate to French: The cat is on the table."}]}'

エラーが出ずに結果が返ってくれば、LLMの実行は成功です。

WebUI（ChatGPT風UI）で動かす

WebUIのDockerイメージを取得します。以下のコマンドでChatGPTのような画面を表示するためのプログラム一式をインターネットから取得します。

sudo docker pull ghcr.io/open-webui/open-webui:main

そぞら

このダウンロードも10分以上かかります。

WebUIコンテナを起動します。

sudo docker run -d \
  -e OLLAMA_BASE_URL=http://127.0.0.1:8000 \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --network=host \
  --restart always \
  ghcr.io/open-webui/open-webui:main

初回起動は数分かかります。次のコマンドで起動状況を確認できます。

sudo docker logs open-webui -f

起動完了したら、Raspberry Piのブラウザで次のURLを開きます。

http://127.0.0.1:8080

ChatGPTのような画面が表示されます。

「はじめる」をクリックします。

WebUIの初回起動時には、ローカルで使用するユーザー情報の登録が必要です。これは外部サービスへのサインインではなく、Raspberry Pi上でWebUIを管理するための設定です。

そぞら

登録した情報はRaspberry Pi本体内に保存され、以後はそのユーザーでログインします。

ログインすると、ChatGPTで馴染みのある画面が登場しました。

「あなたは誰ですか」の質問に回答してくれました。回答完了までの時間は7秒でした。

ブログに掲載するスクリーンショットでは、明るい画面のままだと文字やUIが見にくいため、ダークモードに切り替えました。

「Qwen2 1.5B」以外のモデルを使用したい場合は、以下の手順でダウンロードします。

Raspberry Piの再起動後など、次回以降は以下の手順でWebUIを立ち上げます。

PythonからLLMを動かす

ローカルLLMは、Pythonから制御することで電子工作やアプリに組み込みやすくなります。ここでは、PythonからローカルLLMを動かすための基本的な流れを説明します。

PythonからローカルLLMを使う前に、ターミナルからhailo-ollamaを実行しておく必要があります。

以下のコードはPythonからローカルLLMを呼び出し、回答を生成途中から受け取りつつ最終結果もまとめて取得するためのコードです。

import requests
import json
import time

# ローカルで起動しているLLMのAPIエンドポイント
url = "http://localhost:8000/api/chat"

# ユーザーの質問
question = "おすすめの気分転換の方法を教えてください。"

payload = {
    # 使用するLLMモデルを指定
    "model": "qwen2:1.5b",
    # "model": "qwen2.5:1.5b",
    # "model": "llama3.2:1b",
    # "model": "deepseek_r1:1.5b",

    # LLMに送る会話内容を指定
    "messages": [
        {"role": "user", "content": question}
    ]
}

# 質問内容を表示
print(f"質問: {question}\n")

# 思考開始時刻を記録
think_start_time = time.time()
print("思考開始\n")

# LLM APIにPOSTリクエストを送信（ストリーミング）
res = requests.post(url, json=payload, stream=True)

answer_started = False        # 回答開始検知フラグ
final_answer = ""             # 回答全文を格納する変数

for line in res.iter_lines():
    if not line:
        continue

    data = json.loads(line.decode("utf-8"))
    content = data.get("message", {}).get("content", "")

    # 回答が初めて返ってきた瞬間
    if content and not answer_started:
        print("回答開始\n")
        answer_started = True

    # 回答内容を逐次表示しつつ、変数に蓄積
    if content:
        print(content, end="", flush=True)
        final_answer += content

    # 回答終了を検知
    if data.get("done"):
        elapsed = time.time() - think_start_time
        print(f"\n\n処理時間: {elapsed:.2f}秒")
        break

13～16行目で使用するLLMモデルを変更できますが、Raspberry Piにダウンロードしたモデルのみ利用できます。

ローカルLLMに質問を送信し、返ってくる文章をその場で表示しながら、同時に後続処理用として1つの変数に保存する構成になっています。

VLMで画像を説明してもらう

VLMを使うと、画像をもとに状況や特徴を言葉で表現させることができます。保存した写真だけでなくカメラ映像もそのまま渡せるため、精度次第ではリアルタイムの状況に応じた判断や提案にも使えそうです。実際に試しながら、回答の精度や処理にかかる時間を確認していきます。

Hailoデバイスが認識されていることを確認する。

hailortcli scan

以下のようにデバイスアドレスが表示されれば、Hailoデバイスは正しく認識されています。

hailo-apps リポジトリを取得します。

git clone https://github.com/hailo-ai/hailo-apps.git

hailo-appsディレクトリに移動

cd hailo-apps

venvという名前のPython仮想環境を作成します。

python3 -m venv venv --system-site-packages

仮想環境を有効化します。

source venv/bin/activate

PortAudioをOS側にインストールします。これをしないと、PyAudioのビルドでエラーが出てしまいます。

sudo apt update
sudo apt install -y portaudio19-dev

hailo-appsが定義しているGenAI用の追加依存関係をまとめてインストールします。

pip install -e ".[gen-ai]"

モデルのダウンロードや保存時に権限エラーが発生するのを防ぐため、事前にディレクトリを作成し、所有者をpiに変更します。まず、/usr/local/hailoディレクトリを作成します。

sudo mkdir -p /usr/local/hailo

以下を実行して、/usr/local/hailo以下のファイルとディレクトリの所有者をユーザーpiとグループpiに変更します。

sudo chown -R pi:pi /usr/local/hailo

保存した画像を説明させる

simple_vlm_chat を実行します。初回実行時はVLMモデル（Qwen2-VL-2B-Instruct for hailo10h）のダウンロードが行われるため、時間がかかります。

python -m hailo_apps.python.gen_ai_apps.simple_vlm_chat.simple_vlm_chat

このコマンドは、リポジトリ内の doc/images/barcode-example.png という画像を使って、HailoのVision Language Modelを試すデモを実行します。

この画像に対して “How many people in the image?”（この画像には何人の人が写っていますか？） という質問を行います。

「There is one person in the image.（この画像には1人の人物が写っています）」
と回答されました。

VLMモデルには Alibaba Cloud開発のQwen2-VL-2B-Instructが使われており、これが Hailo-10H 向けに最適化された形で提供されています。

「/home/pi/hailo-apps/hailo_apps/python/gen_ai_apps/simple_vlm_chat/simple_vlm_chat.py」のコードの一部を変更することで、渡す画像や質問の変更ができます。

質問を日本語に変えてみました。ざっくりとした回答ですが、赤い帽子と白いマスクが認識されており、悪くない結果です。

カメラの映像を説明させる

以下を実行すると、Raspberry Piカメラの映像についてVLMに質問できます。

python -m hailo_apps.python.gen_ai_apps.vlm_chat.vlm_chat --input rpi

Raspberry Piカメラが起動し、ライブ映像が画面に表示されます。

Enterキーを押すと、その時点の映像が静止画として取得されます。静止した画像に対してターミナル上で質問を入力すると、VLMが画像を解析して回答を返します。

応答が始まるまでにかかる時間は約2秒で、その速さに驚きました。「日本語で答えてください」を質問に含めると日本語で回答が返ってきます。

プログラムをそのまま実行すると、カメラ映像中のオレンジ色の部分が青色に変換されてしまう不具合があったため、「/home/pi/hailo-apps/hailo_apps/python/gen_ai_apps/vlm_chat/vlm_chat.py」の105行目をコメントアウト（行の先頭に#をつけて無効化）し、その下の行に「get_frame = lambda: picam2.capture_array()」を追加しました。

不要な色の変換処理を無効にし、カメラで取得した画像をそのまま使うように変更することで、正しい色で表示されるようになりました。

今回使用したVLMでは、日本語で質問した場合に誤った物体名を返すことがあり、ミカンの映像を「にんにく」と回答する例が見られました。一方、同じ画像に対して英語で質問すると、「orange」と正しく認識され、英語で回答させた方が精度が高いようです。

PythonからVLMを動かす

以下はカメラで取得した画像をHailoのVLMで解析し、内容をテキストとして生成するPythonプログラムです。日本語で回答させると精度が悪いので、英語のVLM回答をローカルLLMのQwen2:1.5bで日本語に翻訳する処理も行います。

以下はカメラで取得した映像をHailoで解析して内容を英語で説明し、その結果を日本語に翻訳して表示するプログラムです。

import subprocess
import time

# エラー回避のための強制開放（前回プロセスの残骸対策）
subprocess.run(
    "sudo fuser -k /dev/video* /dev/media* /dev/v4l-subdev*",
    shell=True,
    stdout=subprocess.DEVNULL,
    stderr=subprocess.DEVNULL
)
time.sleep(1)

import sys
import time
import signal
import os
import cv2
from typing import Optional

from hailo_apps.python.gen_ai_apps.vlm_chat.backend import Backend
from hailo_apps.python.core.common.core import (
    get_standalone_parser,
    handle_list_models_flag,
    resolve_hef_path,
)
from hailo_apps.python.core.common.defines import (
    VLM_CHAT_APP,
    HAILO10H_ARCH,
)
from hailo_platform import VDevice
from hailo_platform.genai import LLM

def translate_to_japanese(text: str) -> str:
    vdevice_llm = VDevice()
    llm = LLM(vdevice_llm, "/home/pi/models/Qwen2-1.5B-Instruct.hef")
    
    prompt = f"以下の英文を自然で正しい日本語の表現で翻訳してください。難しい漢字を使わないこと\n\n{text}"    
    #print(prompt)

    messages = [
        {"role": "user", "content": prompt}
    ]

    result = ""
    for chunk in llm.generate(messages):
        result += chunk

    llm.release()
    return result.replace("<|im_end|>", "").strip()

# =========================
# 設定
# =========================
WAIT_SECONDS = 3  # 撮影までの待機時間

QUESTION = """
Look at the camera image carefully.
Describe what is happening in the image.
Be concise and clear.
Mention the main subject and important details.
"""
MAX_TOKENS = 30
TEMPERATURE = 0.1
SEED = 42

# 画像説明用のシステムプロンプト
SYSTEM_PROMPT = """
You see images from a camera.
You describe the image clearly and objectively.
Focus on what is visible.
"""
INFERENCE_TIMEOUT = 60
WINDOW_NAME = "Captured Frame"

def extract_model_name(hef_path: str) -> str:
    # hefファイル名からモデル名を取得
    return os.path.splitext(os.path.basename(hef_path))[0]

class OneShotVLMApp:
    def __init__(self, hef_path: str):
        self.hef_path = hef_path
        self.backend: Optional[Backend] = None
        self.running = True
        signal.signal(signal.SIGINT, self._signal_handler)

    def _signal_handler(self, sig, frame):
        self.running = False

    def _init_camera(self):
        from picamera2 import Picamera2
        from libcamera import controls

        picam2 = Picamera2()
        config = picam2.create_preview_configuration(
            main={"size": (320, 240), "format": "RGB888"}
        )
        picam2.configure(config)
        picam2.start()
        
        # オートフォーカス設定
        picam2.set_controls({
            "AfMode": controls.AfModeEnum.Continuous,
            "AfSpeed": controls.AfSpeedEnum.Fast,
        })
        return picam2

    def _init_backend(self):
        # Hailo VLMバックエンド初期化
        self.backend = Backend(
            hef_path=self.hef_path,
            max_tokens=MAX_TOKENS,
            temperature=TEMPERATURE,
            seed=SEED,
            system_prompt=SYSTEM_PROMPT,
        )

    def run(self):
        
        picam2 = self._init_camera()
        self._init_backend()

        cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_AUTOSIZE)

        # ---------- ライブ表示 ----------
        while self.running:

            start_time = time.time()
            captured_frame = None
            
            while self.running and captured_frame is None:
                frame = picam2.capture_array()
                rgb_frame = Backend.convert_resize_image(frame)
                bgr_frame = cv2.cvtColor(rgb_frame, cv2.COLOR_RGB2BGR)

                cv2.imshow(WINDOW_NAME, bgr_frame)
                
                # 指定時間経過で撮影
                if (time.time() - start_time) >= WAIT_SECONDS:
                    captured_frame = cv2.cvtColor(rgb_frame, cv2.COLOR_RGB2BGR)
                    break

                if cv2.waitKey(1) & 0xFF == ord("q"):
                    self.running = False
                    break
                
            if not self.running:
                break
        
            loop_start = time.perf_counter()
            t0 = time.perf_counter()
                    
            # VLM推論を実行（画像→テキスト生成）
            result = self.backend.vlm_inference(
                captured_frame,
                QUESTION,
                INFERENCE_TIMEOUT,
            )
            t1 = time.perf_counter()
            inference_time = t1 - t0
            
            answer_text = result.get("answer", "回答を取得できませんでした")

            model_name = extract_model_name(self.hef_path)

            print("\n=====================================\n")
            print("---------- 実行情報 ----------")
            print(f"モデル名   ：{model_name}")
            print(f"VLM推論時間   ：{inference_time:.2f}秒")
            print("------------------------------\n")
                    
            # Hailoデバイス解放
            self.backend.close()
                             
            # 翻訳 -----------------------------------------------
            t2 = time.perf_counter()

            translated_text = translate_to_japanese(answer_text)
            print(translated_text)
            
            t3 = time.perf_counter()
            llm_time = t3 - t2            
                    
            total_time = time.perf_counter() - loop_start # トータル時間計算
                    
            print("\n---------- 処理時間 ----------")
            print(f"LLM推論時間   ：{llm_time:.2f}秒")
            print(f"トータル時間 ：{total_time:.2f}秒")
            print("------------------------------\n")

            self._init_backend()
            time.sleep(1)

            if cv2.waitKey(30) & 0xFF == ord("q"):
                break

if __name__ == "__main__":
    parser = get_standalone_parser()
    handle_list_models_flag(parser, VLM_CHAT_APP)
    options = parser.parse_args()

    hef_path = resolve_hef_path(
        options.hef_path if hasattr(options, "hef_path") else None,
        app_name=VLM_CHAT_APP,
        arch=HAILO10H_ARCH,
    )

    if hef_path is None:
        sys.exit(1)

    OneShotVLMApp(str(hef_path)).run()
    sys.exit(0)

VLMからLLMへ処理を切り替える際に、プロセスの起動やメモリ確保、モデルのロードが行われるため時間がかかります。結果、VLMの推論自体は速くても、全体の処理時間は長くなります。

VLM作例紹介

ローカルVLMを使って、カメラに映った物や人物をひたすら褒めてくれる装置を作りました。使用したのはTouch Display 2の5インチモデルです。カメラを固定できるスタンドは、3Dプリンターで自作しました。

背景で流れている映画マトリックス風の動画は、Pixabayで公開されているものを使用しました。これがあるだけで、近未来感が増します。

英語のVLM回答をローカルLLMで日本語に翻訳させているので、英文と日本語文が交互に流れます。日本語回答までの処理時間は合計で30秒くらいです。

そぞら

繰り返し動かしても、API利用料金を気にせずに済むところが良いですね。

テキストをしゃべらせる

音声合成（TTS）はRaspberry PiのCPUで動作します。PiperはONNX Runtimeという仕組みで動いており、これはCPUやGPU向けに作られているため、Hailo（Raspberry Pi AI HAT+ 2）では動かないようです。

音声を出力させるためにスピーカーが必要です。今回はPiSugar Whisplay Hatを使用します。コンパクトですが、スピーカーとマイクが搭載されています。

以下を1行ずつ実行すると、Whisplay HATのスピーカーとマイクが使える状態になります。

git clone https://github.com/PiSugar/Whisplay.git --depth 1
cd Whisplay/Driver
sudo bash install_wm8960_drive.sh
sudo reboot

Piperで音声を再生する

音声合成エンジンであるPiperのTTSモデルをダウンロードします。

hailo-audio-troubleshoot --install-tts

以下を実行すると、「Hello, how are you today?」というテキストが音声に変換され、スピーカーから再生されます。

python -c "from hailo_apps.python.gen_ai_apps.gen_ai_utils.voice_processing.text_to_speech import TextToSpeechProcessor as T; t=T(); t.queue_text('Hello, how are you today?'); t.wait_for_completion()"

OpenJTalkで日本語音声を再生する

Piperでは日本語対応しているモデルを使用できないようです。そこで、OpenJTalkをインストールすることにしました。

sudo apt install -y open-jtalk open-jtalk-mecab-naist-jdic hts-voice-nitech-jp-atr503-m001

そぞら

OpenJTalkは、名古屋工業大学を中心に開発された、日本語の文章を音声に変換して読み上げるオープンソースの音声合成エンジンです。

OpenJTalkで日本語を音声合成するための辞書と音声モデルをインストールします。

sudo apt install -y open-jtalk-mecab-naist-jdic hts-voice-nitech-jp-atr503-m001

以下で日本語がしゃべれます。「こんにちは」というテキストを音声に変換してWAVファイルに保存し、その音声を再生しています。

echo "こんにちは" | open_jtalk -x /var/lib/mecab/dic/open-jtalk/naist-jdic -m /usr/share/hts-voice/nitech-jp-atr503-m001/nitech_jp_atr503_m001.htsvoice -ow /tmp/test.wav && aplay /tmp/test.wav

女性の声のモデルもインストールしてみます。

wget https://downloads.sourceforge.net/project/mmdagent/MMDAgent_Example/MMDAgent_Example-1.8/MMDAgent_Example-1.8.zip

ZIP形式のファイル「MMDAgent_Example-1.8.zip」を解凍します。

unzip MMDAgent_Example-1.8.zip

meiフォルダをシステムの音声データ用ディレクトリ（/usr/share/hts-voice/）にコピーします。

sudo cp -r MMDAgent_Example-1.8/Voice/mei /usr/share/hts-voice/

Pythonからは以下のように再生します。

import subprocess

def speak_japanese(text, voice="normal", speed=0.8):
    # voiceで選択できる種類
    # "normal"   : 標準
    # "happy"    : 明るい
    # "angry"    : 怒り
    # "sad"      : 悲しい
    # "bashful"  : 照れ
    voice_path = f"/usr/share/hts-voice/mei/mei_{voice}.htsvoice"

    subprocess.run(
        [
            "open_jtalk",
            "-x", "/var/lib/mecab/dic/open-jtalk/naist-jdic",
            "-m", voice_path,
            "-r", str(speed),
            "-ow", "/tmp/test.wav"
        ],
        input=text,
        text=True
    )

    subprocess.run(["aplay", "/tmp/test.wav"])

speak_japanese("こんにちは", "happy")

日本語テキストをOpenJTalkで音声に変換し、/tmp/test.wavに保存してから再生する処理です。読み上げる内容はtextに入れた文字で決まり、voiceで声の種類（normal・happyなど）を選べます。speedで話す速さを調整でき、数値が小さいほどゆっくり、大きいほど速くなります。

最後のspeak_japanese("こんにちは", "happy")は、「こんにちは」を明るい声で再生する指定です。

AIと音声で会話する

hailo-appsのvoice_assistant.pyを使うことで、マイク入力から音声認識・LLM処理・音声出力まで一連の流れを実行できます。

引き続き、PiSugar Whisplay Hatをスピーカー・マイクとして使用します。

hailo-appsディレクトリに移動し、仮想環境venvを有効化。

cd hailo-apps && source venv/bin/activate

voice_assistant.pyを起動します。初回実行時は音声認識モデルのダウンロードが行われるため、10分程度かかります。

python -m hailo_apps.python.gen_ai_apps.voice_assistant.voice_assistant

そぞら

-mは指定したモジュールをパッケージとして実行するためのオプションです。

起動すると待機状態になり、SPACEキーを押すと録音が始まります。話し終わったらもう一度SPACEキーを押すと録音が止まり、その内容がテキストに変換されてAIの応答が表示・音声再生されます。会話の履歴をリセットしたいときはCキー、アプリを終了したいときはQキーを押します。

デフォルトの構成では日本語で会話できないので、以下に変更します。

マイク → 音声認識（日本語） → LLM（qwen2:1.5b） → TTS（open_jtalk）

日本語の音声を認識できるようにする

音声認識を日本語で動作させるための設定を追加します。

/home/pi/hailo-apps/hailo_apps/python/gen_ai_apps/voice_assistant/voice_assistant.pyを開いて、language=”ja”を追加します。

これにより、音声入力が日本語として処理されるようになります。認識精度は決して高くはありませんが、処理の速さには驚きました。

以下の投稿は日本語音声認識をWhisplayHATのボタン操作で動くようにして、結果をLCDに表示させたものです。

LLMを「Qwen2 1.5B」に変更する

認識した音声を回答させる際にデフォルトのモデルでは回答が安定しません。そこで、比較的日本語に強いqwen2:1.5bモデルを使用します。

https://hailo.ai/products/hailo-software/model-explorer/generative-ai/qwen2-1-5b/のページ下部からCompiled Modelをダウンロードします。ファイルサイズが大きいため、かなり時間がかかります。

モデルを保存するフォルダを作成

mkdir -p /home/pi/models

ダウンロードしたモデルを移動

mv /home/pi/ダウンロード/Qwen2-1.5B-Instruct.hef /home/pi/models/

/home/pi/hailo-apps/hailo_apps/python/gen_ai_apps/voice_assistant/voice_assistant.pyを開いて、モデルのパスを変更します。

以下の行にmodel_path = “/home/pi/models/Qwen2-1.5B-Instruct.hef”を追加します。

日本語で回答してもらうために、import文の下に以下を追加します。from hailo_apps.python.core.common.defines import LLM_PROMPT_PREFIX, SHARED_VDEVICE_GROUP_ID, HAILO10H_ARCH, VOICE_ASSISTANT_APP, VOICE_ASSISTANT_MODEL_NAMEの行より下に記述します。

LLM_PROMPT_PREFIX = "日本語で答えてください。\n"

TTSを日本語対応させる

先ほどインストールしたOpenJTalkを使用するために日本語TTS用ファイルを作成します。

nano ~/hailo-apps/hailo_apps/python/gen_ai_apps/voice_assistant/tts_openjtalk.py

tts_openjtalk.pyに、以下のコードを保存します。

import subprocess

def speak_japanese(text, voice="normal", speed=0.8):
    voice_path = f"/usr/share/hts-voice/mei/mei_{voice}.htsvoice"

    subprocess.run(
        [
            "open_jtalk",
            "-x", "/var/lib/mecab/dic/open-jtalk/naist-jdic",
            "-m", voice_path,
            "-r", str(speed),
            "-ow", "/tmp/test.wav"
        ],
        input=text,
        text=True
    )

    subprocess.run(
        ["aplay", "/tmp/test.wav"],
        stdout=subprocess.DEVNULL,
        stderr=subprocess.DEVNULL
    )

voice_assistant.pyの先頭付近に以下を追加

from .tts_openjtalk import speak_japanese

speak_japanese(response_text)を追加

response_text = “”を追加

以下を追加

def collect_callback(chunk: str):
    nonlocal response_text
    response_text += chunk

”token_callback=tts_callback”を”token_callback=collect_callback”に変更

voice_assistant.pyを以下のコマンドで実行します。

python -m hailo_apps.python.gen_ai_apps.voice_assistant.voice_assistant --no-tts

日本語の音声を認識し、日本語で返答を生成し、そのまま音声として再生できるようになりました。

そぞら

一連の流れがすべてRaspberry Pi上で動作しており、実際に声でやり取りできる体験はとても新鮮です。

認識精度や返答内容については、意図しない変換や不自然な応答になることもあります。それでも、この速度で会話のようなやり取りが成立するのは、触っていて面白さを感じられるレベルです。

現時点では英語と比べて日本語の精度が低い傾向があり、初期のChatGPTと似た印象を受けます。今後のモデルや音声認識の進化によって、より自然で正確な会話ができるようになることが期待されます。

以下の投稿はvoice_assistantをWhisplayHATのボタン操作で動くようにして、結果をLCDに表示させたものです。

まとめ

Raspberry Pi AI HAT+ 2を使ってみると、Raspberry Pi上でもLLMの回答が数秒で返ってくることがわかり、エッジAIとしての可能性にワクワクしました。カメラを使った生成AIでは、さまざまなシチュエーションや質問を次々に試してみたくなるような楽しさがあります。API利用料金を気にせず実行できるため、プロンプトや処理の調整を気軽に繰り返せる点も大きな利点です。

一方で、日本語の回答精度が安定しない場面があり、現時点では用途を選びながら使う必要があると感じました。ただ、この点はAI HAT+ 2自体の問題ではなく、モデルやソフトウェアの進化によって改善される余地があり、今後に期待したい部分です。

生成AIを単体で使うだけでなく、電子工作やセンサー、カメラと組み合わせることで、Raspberry Piならではの使い方に広げられそうです。実際にいろいろ試してみて、面白い形になったものがあれば、この記事に追記していきます。

スパイグッズのようなケースを開くと、9インチタッチディスプレイと電子工作で定番のLCDやセンサー、スイッチ類が整然と配置されています。メカ好きな方なら、この外観だけで心をつかまれるはずです。

本記事ではCrowPiの外観の魅力を入口に、実際に動かして感じた楽しさや、初心者でも無理なく始められるかといった点から、高額なこの製品に購入する価値があるのかをレビューしていきます。

公式サイトから購入

Elecrowの公式サイトから購入したCrowPi。注文から到着までは7日間でした。購入したタイミングでは5ドルオフのクーポンが配布されており、送料込みで約36,000円。価格は購入時の為替レートによって前後します。CrowPiはAliExpressでも購入可能です。

購入時にACアダプターの電源プラグの規格を選択します。USプラグは日本のコンセントと形状が同じであるため、そのまま使用できます。

CrowPiの基本情報

CrowPiを手がけているElecrowは、中国・深圳を拠点に、電子工作やRaspberry Pi関連の製品を多く展開しています。

ハードケース型デザインと作り

ハードケース型の筐体に9インチのタッチディスプレイや各種センサー、操作用の基板が組み込まれており、ケースを開いた状態で使う前提の構成になっています。

CrowPiには、Basic KitとAdvanced Kitの2種類があります。私が購入したBasic KitはRaspberry Pi本体が付属しない構成で、すでに本体を持っている人向けです。Advanced KitはRaspberry Pi 5（8GB）が同梱され、その分価格が上がります。

CrowPiで使用できるモデルはRaspberry Pi 5またはRaspberry Pi 4となっています。

搭載されているパーツ

ケース内には9インチのタッチディスプレイをはじめ、カメラ、LEDマトリクス、ブザー、各種ボタン、温度・湿度センサー、距離センサー、モーター制御系、ブレッドボードなどがまとめられています。

そぞら

配線を個別に行わなくても、多くのセンサーや入出力デバイスをすぐ試せるよう設計されているのが特徴です。

モーターなどの一部のパーツはCrowPi側の専用コネクタに挿して使用します。コネクタは向きを間違えて挿せない形状になっているため、接続で迷うことはありません。

本体のほかに、電源アダプターとOSを書き込んだmicroSDカードが付属しており、Raspberry Piを用意すればすぐに起動できます。加えて、モーター類やIRリモコン、RFIDカード、GPIOケーブルなど、Raspberry Piでの入出力や制御を試すための基本パーツがひと通りそろっています。

ユーザーマニュアルは英語ですが、PDF版をダウンロードしてGoogle翻訳を利用すれば、日本語で内容を把握できます。

使用開始までの準備

CrowPiは付属のmicroSDカードをRaspberry Piにセットするだけで、そのまま起動して使い始めることができます。ただし私の環境では、付属カードを使った場合、Webページの表示や VNC操作、パッケージのインストールが非常に遅く感じられました。そこで付属のmicroSDカードにCrowPi専用OSイメージを書き直して起動したところ、動作が明らかに軽くなりました。

そぞら

まずは付属のmicroSDカードでそのまま起動し、重さを感じた場合は、次の手順でOSイメージを書き直してみると良いと思います。

CrowPi専用OSイメージをダウンロード

通常はこの手順を省略し、下のmicroSDカードの取り付けから始めて問題ありません。OSを書き直す場合は、公式サイトからRaspberry Pi 5用イメージのファイルをPCにダウンロードします。

microSDカードにOSイメージを書き込み

PCにmicroSDカードをセットします。カードリーダーもキットに付属していました。

Raspberry Pi Imagerというソフトを使って、microSDにOSイメージを書き込みます。OSの選択画面で、「カスタムイメージを使う」をクリック後して、ダウンロードしたimgファイルを選択します。

OSイメージの書き込みは1時間かかりました。

microSDカードの取り付け

書き込みが完了したら、microSDをRaspberry Piにセットします。今回使用したのはRaspberry Pi 5の8GBモデルです。

Raspberry PiをCrowPiに取り付け

Raspberry Piに電源やHDMIのケーブルを接続して、CrowPiに固定します。ドライバーはキットに付属しています。

キーボードとマウスUSBポートを接続。Basic Kitにはキーボードとマウスが付属しないので、手持ちのものを使用しました。

フラットケーブルはGPIOピンへの取り付け前に、山折りに曲げておくと接続しやすいです。

実際に動かしてみる

ここからは、CrowPiを実際に起動し、基本的な使い方を一通り試していきます。

電源を接続して起動

CrowPiに電源ケーブルを接続すると、Raspberry Piやディスプレイを含むシステムが起動します。CrowPiの電源スイッチはありません。

Raspberry Piが起動すると、ディスプレイにデスクトップ画面が表示され、すぐに操作を始められます。CrowPiを動かすためのソフトウェアは最初から入っており、必要な設定も済んだ状態になっていました。

センサーやモジュールをPythonで操作する

まずはデモコードを動かして、ディスプレイやセンサーなどのデバイスを動かしてみましょう。公式チュートリアルの通りに進めていけば問題ありませんが、以下の手順だとコマンド入力不要で簡単にプログラムを実行できます。

デスクトップの「CrowPi」フォルダを開いて「Examples」を開きます。

「Examples」には各デバイスを動かすための基本的なコードが、あらかじめ保存されています。ファイル名を見れば、どのデバイス用のコードかがわかりようになっています。

マトリクスLEDの動作確認

ここでは例として「matrix_demo.py」（マトリクスLEDのデモコード）を右クリックして、Thonnyで開きます。ThonnyはPython初心者向けに作られた統合開発環境で、コードの編集と実行を一つの画面で行えます。

実行ボタンを押すと、マトリクスLEDに「Hello World」がスクロール表示されました。

使用する部品によっては、以下の物理スイッチの切り替えが必要なものもあります。これは、Raspberry Piが使えるGPIOピンの数に限りがあり、複数の部品で同じピンを共有しているためです。

RFIDリーダーの動作確認

RFIDリーダー（MFRC522）を使うと、カードやタグに書き込まれたIDの読み取りや、文字データの読み書きができます。

デモコードを実行して、RFIDタグをリーダーに近づけます。

読み取りに成功すると、タグのIDがThonnyのShell画面に表示されます。

RFIDは本来、通信や制御などの複雑な処理が必要な仕組みです。しかし、このプログラムでは、そうした面倒な処理をまとめて引き受けてくれる仕組み（ライブラリ）を使っているため、わずか8行のコードでタグの読み取りができ、すぐに動作を確認できます。

RFIDリーダーの活用方法を模索

この仕組みを応用して、RFIDタグをかざすことでCrowPiを使える認証機能を実装してみました。Raspberry Piの起動時にプログラムが自動で立ち上がるように設定し、RFIDタグ認証が成功したときだけデスクトップ画面が開く仕組みです。

待機中の画面には映画「マトリックス」をイメージした動画を表示し、タグをかざすとサイバーパンク調の認証完了画面に切り替わります。このとき、7セグメントLEDやマトリクスLEDも同時に点灯させ、演出を盛り上げます。

Scratchでプログラミングもできる

CrowPiはPythonだけでなく、Scratchを使ったプログラミングにも対応しています。画面上でブロックを組み合わせるだけなので、コードを書く必要はありません。操作は直感的で、プログラミングが初めてでも動かしやすいように設計されています。

ブザーが鳴る、LEDが光るといった動作を、画面を見ながら確認できます。処理の流れを視覚的に理解しやすく、「なぜ動いたのか」が分かりやすい点が特徴です。

一方で、すべてのパーツをScratchで制御できるわけではありません。カメラを使った画像処理や、複雑な制御が必要なパーツは、Scratchでは扱えません。そうした処理はPython向けです。CrowPiは、Scratchで基礎を学び、必要に応じてPythonに進める構成になっています。

マインクラフトでも遊べる

CrowPiではRaspberry Pi向けに用意されたMinecraft Pi Editionを使って遊ぶこともできます。Raspberry Piで快適に動作するよう調整された特別版で、シンプルな構成が特徴です。

「Minecraft Pi」はスタートメニューのゲームから起動できます。

Minecraft Pi EditionはPythonと連携できる点が特徴です。コードを書いてブロックを配置したり、ゲーム内の情報を取得したりできます。まずはゲームとして遊び、興味が出てきたらプログラミングにも踏み込める構成です。

デモコードを応用して遊ぶ

用意されているデモコードをそのまま動かすだけでなく、少し手を加えながら遊んでみます。

そぞら

コードを組み合わせることで、独自の使い方を生み出すのが電子工作の醍醐味です。

ここでは、カメラで顔を検出し、その結果を複数の表示デバイスに同時に出す構成を試しました。

顔認識した結果を表示デバイスで可視化

以下のコマンドをターミナルで実行して、PythonからOpenCVという画像処理ライブラリを使えるようにします。

sudo apt install python3-opencv

OpenCVで顔認識などを行うための 学習済みデータ一式をインストールします。

sudo apt install -y opencv-data

以下のプログラムはカメラ映像から顔を検出し、そのステータスを7セグメントLEDやLEDマトリクス、LCDに表示するものです。

import cv2
import smbus
from ht16k33segment_python import HT16K33Segment
from luma.led_matrix.device import max7219
from luma.core.interface.serial import spi, noop
from luma.core.legacy import show_message
from luma.core.legacy.font import proportional, CP437_FONT
import HD44780MCP
import MCP230XX
import threading
import time

# -----------------------------
# Haar Cascade configuration
# -----------------------------
HAAR_FILE = "/usr/share/opencv4/haarcascades/haarcascade_frontalface_default.xml"
cascade = cv2.CascadeClassifier(HAAR_FILE)

if cascade.empty():
    raise RuntimeError("Failed to load Haar Cascade XML file")

# -----------------------------
# 7-segment display (HT16K33) configuration
# -----------------------------
i2c = smbus.SMBus(1)
led = HT16K33Segment(i2c)
led.set_brightness(10)

# Initialize MCP
i2cAddr = 0x21
MCP = MCP230XX.MCP230XX('MCP23008', i2cAddr)

# Backlight ON
blPin = 7
MCP.set_mode(blPin, 'output')
MCP.output(blPin, True)

# Initialize LCD (16x2)
LCD = HD44780MCP.HD44780(MCP, 1, -1, 2, [3,4,5,6], rows = 2, characters = 16, mode = 0, font = 0)

LCD.clear_display()
LCD.cursor(False)

def display_count(value):
    """Display a count value (0?9999) on the 7-segment LED."""
    value = max(0, min(9999, value))
    bcd = int(str(value), 16)

    led.set_number((bcd & 0xF000) >> 12, 0)
    led.set_number((bcd & 0x0F00) >> 8, 1)
    led.set_number((bcd & 0x00F0) >> 4, 2)
    led.set_number((bcd & 0x000F), 3)
    led.update()
    
def show_detect_message():
    """Show 'detect' message on MAX7219 LED matrix."""
    serial = spi(port=0, device=1, gpio=noop())
    device = max7219(
        serial,
        cascaded=1,
        block_orientation=90,
        rotate=0
    )

    show_message(
        device,
        "detect",
        fill="white",
        font=proportional(CP437_FONT),
        scroll_delay=0.05
    )    

def lcd_show_detect():
    LCD.clear_display()
    LCD.set_cursor(0, 0)
    LCD.display_string("detect!")

# -----------------------------
# Camera configuration
# -----------------------------
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*'MJPG'))
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 800)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 600)

detect_count = 0
prev_detected = False
lcd_active = False

cooldown_frames = 20
cooldown_counter = 0

display_count(detect_count)

# -----------------------------
# Main loop
# -----------------------------
while True:
    ret, frame = cap.read()
    if not ret:
        break

    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    faces = cascade.detectMultiScale(
        gray,
        scaleFactor=1.2,
        minNeighbors=5,
        minSize=(80, 80)
    )

    detected = len(faces) > 0

    # Case 1: detection starts (False -> True) and cooldown is over
    if detected and not prev_detected and cooldown_counter == 0:
        detect_count += 1
        display_count(detect_count)     # 7-segment update
        lcd_show_detect()               # LCD update
        #lcd_active = True
        # Run MAX7219 message in a separate thread
        threading.Thread(
            target=show_detect_message,
            daemon=True
        ).start()            

    # Case 2: detection ends (True -> False), start cooldown
    if not detected and prev_detected:
        cooldown_counter = cooldown_frames
        
    if cooldown_counter == 0 and not detected:
        LCD.clear_display()
        #lcd_active = False        

    # Decrease cooldown after detection has ended
    if cooldown_counter > 0:
        cooldown_counter -= 1

    prev_detected = detected

    for (x, y, w, h) in faces:
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)

    cv2.imshow("Face Detection Counter", frame)

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

# -----------------------------
# Cleanup
# -----------------------------
cap.release()
cv2.destroyAllWindows()
led.clear()
led.update()

コードを実行するとウィンドウにはカメラ映像が映し出され、検出された顔には赤い枠が描画されます。

顔が検出された回数を数え、その数値を7セグメントLEDに表示します。さらに、顔を検出した瞬間には、LCDに「detect!」という文字を表示し、LEDマトリクスには「detect」という文字が流れるようにしています。

同じ顔を連続して検出した場合に回数が増えすぎないよう、少し待ち時間を入れる工夫もしています。

画像処理の結果を複数の表示方法で見せることで、「認識した情報をどう表現するか」まで踏み込めるのが面白い点です。デモコードを組み合わせることで、CrowPiを使った遊び方の幅が広がります。

CrowPiはどんな人向けか

Raspberry Piや電子工作に興味はあるものの、

といった理由で、これまで踏み出せなかった人に適しています。

ケースを開くと、何かすごいことができそうなワクワク感があり、実際に約20種類のパーツを手軽に動かすことができます。Raspberry Piの使い方に慣れるという意味でも有用です。

そぞら

ただし、入門用としては価格が高めなのは気になるところ。

パーツはあらかじめ固定されており、構成を自由に組み替えたり、発展させたりする余地は限られています。そのため、すでに電子工作に慣れていて、自分で部品を選び構成を考えたい人には向きません。

CrowPiはソフトウェアの設計やマニュアルのわかりやすさも含め、全体としてよく作り込まれている印象を受けました。コンセプトに惹かれる部分があれば、自分の用途に合うかを考えたうえで検討してみるとよいでしょう。

5インチと7インチの2種類があり、いずれも背面にRaspberry Piの基板を取り付けて使用します。

本記事では両モデルをレビューしますが、7インチモデルはRaspberry Pi財団から製品を提供いただいています。

記事の後半では、このディスプレイを活用した情報表示用サイネージの作成方法も紹介しています。

Touch Display 2のスペック

Touch Display 2には5インチと7インチの2種類がありますが、どちらも画面サイズ以外の仕様や使い方はほぼ同じです。

5インチと7インチの両モデルに、1280 x 720のフルカラー静電容量式タッチスクリーンを採用しています。前モデルの800 x 480と比較して、解像度が大幅に向上しました。

5インチモデルは画面が小さいため、タッチ操作では細かなUIが押しにくく感じることがあります。快適に操作したいなら7インチモデルが適しています。マウス併用で、コンパクトさやコスパを重視するなら5インチモデルが便利です。

開封

ディスプレイ本体の重さは5インチが143g、7インチが248gです。バッテリーは内蔵していません。

裏面にRaspberry Piを取り付けます。Zeroシリーズ以外でDSIポートを持つ全モデルに対応しているようです。

ディスプレイ以外の付属品は以下の通りです。

FFC（Flat Flexible Cable）は２種類付いています。これはRaspberry Piのモデルに合わせた接続を可能にするためです。Raspberry Pi 5では22ピンから15ピンに変換するFFCを使用。他のモデルには15ピン同士のFFCを使用します。

準備

今回はRaspberry Pi 5をTouch Display 2に取り付けて使用しました。

Raspberry Pi OSは、2024/11/6時点で最新のバージョンを使用しています。

OSのインストール方法の詳細は、OSインストールから初期設定まで｜ラズベリーパイ セットアップ手順のすべてをご覧ください。新たにOSのインストールをする場合は、Wi-Fi接続などの初期設定を済ませておきます。

取り付け

電源コネクタをディスプレイの裏面側に差し込みます。

付属のFFCをディスプレイに接続します。Raspberry Pi 5 用は両端の幅が異なるタイプを使います。両端の幅が同じタイプは Raspberry Pi 5 以外のモデル用です。

Raspberry Pi 5を取り付けます。このとき、microSDカードは先にセットしておくと安心です。ディスプレイに固定すると出し入れがしづらくなります。

FFCをラズパイ側に取り付けます。DSIポートが2か所ありますが、どちらに差し込んでも使用できました。

電源ケーブルをRaspberry Piの5VとGNDのピンに差し込みます。ディスプレイはこのピンから給電されるため、追加の電源は必要ありません。

Touch Display 2自体は、わずか15mmの厚みですが、ラズパイ本体を取り付けると32ｍｍになりました。

公式パーツであるアクティブクーラーも取り付けて使用できます。

取り付けが完了し、USB電源ケーブルを差し込んだ状態。基板むき出しの状態で使用するのは心もとないので、できれば保護カバーが欲しいところです。

試しにRaspberry Pi 5用公式ケースを取り付けてみました。別途「8x M2.5ネジ」を4本用意すれば、ラズパイ本体とケースを一緒に固定できます。

ケースのフタ部分はフラットケーブルがあり、取り付け不可でした。

デスクにおいて使用する際に安定感が増します。ただ、ケースの厚みがやや気になります。

ケース部分を握ることで、手持ちで使いやすくなりましたが、見た目はあまり洗練されていません。

Touch Display 2（7インチ）に対応したRaspberry Pi 5専用ケースも市販されているので、あわせて検討すると良いでしょう。

起動

ソフトウェアの特別な設定は必要ありません。アダプターからRaspberry Piに給電すれば、自動的に画面が表示され、タッチパネルもそのまま利用できます。

画面の向きを変更する

画面の向きは設定により変更できます。メニューを開き「設定」、「Screen Configuration」の順にタップします。

「Screens」をタップします。

「DSI-2」、「向き」の順にタップし、向きを選択します。

「Apply」をタップします。

10秒以内にOKをタップすると、画面の向きが切り替わります。

「Brightness」の設定では、画面の明るさの変更も可能です。

文字入力も可能

文字入力ではスクリーンキーボードを利用可能です。スクリーンキーボードを表示するには、画面右上のキーボードのアイコンをタップします。

スクリーンを消す場合も、同じく画面右上のキーボードのアイコンをタップします。

キーボードが表示されない場合は以下のコマンドを実行して、画面上で使えるスクリーンキーボード「squeekboard」をインストールします。

sudo apt install squeekboard

「fcitx5」と「mozc」をインストールすれば、ローマ字入力に切り替え可能です。

Raspberry Piで日本語入力の設定をする方法は、https://sozorablog.com/raspberrypi_initial_setting/#toc14で解説しています。

【活用事例】インフォメーションパネル

Touch Display 2の画面に時計、カレンダー、天気、ニュースを表示するインフォメーションパネルを作成しました。画面中央にレーダー風のアニメーションを配置し、文字の色もレーダーに合わせて統一しています。また常時表示しておけるようにスタンドも自作しています。

ここからは制作の過程を紹介していきます。

スタンドの作成

3Dプリンターで自分好みのデザインのスタンドを作成します。まずはCADソフトでスタンドを設計します。

プリント時間は約3時間。Touch Display 2に付属のM2.5ネジ4本で固定する仕様にしました。寸法の調整をするため、2回作り直しています。

イメージ通りに仕上がりました。

前面から電源のケーブルが目立たないように、L字型のアダプターを使用しました。

ソフトウェアの準備

MagicMirror²という情報表示が可能なスマートミラーを作成するためのオープンソースソフトウェアを使用します。MagicMirror²を使えば、ミラーがなくてもクールな見た目のディスプレイ表示を作れます。

設定操作はタッチパネルでは難しいため、VNC接続やマウス・キーボードを使って行います。

MagicMirror²のインストール

ターミナルを開きます。

以下のコマンドを順に実行していきます。

curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -

sudo apt install -y nodejs

git clone https://github.com/MichMich/MagicMirror

cd MagicMirror/

npm run install-mm

設定ファイルの作成

config.jsを作成します。

nano config/config.js

nanoエディタが開いたら、以下のコードを貼り付けて保存します。

let config = {
	address: "localhost",	// Address to listen on, can be:
							// - "localhost", "127.0.0.1", "::1" to listen on loopback interface
							// - another specific IPv4/6 to listen on a specific interface
							// - "0.0.0.0", "::" to listen on any interface
							// Default, when address config is left out or empty, is "localhost"
	port: 8080,
	basePath: "/",	// The URL path where MagicMirrorﾂｲ is hosted. If you are using a Reverse proxy
									// you must set the sub path here. basePath must end with a /
	ipWhitelist: ["127.0.0.1", "::ffff:127.0.0.1", "::1"],	// Set [] to allow all IP addresses
									// or add a specific IPv4 of 192.168.1.5 :
									// ["127.0.0.1", "::ffff:127.0.0.1", "::1", "::ffff:192.168.1.5"],
									// or IPv4 range of 192.168.3.0 --> 192.168.3.15 use CIDR format :
									// ["127.0.0.1", "::ffff:127.0.0.1", "::1", "::ffff:192.168.3.0/28"],

	useHttps: false,			// Support HTTPS or not, default "false" will use HTTP
	httpsPrivateKey: "",	// HTTPS private key path, only require when useHttps is true
	httpsCertificate: "",	// HTTPS Certificate path, only require when useHttps is true

	language: "en",
	locale: "en-US",
	logLevel: ["INFO", "LOG", "WARN", "ERROR"], // Add "DEBUG" for even more logging
	timeFormat: 24,
	units: "metric",

	modules: [
		{
			module: "alert",
		},
		{
			module: "updatenotification",
			position: "top_bar"
		},
		{
			module: "clock",
			position: "top_left"
		},
		{
			module: "calendar",
			header: "Japanese Holidays",
			position: "top_left",
			config: {
				calendars: [
					{
						fetchInterval: 7 * 24 * 60 * 60 * 1000,
						symbol: "calendar-check",
						url: "https://www.google.com/calendar/ical/ja.japanese%23holiday%40group.v.calendar.google.com/public/basic.ics"
					}
				]
			}
		},
		{
			module: "MMM-VideoLoop",
			position: "middle_center", // Central position
			config: {
				videoPath: "http://localhost:8081/radar.mp4"
			}
		},
		{
			module: "weather",
			position: "top_right",
			config: {
				weatherProvider: "openmeteo",
				type: "current",
				lat: 35.6895,
				lon: 139.6917
			}
		},
		{
			module: "weather",
			position: "top_right",
			header: "Weather Forecast",
			config: {
				weatherProvider: "openmeteo",
				type: "forecast",
				lat: 35.6895,
				lon: 139.6917
			}
		},
		{
			module: "newsfeed",
			position: "bottom_bar",
			config: {
				feeds: [
					{
						title: "NHK news",
						url: "https://www3.nhk.or.jp/rss/news/cat0.xml"
					}
				],
				showSourceTitle: true,
				showPublishDate: true,
				broadcastNewsFeeds: true,
				broadcastNewsUpdates: true
			}
		},
	]
};

/*************** DO NOT EDIT THE LINE BELOW ***************/
if (typeof module !== "undefined") { module.exports = config; }

nanoエディタでファイルを保存して終了するには、Ctrl + Oを押して保存し、Enterを押してから、Ctrl + Xで終了します。

このコードは、MagicMirrorの設定ファイルです。MagicMirrorではモジュールという独立した機能を使用して表示内容を設定します。このモジュールごとに表示内容を設定でき、必要な情報を自由にカスタマイズして表示できます。

今回の表示内容は以下の通りです。

レーダーアニメーション表示用モジュールを作成する

レーダーの動画をループ再生するために、MMM-VideoLoopという名前のモジュールを作成します。

MagicMirrorのモジュールディレクトリに移動します。

cd modules

MMM-VideoLoopフォルダを作成します。

mkdir MMM-VideoLoop

MMM-VideoLoopフォルダに移動します。

cd MMM-VideoLoop

MMM-VideoLoop.jsファイルを作成して編集モードに入ります。

nano MMM-VideoLoop.js

nanoエディタが開いたら、以下のコードを貼り付けます。

Module.register("MMM-VideoLoop", {
    defaults: {
        videoPath: "http://localhost:8081/radar.mp4" //
    },

    getDom: function() {
        const wrapper = document.createElement("div");
        wrapper.style.textAlign = "center";

        const video = document.createElement("video");
        video.src = this.config.videoPath;
        video.autoplay = true;
        video.loop = true;
        video.muted = true;
        video.style.width = "100%";
        video.style.maxWidth = "800px";

        video.onerror = () => {
            wrapper.innerText = "Failed to load video. Please check the path.";
            console.error("Failed to load video:", this.config.videoPath);
        };

        wrapper.appendChild(video);
        return wrapper;
    }
});

このコードでは「MMM-VideoLoop」モジュールを定義し、指定されたURLから動画をループ再生する設定をしています。videoPathプロパティで動画のURLを設定し、getDom関数で動画要素を作成、表示します。

デザインを調整する

custom.cssを作成して、テキストの色や表示位置など、デザインの設定をします。

cd

nano /home/pi/MagicMirror/css/custom.css

nanoエディタが開いたら、以下のコードを貼り付けて保存します。

/* Set all text to a more greenish yellow-green */
* {
    color: #7FFF00 !important; /* Chartreuse */
}

/* Adjust text for the weather module (specify further if necessary) */
.weather .bright,
.weather .dimmed,
.weather .normal,
.weather .small,
.weather .large {
    color: #7FFF00 !important;
}

/* Apply to other modules if text remains */
.clock .bright,
.clock .dimmed,
.calendar .event,
.compliments .compliment,
.newsfeed .newsfeed-title,
.newsfeed .newsfeed-source {
    color: #7FFF00 !important;
}
/* MMM-VideoLoop module to be placed at the back */
.MMM-VideoLoop {
    position: absolute;
    top: -5px;
    left: -110px;
    width: 120%;
    height: auto;
    z-index: 0; /* Set a low z-index to place it behind */
    pointer-events: none; /* Make sure it doesn't interfere with clicks */
    transform: scale(1.2);
}

/* Ensure other modules are above */
.module {
    position: relative;
    z-index: 10; /* Set higher z-index for other modules */
}
.calendar {
    position: relative !important;
    z-index: 120 !important;

このCSSコードは、MagicMirrorの画面デザインを調整するための設定です。まず、全体のテキスト色を黄緑色（#7FFF00）に変更します。次に、天気やカレンダー、ニュースフィードなど特定のモジュールのテキスト色も同じ黄緑色に設定しています。また、動画モジュール（MMM-VideoLoop）は画面の最背面に配置し、他のモジュールがその上に表示されるようにz-indexを調整しています。

レーダー動画をダウンロードする

回転するレーダーの動画は、Pixabayで公開されているものをダウンロードして使用します。Pixabayは著作権フリーの画像、動画、音声などを共有するサイトです。

動画のサイズは640×360を選択します。

ダウンロードしたら、ファイル名を「radar.mp4」に変更しておきます。名前が違うと表示できません。

radar.mp4を/home/pi/MagicMirrorフォルダに移動します。

表示を起動する

MagicMirrorディレクトリに移動します。

cd /home/pi/MagicMirror

Pythonの簡易サーバーを立ち上げて、MagicMirrorに動画（radar.mp4）を提供します。最初はファイルのパスを直接指定して読み込もうとしましたが、うまくいきませんでした。

python3 -m http.server 8081

別のターミナルを開き、MagicMirrorを起動します。

cd MagicMirror/ && npm run start

以下のように表示が開始されれば成功です。

表示を中断するには、CtrlキーとQキーを同時に押します。

まとめ

Touch Display 2は簡単に取り付けられ、特別な設定不要ですぐに使用を始められる手軽さが魅力です。7インチモデルならデスクトップ画面のタッチ操作が快適に行える一方、Raspberry Piのコンパクトさを損なうこともありません。5インチモデルだと、スタートメニューを開く際やアプリを閉じる✕ボタンの操作など細かいUI操作が難しく感じました。

また、Raspberry Piがむき出しの状態になるため、保護用のカバーやスタンドを自作する必要がある点はデメリットです。タブレットのような使い心地を期待して購入すると、少し物足りなく感じるかもしれません。ただ、カスタマイズの自由度が広がる点においては、これもまたRaspberry Piらしさと言えるのかもしれません。

以下の投稿では、Touch Display 2を使った3Dホログラム投影装置を紹介しています。

透明なプラスチック板（ダイソーで購入）を切り出して台形のパーツを4枚用意し、テープで組み立てるだけで、ディスプレイ上の映像が立体的に浮かび上がって見えます。

そんな中、SunFounderから犬型ロボットキット「PiDog」が新登場しました。PiDogは、Raspberry Piの可能性を広げ、未来のペットとして日常に新たな楽しさをもたらします。革新を追求するSunFounderが生み出した「新しい相棒」に注目です。

公式のプロモーション動画はこちらからご覧いただけます。

PiDogを開封する

箱は意外とコンパクトに感じました。シンプルで洗練されたデザインに気分が高まります。

パッケージ内容

部品一式です。一見すると量が少ないように見えますが、小さな部品が多く含まれているため、総数ではかなりのボリュームです。ドライバーが2種類とレンチも付いています。

制御に関する主要な部品は次の通りです。名称をクリックすると公式の解説ページをご覧いただけます。

取扱説明書は組み立て方についてのもので、表裏に印刷されています。基本的には英語表記ですが、組み立てるうえで間違いやすいポイントは日本語で書かれているため、理解しやすいです。

Raspberry Piの設定方法やPiDogの動かし方については、オンラインでマニュアルが提供されています。日本語版マニュアルもあるので、大変便利です。

Raspberry Piは別売り

PiDogを制御するためのRaspberry Piは、キットに付属していません。使用できるモデルは次の通りです。

PiDogはカメラが搭載されており、物体を追跡できます。スムーズな動作を求める方は、Raspberry Pi 4 Model B　8GBといった高性能なモデルを選ぶことをおすすめします。

僕はRaspberry Pi 4の2GBモデルを使用しました。

バッテリー付属

このタイプのロボットキットはバッテリー別売りのものが多いですが、PiDogにはバッテリーが付属しています。USB Type-Cでの充電可能です。

組み立て後でもバッテリーを外さずに、そのまま充電可能です。充電中は赤いLEDが点灯し、充電が完了するとLEDが消えます。

Raspberry Piの準備をする

Bullseye 32-bit Desktop版のRaspberry Pi OSを使用しました。最新のOSであるBookwormには対応していないようです。

言語設定を英語にする

システムの言語設定は英語にしておくことが必要です。日本語に設定されていると、音声アンプの設定に問題が生じ、PiDogが正常に動作しなくなることがあります。

VNC環境を用意する

マニュアルには記載されていませんが、Raspberry PiはVNCで操作するのが圧倒的に便利です。VNC（Virtual Network Computing）はネットワークを通じて別のコンピュータにアクセスし、そのデスクトップ画面を呼び出して操作する技術です。これにより、Pidog（Raspberry Pi）にマウスやキーボード、ディスプレイを接続することなく操作できるようになります。

PiDogの組み立て

まずは音方位センサーを取り付けます。このセンサーは音がしている方向を検出して、0から359の数値で出力します。

音方位センサーの上にRaspberry Pi を取り付けます。microSDは組み立て後でも交換可能です。

メインの基板です。裏側にはスピーカーが付いており、PiDogの鳴き声はここから出力されます。

メインの基板はHATと呼ばれる形状のコネクターで、Raspberry Piの40ピンに直接挿入します。

組み立ての途中でラズパイを起動する

Raspberry Piの電源を入れて、ソフトウェアの準備をします。これは、サーボモーターを適切な角度に設定し取り付けるためです。サーボモーターには稼働範囲が決まっており、正確な角度での取り付けが行われない場合、ロボットの正常な動作が妨げられることがあります。

オンラインマニュアルの手順に沿って、Raspberry Piへソフトウェアをインストールします。

servo_zeroing.pyというプログラムを実行した状態でサーボモーターをピンに接続します。すると、サーボモーターが基準位置に動きます。この状態でサーボモーターを固定していきます。

楽ちんなリベット止め

強度が不要な接合部分は、プラスチック製のリベットで止める仕様になっています。手で簡単に押し込むだけでカチッとはまり、作業がスムーズに進みます。

完成

組み立てにかかった時間は4時間。しかし、その時間を忘れさせるほど、完成した瞬間の感動と達成感は格別でした。犬型ロボットの愛らしいデザインと、自分で組み立てたという事実が相まって、特別な愛着が生まれてきます。

組み立ての様子はこちらの公式動画で確認できます。

PiDogを動かしてみる

ここからはPiDogを動かしていきます。その機能性と心を引きつけるアクションをご覧ください。

サーボモーターの校正

完成したPiDogをすぐに動かしたいところですが、まずはサーボモーターの校正が必要です。この作業によって、サーボモーターの基準角度を細かく調整します。校正を怠ると、PiDogの歩行が不安定になるなどの問題が生じることがあります。

校正用のプログラムを動かして、12個のサーボモーターをひとつずつ調整していきます。校正時はキットに付属している直角のゲージを使用します。

13種類のサンプルプログラム

校正が終わったら、いよいよPiDogで遊んでいきます。前項でインストールした「/home/pi/pidog/examples」のフォルダー内には13種類のサンプルプログラムがあります。

サンプルプログラムの種類は次の通りです。

	プロジェクト名	動作	詳細
	Wake Up	伸びをする、体をねじる、座る、尻尾を振る、ハアハアする。	詳細を見る
	Function Demonstration	15種類の動作と12種類のサウンドを実行できる	詳細を見る
	Patrol	超音波センサーで距離を測定しながら前進	詳細を見る
	Response	PiDogに接近すると警戒して吠える。頭をなでると喜ぶ	詳細を見る
	Rest	音に反応して立ち上がり、キョロキョロする	詳細を見る
	Be Picked Up	PiDogを持ち上げると、スーパーマンのポーズをする	詳細を見る
	Face Track	顔を認識して頭を動かす。音のする方向に頭を向ける	詳細を見る
	Push Up	腕立て伏せをする	詳細を見る
	Howling	遠吠えする	詳細を見る
	Balance	地面の角度に応じてバランスを取る	詳細を見る
	Play PiDog with Keyboard	キーボードでPiDogを操作する	詳細を見る
	Play PiDog with APP	スマートフォンやタブレットからPiDogを操作する	詳細を見る
	Ball Track	赤い物体を追いかけて歩く	詳細を見る

プログラムの実行方法

ターミナル画面を開いて、サンプルプログラムが保存してあるフォルダに移動します。

cd ~/pidog/examples

「sudo python3 1_wake_up.py」のようにコマンドを打ち込むと、プログラムが実行されます。

sudo python3 1_wake_up.py

以下は「Ball Track」を実行した様子です。赤い物体を発見すると、その方向に顔を向けて歩きだします。歩く方向もゆっくりと変わっていきます。

以下は「Play PiDog with Keyboard」というプログラムでscratchという動作をさせた様子です。

同じく「Play PiDog with Keyboard」でtrotを実行した様子です。通常の歩行はゆっくりですが、軽快に走ることもできます。

Push Up（腕立て伏せ）をしている姿もかわいいです。

スマホやタブレットから操作する

SunFounder Controllerという専用アプリをスマホやタブレットにインストールして、PiDogを操作できます。SunFounder ControllerはAPP Store（iOS）またはGoogle Play（Android）からインストール可能です。

PiDogでプログラムを起動後、SunFounder Controllerを開くと、自動でネットワーク上からPiDogを探してくれます。

カメラの映像を通じてPiDogを操作することができます。歩いたり頭部を動かしたりすることで視界が変化します。まるでPiDogの目線で周囲を見ているかのような体験が可能です。インターフェイスは洗練されており非常にスタイリッシュな印象を与えます。

コントローラーを使えば、歩行、頭の動き、座る、立つ、伏せる、尻尾を振る、頭をかくなどのさまざまな操作が行えます。個人的には、サンプルプログラムの中で「Play PiDog with APP」が一番気に入っています。

自分でもプログラミングできる

PiDogはサンプルプログラムだけでも十分に楽しむことができます。しかし、ラズパイ経験者であれば独自のプログラムを作って動かしたくなるものです。PiDogのオンラインマニュアルには、プログラミングの手引きとなるチュートリアルが用意されており、プログラム作成に役立ちます。

「お手」のプログラムを作ってみる

以下のプログラムはPiDogを操作し、「お手」の動作を実行するためのものです。上述したチュートリアルを参考に作成しました。基本的にはプリセットされた動作を呼び出して、PiDogを動かします。

from pidog import Pidog  # PiDogライブラリからPidogをインポート
from preset_actions import hand_shake  # hand_shakeアクションをインポート
import time

# カスタムの初期化サーボ角度でPiDogのインスタンスを作成
# 初期化することで、PiDogが特定の姿勢で起動します
my_dog = Pidog()

try:
    my_dog.do_action("sit", speed=60)  # PiDogに座る動作を指示（速度は60）
    
    time.sleep(1)  # 次の動作まで1秒待機
    
    hand_shake(my_dog)  # PiDogに「お手！」の動作を実行させる
    
    my_dog.do_action("sit", speed=60)  # 再び座る動作を指示（速度は60）
    
    time.sleep(1)  # 次の動作まで1秒待機
    

# キーボード割り込み（Ctrl + C）があった場合の処理
except KeyboardInterrupt:
    pass  # 特に何もしない

# その他の例外が発生した場合の処理
except Exception as e:
    print(f"\033[31mERROR: {e}\033[m")  # エラーメッセージを表示

# プログラム終了時に実行される処理
finally:
    print("closing ...")  # 終了することを表示
    my_dog.close()  # PiDogの接続を適切に閉じる

最初にPiDogを起動し、その後、速度を60に設定して座る動作を指示します。1秒待ってから、「お手」という動作を実行し、再び座る動作を指示します。最後にPiDogの接続を閉じて、プログラムが終了します。

プログラムはサンプルプログラムと同じフォルダーの「/home/pi/pidog/examples」に保存して実行します。

音声で「お手」をさせてみる

最近のロボットは音声での操作が主流になってきています。マイクを接続すればRaspberry Piでも音声認識ができます。そこで、声を出して「お手」と指示してPiDogを動かしてみることにしましょう。

音声認識を利用するには、別売りのUSBマイクを使います。上記のようなコンパクトなマイクを選ぶと良いでしょう。千円以下で販売されています。

音声認識エンジンをインストールする

音声認識には「Julius（ジュリアス）」を使用します。Juliusはリアルタイムで日本語音声認識を行う無料のソフトウェアです。

必要なパッケージをインストール

ターミナルを開いて、以下のコマンドを1行ずつ実行していきます。

sudo apt update
sudo apt upgrade
sudo apt install build-essential zlib1g-dev libsdl2-dev libasound2-dev

Juliusのインストール

git clone https://github.com/julius-speech/julius.git
cd julius
wget -O support/config.guess 'http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD'
wget -O support/config.sub 'http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD'
cd jcontrol
wget -O config.guess 'http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD'
wget -O config.sub 'http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD'
cd ..
./configure --enable-words-int
make -j4

日本語モデルのダウンロード

git clone https://github.com/julius-speech/dictation-kit.git

「dictation-kit」のフォルダーに移動します。

cd dictation-kit

USBマイクの設定

以下のコマンドでUSBマイクが認識されているか確認します。

arecord -l

マイクのカード番号とデバイス番号を読み取ります。「card 4」はシステムが認識しているサウンドカードの番号です。「USB PnP Sound Device」 は、デバイスの名前です。これはUSBマイクを指しています。「device 0」 はそのサウンドカード上のデバイス番号を示しています。

マイクの音量を最大に設定します。音量が小さいと、うまく言葉の認識ができなくなります。

Juliusの起動

Juliusを起動して、音声認識ができることを確認します。以下のコマンドでJuliusが起動します。

/home/pi/julius/julius/julius -C main.jconf -C am-dnn.jconf -demo -dnnconf julius.dnnconf

以下の画面になれば起動成功です。マイクに向かって話しかけると、認識結果が表示されます。

認識精度はそれほど高くないようです。「お手」という言葉を「大手」と誤認識してしまいました。しかし、PiDogを操作する上では大きな支障はありません。「大手」と認識された際にPiDogを動かすプログラムを設定すれば問題なく対応できます。

Juliusをモジュールモードで起動

Juliusをモジュールモードで起動すると、Pythonプログラムを介して音声認識結果をテキストで取得できます。これにより、得られたテキストを用いてPiDogの制御を行うことが可能になります。

まず、Juliusの設定ファイルである 「main.jconf」 を編集します。これらの手順を踏まないとエラーが発生して、動作しませんでした。

nano main.jconf

-fvad オプションを探し、その行をコメントアウトします。コメントアウトするには、行の先頭に # 記号を追加します。

「-h model/phone_m/jnas-tri-3k16-gid.hmmdefs」を追加する。

必要に応じて「cd /home/pi/julius/dictation-kit」で「/home/pi/julius/dictation-kit」に移動してください。

以下のコマンドを実行することにより、Juliusをモジュールモードで起動します。

/home/pi/julius/julius/julius -C main.jconf -C am-dnn.jconf -dnnconf julius.dnnconf -module

以下の画面になれば、起動成功です。

この状態のまま、次の手順に進んでいきます。

Pythonプログラムからテキストを取得

Juliusをモジュールモードで、起動した状態で以下のコードを実行します。

import socket
import sys

# Juliusサーバの設定
host = "localhost"
port = 10500

# ソケットの作成と接続
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port))

res = ''
while True:
    # 音声認識の区切りである「改行+.」がくるまで待つ
    while (res.find('\n.') == -1):
        # Juliusから取得した値を格納していく
        res += sock.recv(1024).decode('utf-8')

    word = ''
    for line in res.split('\n'):
        # Juliusから取得した値から認識文字列の行を探す
        index = line.find('WORD=')
        # 認識文字列があったら...
        if index != -1:
            # 認識文字列部分だけを抜き取る
            line = line[index + 6 : line.find('"', index + 6)]
            # 文字列の開始記号以外を格納していく
            if line != '[s]':
                word = word + line
                print('word：' + word)

        # 特定の文字列を認識した時の処理
        if word == 'お手'or word == '大手':
            print("発見")

        res = ''

このコードは、Julius音声認識エンジンからリアルタイムでデータを受信し、認識された単語を処理するためのPythonスクリプトです。ローカルサーバー上のJuliusからデータを受け取り、認識された各単語を抽出して表示します。特定の単語（「お手」または「大手」）が認識されると、「発見」と出力します。

本番用プログラム

import socket
import sys
from pidog import Pidog  # PiDogライブラリからPidogをインポート
from preset_actions import hand_shake  # hand_shakeアクションをインポート
import time

# Juliusサーバの設定
host = "localhost"
port = 10500

# ソケットの作成と接続
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port))

# カスタムの初期化サーボ角度でPiDogのインスタンスを作成
# 初期化することで、PiDogが特定の姿勢で起動します
my_dog = Pidog()
my_dog.do_action("sit", speed=60)  # PiDogに座る動作を指示（速度は60）
my_dog.head_move([[0, 0, -20]], roll_comp=0, pitch_comp=0, immediately=True, speed=50)

res = ''
while True:
    # 音声認識の区切りである「改行+.」がくるまで待つ
    while (res.find('\n.') == -1):
        # Juliusから取得した値を格納していく
        res += sock.recv(1024).decode('utf-8')

    word = ''
    for line in res.split('\n'):
        # Juliusから取得した値から認識文字列の行を探す
        index = line.find('WORD=')
        # 認識文字列があったら...
        if index != -1:
            # 認識文字列部分だけを抜き取る
            line = line[index + 6 : line.find('"', index + 6)]
            # 文字列の開始記号以外を格納していく
            if line != '[s]':
                word = word + line
                print('word：' + word)

        # 文字列を認識したらPiDogを動かす
        if word == 'お手'or word == '大手':
            my_dog.rgb_strip.set_mode('breath', 'pink', bps=1)
            my_dog.head_move([[-40, 0, -30]], roll_comp=0, pitch_comp=0, immediately=True, speed=50)
            hand_shake(my_dog)  # PiDogに「お手！」の動作を実行させる
    
            my_dog.do_action("sit", speed=60)  # 再び座る動作を指示（速度は60）
            my_dog.head_move([[0, 0, -20]], roll_comp=0, pitch_comp=0, immediately=True, speed=50)
            my_dog.rgb_strip.set_mode('breath', 'white', bps=0.5)

        res = ''

このコードは前述したものに、PiDogを操作するためのスクリプトを追加したものになります。認識された単語が「お手」または「大手」と認識された場合、PiDogのLEDストリップがピンク色で点滅し、PiDogが頭を動かして「お手」の動作をします。その後、PiDogは再び座る姿勢をとり、LEDストリップが白色でゆっくりと点滅します。

PiDogならラズパイがもっと楽しくなる

PiDogが手元に届いてから、組み立て、動作確認、プログラミングといった一連の作業を経て、いつも「次に何が起こるんだろう？」と楽しみで仕方がありませんでした。時間が足りないくらい、ずっとPiDogと遊んでいたいと思わせる魅力がそこにはありました。

PiDogはRaspberry Piで何から手をつけていいか迷っている方や、電子工作には興味があるけれど初めの一歩が踏み出せない方にぴったりのキットです。親しみやすい工夫がたくさんされており、使う人を魅了します。こんなに夢中になれるアイテムとの出会いは、そうはありません。

さて、次はPiDogと何をして遊ぼうかな？

今回は、その魅力的なラズパイケースのすべてをレビューします。後半では、類似商品であるPironmanとの違いにも触れながら、どんな人がこの製品を買うべきなのかを解説していきます。

開封～組み立て

ElectroCookie Raspberry Pi 4ケースの箱です。意外とコンパクトなサイズです。組み立て時間は30分でした。

キットの部品数は少なめです。組み立てが得意でない方でも、安心して作業できます。

取説は両面になっています。組み立ての指示については図だけで十分に理解できます。特に迷うことはありませんでした。

付属のドライバーは、なぜかマイナスドライバーでしたが、特に不便に感じることなく作業できました。

Raspberry Pi 4のSoCの部分に背の高いヒートシンクを取り付けます。ファンが高い位置に付くので、高さをかせぐ必要あるようです。ここをしっかりと冷却することで、ラズパイは本来の能力を発揮できます。

ラズパイ本体をケースに入れます。

サイドパネルは透け感のあるブラックです。このパネル越しに光るLEDがサイバー感を盛り上げます。

冷却ファンをパネルに取り付けます。ファンにはフルカラーLEDが入っています。

上の写真はLEDの基板とGPIOピンを延長するための基板が一緒になったものです。左側にLEDの明るさを調整する青いツマミが付いています。このツマミはケース組み立て後でも調整可能です。また右端には冷却ファンの電源用のピンが付いています。

LEDの基板はラズパイ本体のGPIOピンにまるごと差し込むだけなので、楽ちんです。

サイドパネルを両面取り付けて完成。早く光らせたい。

いざ起動

ACアダプターのUSBケーブルを接続します。サイドパネルには穴が開いており、コネクターにアクセス可能です。

電源を入れるとすぐに、冷却ファンが稼働し始め、LEDも点灯します。ラズベリーパイの設定は一切必要なく、簡単に使用開始できます。

半透明のパネルから透けるLEDがかっこいいです。

LEDの色は周期的に変化します。

見た目のクールさとコンパクトさのギャップがたまりません。

LEDの明るさはドライバーを使って調整できます。左いっぱいに回せば、LEDを消灯することも可能です。

冷却ファンは連続運転です。環境によっては、少し音が気になるかもしれません。冷却ファン側にもLEDが付いており、こちらも周期的に色が変化します。

背面の穴からmicroSDカードを交換できるのも、便利なポイントです。

また、GPIOピンはすべて使用できます。電子パーツを接続して、動作確認するときに便利です。

以下の動画はサーボモーターをつないで動かした様子です。

冷却効果の検証

発熱しやすいRaspberry Pi 4にとっては、冷却効果が重要な要素となります。ここからはケースに搭載された冷却ファンの効果を検証していきましょう。

冷却ファンは電源が供給されている間は運転を継続します。今回のテストでは電源ワイヤーとファンの間に手持ちのスイッチを追加して、ファンの運転前後のCPU温度を比較します。

テストの条件は以下の通りです。

以下はテストで使用したPythonスクリプトです。CPU温度をリアルタイムでプロットします。

import numpy as np
import sys
import time
import matplotlib.pyplot as plt
import datetime
import pandas as pd
import subprocess
import re

count = 0

max_plot_num = 1500
history_x = []
history_y = []
ax = plt.subplot()

while True:
    # 現在のcpu温度の取得
    proc = subprocess.run(["vcgencmd", "measure_temp"], stdout = subprocess.PIPE, stderr = subprocess.PIPE)
    proc_tmp = re.split("[=\']", proc.stdout.decode("utf8"))
    print(proc_tmp[1]," ",count)
    temp_c = proc_tmp[1]
    
    date1 = datetime.datetime.now()
    date_p = pd.to_datetime(date1.strftime("%H:%M:%S.%f"))
    history_x.append(date_p)
    history_y.append(float(temp_c))
    ax.clear()
    ax.plot(history_x[-max_plot_num:],history_y[-max_plot_num:], '-')
    plt.ylim(30,50.0)
    plt.grid(True)
    plt.xticks(rotation=30)
    plt.xlabel('date')
    plt.ylabel('cpu temp')
    plt.pause(0.3)
    
    count = count+1

上記のPythonスクリプトを実行後、しばらくしてからスイッチを入れて、ファンを運転します。

テスト結果は3分で50℃から41℃になり、9℃低下しました。見た目だけではなく、ファンの冷却効果は確実にあるといえます。

類似製品「Pironman」との比較

同じくAmazonで販売されているラズパイ４用ケースPironmanとの違いを見ていきましょう。

	ElectroCookie	Pironman
参考価格	4,890円	9,980円
メーカー	ElectroCookie	SunFounder
サイズ	9.8×9.8×6.2cm	16×14×9cm
冷却方式	冷却ファン	アイスタワー 冷却ファン
冷却ファンの 運転条件	常時運転	運転条件の 設定が可能
電源ボタン	なし	あり
インフォメーション ディスプレイ	なし	あり
LEDの点灯 パターン	変更不可	変更可能
専用ソフトウェア のインストール	不要	必要

ElectroCookieとPironmanの大きな違いは、それが「単なるケース」であるかどうかという観点になります。ElectroCookieは、ラズベリーパイを保護する基本的なケースの役割に、冷却ファンとLEDの電飾を追加した製品です。これに対して、Pironmanは単なる保護ケースではなく、ラズベリーパイの便利さを高める機能や、カスタマイズを楽しむための様々なオプションが組み込まれています。

Pironmanは多機能である反面、初心者にとっては組み立てや設定が少々難しく感じるかもしれません。一方、シンプルな設計のElectroCookieは、その手軽さからすぐに組み立てて使用開始できるメリットがあります。

黒が好きで、ケースにあまりお金をかけたくない方はElectroCookieがおすすめです。予算に余裕があり、ワクワクしながらラズベリーパイを使いたい方はPironmanを選ぶと良いでしょう。

RasPad3はSUNFOUNDER社が製造・販売している、Raspberry Pi 4をタブレット化できるキットです。ラズパイを中に入れてタブレットのように使用できます。

ITが苦手な方でも思わず手に取ってしまうような、スタイリッシュで親しみやすいデザインが特徴です。

通常のラズパイと同様に、コンピューター教育や電子工作などに利用できるRasPad3。エンジニアが使うLinuxベースのOSを気軽に触ることができるため、お子様の学習用タブレットにも適しています。

そぞら

この記事ではRasPad3のデザインやスペック、使用感などを詳しくレビューします。

RasPad3のキットにはRaspberry Pi 4は含まれていません。ラズパイ本体とmicroSDカードは別途用意する必要があります。

RasPad3のスペックとデザイン

世界中で販売されているRasPad3。クラウドファンディングサイトKickstarterにおいて、目標金額を大きく上回る$313,431の調達に成功しています。

タブレットのスペック

画面サイズは10.1インチ。タップ操作が問題なくできるちょうどいいサイズだと感じました。

CPU（ラズパイ）のスペック

CPUやメモリのスペックは、中に入れるRaspberry Pi 4のスペックに依存します。

ラズパイは自分で用意する

RasPad3に組み込むことができるラズパイはRaspberry Pi 4 Model Bだけです。Raspberry Pi 3 Model Bなどは基板サイズが同じでも使用できません。

そぞら

Raspberry Pi 4 Model Bはメモリが3種類ありますが、どれでも使用可能です。

使用できるラズベリーパイは次の３種類です。

僕はRaspberry Pi 4 Model Bの2GBモデルを使用しました。

充実したインターフェース

USBポートは高速なデータ通信が可能な規格であるUSB3.0が3か所あります。

バッテリー残量は3段階のLED点灯で確認できます。

microSDカードのスロットは外側に付いているため、カード交換が容易です。

冷却ファンは起動中ずっと回転を継続します。運転・停止や回転数の制御はできません。

開封～組み立て

タブレット本体は組み立てられた状態で入っています。

パーツリストが入っています。デザインがおしゃれです。

主な付属品は以下の通りです。

パーツの点数はそこまで多くはありません。子供と一緒に楽しみながら作るのも良さそうです。

ドライバーが付属しているため、自分で工具を用意する必要はありません。

タブレット用の「タッチペン」を連想させる気の利いたデザインのドライバーです。

組み立て

組み立てから使用方法までを解説したオンラインマニュアルがあります。英語表記ですが、ブラウザの翻訳機能を使えば問題なく使用可能です。

組み立て時間は20分かかりました。特に難しい箇所はありません。

まず裏面のふたを取り外します。バッテリーや基板、スピーカーがすでに取り付けられています。

ラズパイ本体を取り付けてケーブルを接続します。

加速度センサーをラズパイのGPIOに差し込みます。加速度センサーは画面の自動回転機能で使う重要なパーツです。

以下の動画を見ていただくと、組み立ての様子がイメージしやすくなります。

完成

中身がラズパイとは思えないほどスタイリッシュで高級感のある外観です。その一方で、気になるのは重さです。

重量は実測値で942g。一般的な同サイズのタブレットの2倍近い重さであり、片手で長時間持つには重く感じます。

使用前に充電する

キットに付属しているアダブターで充電できます。最初の充電時間は2時間かかりました。フル充電から電源が切れるまでの時間は2時間30分。YouTubeの視聴など負荷のかかる使い方をしなければ、3時間前後は使えます。

Raspberry Pi OSで使用する

使用したOSのバージョンは以下の通りです。

Raspberry Piは別売りのmicroSDカードにOSをインストールして使用します。

microSDカードは裏面を上にしてセットします。

RasPad3起動

初期設定の済んでいないmicroSDカードを使う場合は、以下の画面が立ち上がります。別売りのUSBキーボードを使って初期設定をしましょう。

解像度1280×800のIPS液晶パネルはどの角度から見ても美しいです。

電源を入れると、裏面の冷却ファンが回転します。そこまで大きい音ではありませんが、電源を切ったときにファンが停止すると、静かになったなと感じます。

発熱しやすいことが特徴であるRaspberry Pi 4。タブレットの内部という密閉された空間で使用するには冷却ファンが必須です。安定した処理能力を維持するためならば、ファンの音は目をつぶれるレベルといえます。

タブレットとして使用するための設定をする

画面のタップはすぐに使える状態になっています。このほかに、タブレットの基本的な機能を利用するために以下の設定をします。

設定の段階では、コマンドを入力するために、別売りのUSBキーボードが必要です。

仮想キーボード

仮想キーボードを設定すると、文字入力の場面で画面上にキーボードが自動で出ます。

仮想キーボードを使うには、本体を起動するたびに以下のように「Onboard」を立ち上げる必要があり、少し面倒に感じます。

右クリックメニュー

マウスで右クリックしたときのメニューを表示させるときは、2本の指で画面をタップします。

画面の自動回転

タブレットの向きを変えたときに画面が自動で回転する設定ができます。組み立てのときに取り付けた加速度センサーで本体の傾きを検知して画面を回転する仕組みです。

画面が回転する様子は以下のツイートの動画を参考にしてください。

180°回転させるとタブレットが直立するので、立てた状態で使用したいときに便利です。

「RasPad Launcher」をインストール

RasPad3には専用のソフトであるRasPad Launcherが用意されています。RasPad Launcherをインストールするとスタートメニューの表示が変わり、タブレットでの操作性が向上します。

wget https://github.com/raspad-tablet/raspad-launcher/releases/latest/download/raspad-launcher.zip
unzip raspad-launcher.zip
cd raspad-launcher

chmod +x install
sudo ./install

上記のコマンドを実行して再起動すると、スタートメニューのアイコンが変更されます。

スタートメニューをタップすると以下のような画面が開きます。

大きめのアイコンでタップしやすいように配慮されたインターフェースです。ただし、RasPad Launcherをインストールすることにより変わる部分はメニュー表示のみで、アプリを起動すると通常のOS画面に戻ります。

そぞら

RasPad Launcherをインストールするメリットはあまり感じませんでした。

YouTube視聴が快適

ブラウザを開けばYouTubeも見れます。画面の大きさがちょうど良く、画質もキレイです。

スピーカーは2個搭載されているので、迫力のある音量で動画が楽しめます。

プログラミングでLEDを点滅させる

スクラッチ（Scratch）というビジュアルプログラミング言語で遊んでみます。ビジュアルプログラミング言語は、プログラミングを行う際にグラフィックスや図形を使って視覚的に表現する言語です。

そぞら

難しい文法を覚える必要がなく、未経験者や子供でもすぐにプログラミングを楽しめます。

また文字入力不要でプログラミングできるため、タブレットでも快適に操作できます。

スクラッチをインストールする

まずはターミナルで以下のコマンドを実行してスクラッチをインストールします。

sudo apt install scratch3

インストール後、Programmingのメニューを開くとScratch 3が追加されています。タップして開きます。

見ているだけでワクワクするような画面が立ち上がります。

この画面ですぐにプログラムを作ることができます。

LEDを配線する

LEDはRaspberry PiのGPIOと呼ばれるピンに接続します。

タブレット内部に収納されたRaspberry PiのGPIOにアクセスするために、別売りの拡張ボードを使用します。

タブレットを分解して拡張ボードを取り付けるのは手間に感じます。できればRaspberry Pi 400のように、常時GPIOにアクセスできるようなデザインにしてほしかったです。

LEDを拡張ボードのピンに接続します。接続にはジャンパーワイヤーを使用します。

今回は抵抗内蔵LEDという、内部に抵抗が入っているLEDを使用しました。普通のLEDを使用する場合は抵抗を接続しないとLEDが壊れるため、注意が必要です。

LEDには極性があります。足の長いほう（プラス）をGPIO18に、足の短いほう（マイナス）をGNDに接続します。

Raspberry PiのGPIOを使えるようにする

スクラッチの初期状態では、Raspberry PiのGPIOを扱うためのブロックが用意されていません。ブロックを追加するにはメイン画面左下の拡張ボタンをタップします。

Raspberry Pi GPIOをタップします。

するとGPIOに関するブロックが追加されます。

プログラミングをする

プログラミングはとても簡単です。画面左側からブロックを選び、中央で組み合わせていきます。

LEDを点滅させるプログラムは以下のようになります。

プログラムの内容は以下の通りです。

参考にさせていただいたサイト。ラズパイでスクラッチ3を使ってLチカする

プログラムの実行

旗のボタンをタップするとLEDが10回点滅します。

スクラッチとタブレットは非常に相性が良いと感じました。画面のタッチでブロックをスムーズに動かせるからです。

一般的なタブレットやパソコンでも無料で楽しめるスクラッチ。ブロックを組み合わせて画面上のキャラクターを動かすといった操作により、プログラミングの基本的な概念が学べます。

そぞら

しかし、タブレットに繋いだLEDを点滅できるのはRasPad3だけの強みです。

自分の作ったプログラムで「実在するモノの状態が変化する」というかけがえのない体験を得られることでしょう。

まとめ　ラズパイ入門用タブレットとして秀悦

本記事はRasPad3のレビューについて書きました。

レビューをすることが決まって以来「ラズパイをタブレットにするメリットは何だろう」という疑問を持ち続けていました。しかし、スクラッチでLEDを点滅させた瞬間に、はっきりとした答えが見えました。

そぞら

RasPad3ならプログラミング経験のない方やお子様でも、電子工作の楽しさを手軽に体感できます。

最も楽しいラズパイの使い方は電子工作だと思います。これは長い間ラズパイを使ってきた僕の結論です。

RasPad3でラズパイの使い方や電子工作に慣れてきたら、いつか基板だけのラズパイでPythonなどのプログラミングで電子工作にチャレンジしてほしい。そう思いながらこの記事を書きました。

ラズパイや電子工作の入門用タブレットとして最適なRasPad3。興味のある方はぜひ、お手に取っていただきたいアイテムです。