Bark Back: IoT-Haustiermonitor für intelligentes Schallmanagement

Erhalten Sie Echtzeit-Einblicke in das Verhalten Ihrer Haustiere – von überall. Das Bark-Back-System nutzt das Internet der Dinge, um Umgebungsgeräusche in Ihrem Zuhause aufzuzeichnen, die Daten in die Cloud hochzuladen und automatisch eine benutzerdefinierte Audiodatei abzuspielen, wenn der Schallpegel einen benutzerdefinierten Schwellenwert überschreitet.

Auf einem Raspberry Pi basierend, liest das Projekt ein SparkFun-MEMS-Mikrofon über einen MCP3002-ADC aus, streamt Lautstärkedaten per MQTT an CloudMQTT und startet eine OMXPlayer-Instanz, um einen vorgewählten „Bark-Back“-Clip abzuspielen.

Was Sie lernen werden

SparkFun MEMS-Mikrofon mit Raspberry Pi 3 verbinden und auslesen.
Echtzeit-Lautstärkepegel an CloudMQTT übertragen.
Lautstärkeschwellenwert konfigurieren, der automatisch eine benutzerdefinierte Audiodatei abspielt.

Voraussetzungen

Für dieses Tutorial benötigen Sie einen Raspberry Pi 3 (oder neuer) mit Raspbian OS, WLAN-Konnektivität und grundlegende Python-Kenntnisse. Vertrautheit mit GPIO, MQTT und analoger Signalwandlung ist hilfreich, aber nicht erforderlich.

MQTT-Kommunikationsprotokoll

MQTT (Message Queuing Telemetry Transport) ist ein leichtes IoT-Messaging-Protokoll. Dieser Leitfaden nutzt den Eclipse Paho Python Client und CloudMQTT als Broker.

IoT-Kommunikationsprotokolle verstehen.
CloudMQTT-Konto einrichten (der kostenlose „Cute Cat“-Plan reicht aus).
Paho MQTT Python Library installieren und nutzen.

MEMS-Mikrofon-Breakout

Das SparkFun MEMS-Mikrofon ist ein analoger Sensor; ein MCP3002-ADC wandelt sein Ausgangssignal in ein digitales Signal um, das der Raspberry Pi lesen kann.

Einstieg in das SparkFun MEMS Microphone Breakout.
MEMS-Mikrofon-Datenblatt prüfen.
MCP3002-ADC-Datenblatt prüfen.

Materialien

Nachfolgend eine umfassende Liste der benötigten Komponenten. Alle Artikel sind bei SparkFun und anderen Händlern erhältlich.

Bark Back: Monitor & Interact with Pets! SparkFun Wish List
Analog-Digital-Wandler – MCP3002
SparkFun MEMS Microphone Breakout – INMP401 (ADMP401)
Steckplatine – Selbstklebend (Weiß)
Jumper Wires – 6″ (M/M, 20er Pack)
Netzteil – 5V DC 2A (USB Micro-B)
Raspberry Pi GPIO Ribbon Cable – 40-polig, 6″ (kompatibel mit Pi 3, Pi 2, B+)
Raspberry Pi 7″ Touchscreen LCD
Raspberry Pi 3
Raspberry Pi™ – 16GB MicroSD NOOBS Karte
Raspberry Pi 3 + Camera Enclosure – Clear

Zusätzliches Zubehör:

MicroUSB-Stromkabel
HDMI-Kabel
USB-Tastatur
USB-Maus
Lautsprecher mit 3,5-mm-Klinkenanschluss

Hardware-Aufbau

Verbinden des Pi mit Mikrofon und ADC. Auf das Verdrahtungsdiagramm klicken für eine vergrößerte Ansicht.

Zum Raspberry Pi 2/3 Model B Pinout-Diagramm als Referenz.

1. MCP3002 mit dem Raspberry Pi verbinden

Der MCP3002 nutzt vier SPI-Pins: SCLK, MISO, MOSI und CS. Diese werden auf Pi GPIO-Pins 11 (SCLK), 9 (MISO), 10 (MOSI) und 8 (CE0) abgebildet.

