Bark Back Interaktiver Haustiermonitor

Bringen Sie etwas Licht (äh, Ton) in die schwer fassbaren Geheimnisse der Possen Ihrer Haustiere, während Sie nicht zu Hause sind! Dieses Bark-Back-Projekt für das Internet der Dinge (IoT) überwacht und lädt den Geräuschpegel in Ihrem Zuhause in die Cloud, damit Sie nach Ihren geliebten Haustieren sehen können. Das Beste daran:Wenn es zu laut wird (z. B. Fido bellt oder macht einen anderen Krach), spielt das Programm Ihre eigene "belle"-Audiodatei ab, um den Welpen abzulenken und zu beruhigen.

In diesem Projekt wird ein Raspberry Pi verwendet, um das SparkFun MEMS-Mikrofon-Breakout-Board zu lesen und einen Audioplayer auszulösen. Die Daten werden über das MQTT-Kommunikationsprotokoll in den CloudMQTT-Dienst hochgeladen.

Sehen Sie sich das Video unten für eine Demo an!

In diesem Tutorial behandelt

Dieses Tutorial zeigt Ihnen, wie Sie Folgendes tun:

• Anschließen und Einlesen des SparkFun MEMS-Mikrofons mit dem Raspberry Pi 3
• Laden Sie die Lautstärke in den CloudMQTT-Dienst hoch
• Verwenden Sie einen Lautstärkeschwellenwert, um Ihr "Rückbellen" bei Ihrem Hündchen auszulösen, wenn es zu laut wird

Empfohlene Lektüre

Um dieses Projekt zu erstellen, benötigen Sie einen vollständig konfigurierten, über WLAN verbundenen Raspberry Pi 3 mit Raspbian OS. Es ist auch hilfreich, einige Python-Programmierung sowie die folgenden drei Dinge zu kennen:(1) Verwendung und Steuerung der Raspberry Pi GPIO-Pins, (2) MQTT-Kommunikation und (3) analoge Signale. Wenn Ihnen etwas davon unbekannt ist oder Sie einfach nur neugierig sind (sei neugierig!)

MQTT-Kommunikationsprotokoll

MQTT (Message Query Telemetry Transport) ist ein beliebtes IoT-Kommunikationsprotokoll. Wir verwenden die Python-Bibliothek von Paho Client und einen MQTT-Dienst namens CloudMQTT.

1. Kommunikationsprotokolle für das IoT erkunden
2. Erste Schritte mit CloudMQTT
3. Übersicht über die Eclipse Paho MQTT Python-Clientbibliothek

MEMS-Mikrofon-Breakout-Board

Das MEMS-Mikrofon ist ein analoges Mikrofon, daher benötigen Sie den MCP3002 Analog-to-Digital-Wandler ("ADC"), um das analoge Signal mit den digitalen GPIO-Pins des Raspberry Pi einzulesen.

1. Erste Schritte mit dem SparkFun MEMS Microphone Breakout Board
2. MEMS-Mikrofon-Datenblatt
3. MCP3002 ADC-Datenblatt

Materialien

Sie benötigen die folgenden Materialien, um mitzumachen.

Bark Back:Haustiere überwachen und mit ihnen interagieren! SparkFun-Wunschliste

Analog-Digital-Wandler – MCP3002

SparkFun MEMS Mikrofon Breakout – INMP401 (ADMP401)

Steckbrett – selbstklebend (weiß)

Überbrückungsdrähte – verbunden 6″ (M/M, 20er Pack)

Wandadapter-Netzteil – 5V DC 2A (USB Micro-B)

Raspberry Pi GPIO Flachbandkabel – 40-polig, 6″ (RPi 3, RPi2, B+)

Raspberry Pi LCD – 7″ Touchscreen

Raspberry Pi 3

Raspberry Pi™ – 16-GB-MicroSD-NOOBS-Karte

Raspberry Pi 3 + Kameragehäuse – Klar

Sie benötigen außerdem Folgendes:

• MicroUSB-Stromkabel
• HDMI-Kabel
• USB-Tastatur
• USB-Maus
• Lautsprecher mit 1/8-Zoll-Kopfhöreranschluss

Hardware-Anbindung

Anschließen des Pi an die andere Hardware. Klicken Sie auf den Schaltplan für eine genauere Ansicht.

Hier ist das Pinbelegungsdiagramm von Raspberry Pi 2 (und 3) Modell B:

1. Verbinden Sie den MCP3002 mit dem Raspberry Pi.

Nahaufnahme des MCP3002

Es gibt vier SPI-Pins für die SPI-Kommunikation:Serial Clock („SCL“), Master Input Slave Output („MISO“), Master Output Slave Input („MOSI“) und Chip Select („CS“). Diese Pins entsprechen dem Raspberry Pi GPIO-Pin 11 (SCLK), GPIO-Pin 9 (MISO), GPIO-Pin 10 (MOSI) bzw. GPIO-Pin 8 (CE0).

Hier ist das Pinbelegungsdiagramm des MCP302:

Stellen Sie die folgenden Verbindungen mit MCP3002-Pins her:

• Verbinden Sie Pin 1 mit Raspberry Pi GPIO Pin 8 (CE0)
• Verbinden Sie Pin 2 mit dem analogen Ausgang der MEMS-Mikrofon-Breakout-Platine
• Pin 4 mit GND verbinden
• Verbinden Sie Pin 5 mit Raspberry Pi GPIO Pin 10 (MOSI)
• Pin 6 mit Raspberry Pi GPIO Pin 9 (MISO) verbinden
• Pin 7 mit Raspberry Pi GPIO Pin 11 (SCLK) verbinden
• Verbinden Sie Pin 8 mit Raspberry Pi 3.3V out

2. Lötdrähte an die MEMS-Mikrofon-Breakout-Platine. Verbinden Sie sich mit MCP3002 und Raspberry Pi.

• Vcc mit Raspberry Pi 3.3V verbinden.
• GND mit Raspberry Pi GND verbinden
• AUD mit MCP3002 Pin 2 verbinden

Pi-Konfiguration

RPi verbunden!

Schritt 1:Updates prüfen und installieren

Nach Updates suchen und installieren:
sudo apt-get update
sudo apt-get upgrade
sudo reboot

Schritt 2:SPI-Schnittstelle für MEMS-Mikrofon + MCP3002 einrichten

Installieren Sie das Python Dev-Paket:
sudo apt-get install python-dev

Erstellen Sie einen Unterordner und installieren Sie das Serial Port Interface („SPI“):
mkdir py-spidev
git clone git://github.com/doceme/py-spidev
sudo python setup. py installieren

Hier ist die SPI-Dev-Dokumentation, falls Probleme auftreten.

Schritt 3:Sounds mit dem OMXPlayer abspielen

Der OMXPlayer ist ein auf Raspbian OS vorinstallierter Audio- und Videoplayer (woo!). Es funktioniert mit den meisten Audiodateitypen, einschließlich:.wav, .mp3 und .m4a. Wir werden dies verwenden, um unsere "Bell-Back"-Sounds abzuspielen.

Testen Sie im Terminal den OMXPlayer mit dem folgenden Befehl:
omxplayer /home/pi/…/SongFilePath/SongFileName.mp3

Wenn das nicht funktioniert, versuchen Sie, es über das lokale Audioausgabegerät zu erzwingen:
omxplayer -o local /home/pi/…/SongFilePath/SongFileName.mp3

Schritt 4:Konfigurieren des CloudMQTT-Servers

Jetzt richten wir einen MQTT-Server ein! Um dies mit CloudMQTT zu tun, gehen Sie wie folgt vor:

1. Richten Sie ein CloudMQTT-Konto ein (der „Cute Cat“-Plan ist kostenlos).
2. Erstellen Sie eine neue MyCloud-Instanz.
3. Erstellen Sie in der Konsole eine neue ACL-Regel.
4. Sie können veröffentlichte Nachrichten in der „Websocket-UI“ Ihrer CloudMQTT-Konsole überwachen.