Pin-Verbindungen:

Pin 1 → Raspberry Pi GPIO 8 (CE0)
Pin 2 → MEMS-Mikrofon Analogausgang
Pin 4 → GND
Pin 5 → Raspberry Pi GPIO 10 (MOSI)
Pin 6 → Raspberry Pi GPIO 9 (MISO)
Pin 7 → Raspberry Pi GPIO 11 (SCLK)
Pin 8 → Raspberry Pi 3,3V Ausgang

2. MEMS-Mikrofon-Breakout-Board verdrahten

Vcc → Raspberry Pi 3,3V
GND → Raspberry Pi GND
AUD → MCP3002 Pin 2

Pi-Konfiguration

Stellen Sie sicher, dass Ihr Raspberry Pi vollständig aktualisiert ist und die SPI-Schnittstelle aktiviert ist.

Schritt 1: Updates prüfen & installieren

sudo apt-get update
sudo apt-get upgrade
sudo reboot

Schritt 2: SPI aktivieren und Abhängigkeiten installieren

sudo apt-get install python-dev
mkdir py-spidev
cd py-spidev
git clone https://github.com/doceme/py-spidev
sudo python setup.py install

Schritt 3: OMXPlayer testen

OMXPlayer ist auf Raspbian vorinstalliert. Wiedergabe prüfen:

omxplayer /home/pi/…/SongFilePath/SongFileName.mp3
# Falls nötig, lokalen Ausgabe erzwingen:
omxplayer -o local /home/pi/…/SongFilePath/SongFileName.mp3

Schritt 4: CloudMQTT konfigurieren

CloudMQTT-Konto erstellen (kostenloser „Cute Cat“-Plan).
Neue MyCloud-Instanz anlegen.
In der Konsole ACL-Regel hinzufügen, um Publish/Subscribe zu erlauben.
WebSocket-UI nutzen, um Nachrichten zu überwachen.
Paho MQTT Client installieren:
```
pip install paho-mqtt
```

Software-Setup

Das Bark-Back-System hat zwei Kernfunktionen: (1) Audiodatei abspielen, wenn der Hund bellt, und (2) Lautstärkedaten in die Cloud senden.

Vor dem Coding Ihre „Bark-Back“-Audioclips aufnehmen oder besorgen und in einem zugänglichen Verzeichnis ablegen (z. B. Desktop). Das folgende Python-Skript ist sofort einsatzbereit; Sie können auch das komplette Repository von GitHub klonen.

# Bark Back: Monitor & Interact with Pets!
# -----------------------------------------------------
# Author: jenfoxbot <[email protected]>
# License: Coffee/Beer‑ware – keep this header if you use it.
# Libraries
import spidev
from threading import Thread
import subprocess
import paho.mqtt.client as paho
import random, time, os, urlparse

# Configurable lists and credentials
songList = [
    "/home/pi/Desktop/SongFile1.mp3",
    "/home/pi/Desktop/SongFile2.mp3",
    "/home/pi/Desktop/SongFile3.mp3",
    "/home/pi/Desktop/SongFile4.mp3"
]
creds = {
    'CloudMQTT URL': 'https://m10.cloudmqtt.com',
    'user': 'INSERT_CLOUDMQTT_USERNAME',
    'password': 'INSERT_CLOUDMQTT_PASSWORD',
    'host': 'INSERT_CLOUDMQTT_SERVER',
    'port': 'INSERT_CLOUDMQTT_PORT',
    'topic': 'INSERT_ACL_TOPIC'
}

# --- SPI / MEMS Microphone ----------------------------------------
spi = spidev.SpiDev()
spi.open(0,0) # CE0

def read_spi(channel):
    spidata = spi.xfer2([96,0])
    data = ((spidata[0] & 3) << 8) + spidata[1]
    return data

def PTPAmp():
    sampleTime = 0.05
    startTime = time.time()
    PTPAmp = 0
    maxAmp = 0
    minAmp = 1023
    while(time.time() - startTime < sampleTime):
        micOut = read_spi(0)
        if micOut < 1023:
            if micOut > maxAmp:
                maxAmp = micOut
            elif micOut < minAmp:
                minAmp = micOut
        PTPAmp = maxAmp - minAmp
    return PTPAmp