Installieren Sie abschließend die MQTT Paho Client Python-Bibliothek:
pip install paho-mqtt

Software-Setup

Unser Ziel mit dem Bark Back ist zweierlei:(1) eine Audiodatei auslösen, wenn der Hund bellt und (2) die Lautstärkedaten an einen Server senden.

Aber zuerst brauchen wir einige "Bell-Back"-Sounds zum Abspielen! Sie können ganz einfach Töne in GarageBand (oder auf Ihrem Smartphone) aufnehmen und an den Raspberry Pi senden. Speichern Sie die Dateien an einem leicht zugänglichen Ort (z. B. Desktop).

Jetzt können Sie ein Bark Back Python-Programm schreiben! …Oder nutze einfach meins:

Hier ist das GitHub-Repository für dieses Projekt. Sie können auch den folgenden Code kopieren und einfügen (denken Sie daran, dass dies Python ist!).
########################### #########################
#Bark Back:Haustiere überwachen und mit ihnen interagieren!##
##### #############################################
# Code geschrieben von jenfoxbot <[email protected]>
# Code ist Open Source, Kaffee-/Bierware-Lizenz.
# Bitte behalten Sie die Kopfzeile + bei, wenn Ihnen der Inhalt gefällt,
# kauf mir einen Kaffee und/oder ein Bier, wenn du mir über den Weg läufst!
################################ #####################

# Vielen Dank an die Leute, die die Bibliotheken
# und die in diesem Projekt verwendeten Funktionen erstellt und dokumentiert haben.

#Libraries
#SPI
import spidev
#OMXPlayer
from Threading import Thread
import subprocess
#MQTT
import paho.mqtt.client as paho
#Other
import random, time, os, urlparse
import time

songList =["SongFile1", #z.B. „/home/pi/Desktop/SongFile.mp3“
„SongFile2“,
„SongFile3“,
„SongFile4“]

creds ={
‘CloudMQTT URL’:‘INSERT_CLOUDMQTT_URL’, #z.B. 'https://m10.cloudmqtt.com'
'Benutzer':'INSERT_CLOUDMQTT_USERNAME',
'Passwort':'INSERT__CLOUDMQTT_PASSWORD',
'Host':'INSERT_CLOUDMQTT_SERVER'
'port':'INSERT_CLOUDMQTT_PORT',
'topic':'INSERT_ACL_TOPIC'
}

################################################ ######
# SparkFun MEMS Mikrofon Breakout Board lesen
############################# ###########################
#SPI-Protokoll starten.
spi =spidev.SpiDev()
spi.open(0,0) #Dies ist der CE0 Pin (GPIO 08) auf dem RPi, für CE1 verwenden Sie (0,1)

#Funktion zum Einlesen des CE0-Kanals
def read_spi(channel):
spidata =spi.xfer2([96,0]) ##Senden von 2 Byte Daten (96 und 0)
data =((spidata[0] &3) <<8) + spidata[1]
Daten zurückgeben

#Funktion zur Berechnung der Peak-to-Peak-Amplitude vom MEMS-Mikrofon
def PTPAmp():
sampleTime =0.05 #Sample-Rate von 50 ms
startTime =time.time()

PTPAmp =0
maxAmp =0
minAmp =1023