def VolumeUnit(data, fromLow, fromHigh, toLow, toHigh):
    return (data - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow

# --- OMXPlayer wrapper ---------------------------------------------
class OMXPlayer:
    def __init__(self, file_path):
        self.file_path = file_path
        self.is_running = False
        self.play_song()

    def call_omxplayer(self):
        print(f"Playing {self.file_path}\n")
        subprocess.Popen(["omxplayer", "-o", "local", self.file_path],
                         stderr=subprocess.PIPE, stdout=subprocess.PIPE)
        self.is_running = False

    def play_song(self):
        if not self.is_running:
            self.song_thread = Thread(target=self.call_omxplayer)
            self.song_thread.start()
            self.is_running = True

def pickRandom(songList):
    return random.choice(songList)

# --- MQTT callbacks -----------------------------------------------
def on_connect(mosq, obj, rc):
    print(f"rc: {rc}")

def on_message(mosq, obj, msg):
    print(f"{msg.topic} {msg.qos} {msg.payload}")

def on_publish(mosq, obj, mid):
    print(f"mid: {mid}")

def on_subscribe(mosq, obj, mid, granted_qos):
    print(f"Subscribed: {mid} {granted_qos}")

def on_log(mosq, obj, level, string):
    print(string)

# --- Main loop ----------------------------------------------------
def main():
    mqttc = paho.Client()
    mqttc.on_message = on_message
    mqttc.on_connect = on_connect
    mqttc.on_publish = on_publish
    mqttc.on_subscribe = on_subscribe
    # mqttc.on_log = on_log # enable for debugging

    url_str = os.environ.get(creds['CloudMQTT URL'], 'mqtt://localhost:1883')
    url = urlparse.urlparse(url_str)
    mqttc.username_pw_set(creds['user'], creds['password'])
    mqttc.connect(creds['host'], creds['port'])
    mqttc.subscribe(creds['topic'], 0)

    while True:
        PTPamp = PTPAmp()
        PTPampV = round(((PTPamp * 3.3) / 1024), 2)
        VolUnit = VolumeUnit(PTPamp, 0, 700, 0, 10)
        print(PTPamp, VolUnit)
        if VolUnit > 7:
            playBack = pickRandom(songList)
            OMXPlayer(playBack)
        time.sleep(0.1)
        mqttc.publish("Volume", str(VolUnit))
        rc = True
        while rc:
            rc = mqttc.loop()
            time.sleep(0.1)
            print(f"rc: {rc}")

try:
    while True:
        pass
except KeyboardInterrupt:
    pass

if __name__ == '__main__':
    main()

Ersetzen Sie die Platzhalterwerte in songList und creds durch Ihre tatsächlichen Dateipfade und CloudMQTT-Zugangsdaten.

Fühlen Sie frei, das Skript anzupassen – z. B. Lautstärkeschwellenwert ändern, Logging hinzufügen oder weitere Sensoren integrieren.

Nächste Schritte

Weitere Erweiterungen erkunden:

Touchscreen-Display integrieren, um Echtzeit-Lautstärkepegel anzuzeigen.
Kamera-Feed hinzufügen, um Ihr Haustier visuell zu überwachen.
Web-Dashboard für Remote-Monitoring implementieren.

Für zusätzliche Ressourcen konsultieren Sie das SparkFun MEMS-Mikrofon-Datenblatt, das MCP3002-ADC-Datenblatt und die Eclipse Paho MQTT Client Dokumentation.

Viel Spaß beim Basteln – und möge Ihr Hund eine ruhigere, glücklichere Umgebung genießen!

Posture Pal mit Walabot – Echtzeit-Entfernungsüberwachung gegen Nacken- und Rückenschmerzen Acconeer A111 Pulsradar mit Raspberry Pi integrieren: Praktischer Leitfaden

Herstellungsprozess

3d Drucken

Automatisierungssteuerung System

Industrietechnik