while(time.time() – startTime micOut =read_spi(0) #Einlesen von Kanal CE0
if(micOut <1023):#Fehlerhaftes Lesen verhindern
if(micOut> maxAmp):
maxAmp =micOut
elif(micOut minAmp =micOut

PTPAmp =maxAmp – minAmp #Spitze-zu-Spitze-Verstärker berechnen.
PTPAmp zurückgeben

#Funktion zum Zuordnen von Peak-to-Peak-Verstärker zu einer Lautstärkeeinheit zwischen 0 und 10
def VolumeUnit(data, fromLow, fromHigh, toLow, toHigh):
return (data – fromLow) * (toHigh – toLow) / (fromHigh – fromLow) + toLow

################################################ ######
# Klasse zur Steuerung des OMXPlayer für Audio
############################# ###########################
class OMXPlayer():
def call_omxplayer(self):
print ("playing" + self.file_path + '\n')
pid =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, args=())
self.song_thread.start()
self.is_running =True

def __init__(self, file_path):
self.file_path =file_path
self.is_running =False
self.play_song()

#Funktion zum Auswählen eines zufälligen Songs aus der Liste
def pickRandom(songList):
return(random.choice(songList))

################################################ ######
# CloudMQTT-Server
################################# #######################
# Ereignisrückrufe definieren
def on_connect(mosq, obj, rc):
print (“rc:“ + str(rc))

def on_message(mosq, obj, msg):
print(msg.topic + ” “ + str(msg.qos) + ” “ + str(msg.payload))

def on_publish(mosq, obj, mid):
print(“mid:“ + str(mid))

def on_subscribe(mosq, obj, mid, granted_qos):
print(“Abonniert:“ + str(mid) + ” “ + str(granted_qos))

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

################################################ ######
# Hauptfunktion
################################# #######################
def main():
#Paho Python Client Server aufrufen
mqttc =paho. Client()
#Ereignisrückrufe zuweisen
mqttc.on_message =on_message
mqttc.on_connect =on_connect
mqttc.on_publish =on_publish
mqttc.on_subscribe =on_subscribe

# Kommentar entfernen, um Debug-Nachrichten zu aktivieren
#mqttc.on_log =on_log

# Parse CLOUDMQTT_URL (oder Fallback auf localhost)
url_str =os.environ.get(creds['CloudMQTT URL'], 'mqtt://localhost:1883')
url =urlparse.urlparse(url_str )

# Connect
mqttc.username_pw_set(creds[‘user’], creds[‘password’])
mqttc.connect(creds[‘host’], creds[‘port’])

# Abonnieren beginnen, mit QoS-Level 0
mqttc.subscribe(creds[‘topic’], 0)

while True:
#1. ADC-Wert für MEMS-Mikrofon-Spitze-Spitze-Verstärker ermitteln
PTPamp =PTPAmp()
#2. Berechnen Sie ptp amp (Volt)
PTPampV =round(((PTPamp*3.3) / 1024), 2)
#3. Ordnen Sie ptp amp (ADC-Wert) der Volume Unit zwischen 0 und 10 zu
VolUnit =VolumeUnit(PTPamp, 0, 700, 0, 10)

#Zur Fehlersuche
print(PTPamp, VolUnit)

#4. Wenn Volume Unit größer als 7 ist, spielen Sie einen der Songs
if(VolUnit> 7):
playBack =pickRandom(songList)
OMXPlayer(playBack)
time.sleep( 0.1)

#5. Daten auf den CloudMQTT-Server hochladen
mqttc.publish(“Volume”, str(VolUnit))
rc =True
while rc:
rc =mqttc.loop()
time.sleep(0.1)
print(“rc:“ + str(rc))

try:
while True:
pass
außer KeyboardInterrupt:
myprocess.kill()

if __name__ ==‘__main__’:
main()

Damit das Bark-Back-System richtig funktioniert, füllen Sie Folgendes aus:

• Liedliste :Geben Sie den Dateipfad und den Dateinamen für jeden der Songs ein, die Sie abspielen möchten.
• Guthaben :Geben Sie Ihre CloudMQTT-Informationen in dieses Wörterbuch ein.

Fühlen Sie sich frei (und tun Sie dies bitte), den Code anzupassen und zu ändern. Sehen Sie sich die Ressourcen und weitere Schritte an Abschnitt für Projektvarianten und Ergänzungen.

Weitere Informationen lesen…

Interaktiver Haustiermonitor von Bark Back