Bark Back Interactieve Huisdiermonitor

Werp wat licht (eh, geluid) op de ongrijpbare mysteries van de capriolen van uw huisdieren terwijl u niet thuis bent! Dit Internet of Things (IoT) Bark Back-project bewaakt en uploadt het geluidsniveau in uw huis naar de cloud, zodat u uw geliefde huisdier(en) kunt controleren. Het beste deel:als het te luid wordt (d.w.z. Fido blaft of andere herrie maakt), speelt het programma je eigen "blaf terug" audiobestand om de pup af te leiden en te kalmeren.

Dit project gebruikt een Raspberry Pi om het SparkFun MEMS-microfoonbreakoutboard te lezen en een audiospeler te activeren. Gegevens worden geüpload naar de CloudMQTT-service met behulp van het MQTT-communicatieprotocol.

Bekijk de video hieronder voor een demo!

Behandeld in deze zelfstudie

Deze tutorial laat je zien hoe je het volgende doet:

• Verbind en lees de SparkFun MEMS-microfoon in met behulp van de Raspberry Pi 3
• Upload het volumeniveau naar de CloudMQTT-service
• Gebruik een volumedrempel om uw "blaf" naar uw hond te activeren als hij / zij te luidruchtig wordt

Voorgestelde lezing

Om dit project te bouwen, heb je een volledig geconfigureerde, met wifi verbonden Raspberry Pi 3 met Raspbian OS nodig. Het is ook handig om wat Python-programmering te kennen, evenals de volgende drie dingen:(1) het gebruiken en besturen van de Raspberry Pi GPIO-pinnen, (2) MQTT-communicatie en (3) analoge signalen. Als iets hiervan niet bekend is, of als je gewoon nieuwsgierig bent (wees nieuwsgierig!)

MQTT-communicatieprotocol

MQTT (Message Query Telemetry Transport) is een populair IoT-communicatieprotocol. We gebruiken de Paho Client Python-bibliotheek en een MQTT-service genaamd CloudMQTT.

1. Communicatieprotocollen voor IoT verkennen
2. Aan de slag met CloudMQTT
3. Overzicht van Eclipse Paho MQTT Python-clientbibliotheek

MEMS Microfoon Breakout Board

De MEMS-microfoon is een analoge microfoon, dus je hebt de MCP3002 analoog-naar-digitaal-omzetter ("ADC") nodig om het analoge signaal in te lezen met de Raspberry Pi digitale GPIO-pinnen.

1. Aan de slag met het SparkFun MEMS Microphone Breakout Board
2. MEMS-gegevensblad microfoon
3. MCP3002 ADC-gegevensblad

Materialen

Je hebt de volgende materialen nodig om mee te volgen.

Terugblaffen:controleer en interactie met huisdieren! SparkFun-verlanglijstje

Analoog naar digitaal converter – MCP3002

SparkFun MEMS Microfoon Breakout – INMP401 (ADMP401)

Breadboard – zelfklevend (wit)

Doorverbindingsdraden – Verbonden 6″ (M/M, 20 stuks)

Voeding voor wandadapter – 5V DC 2A (USB Micro-B)

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

Raspberry Pi LCD – 7″ touchscreen

Raspberry Pi 3

Raspberry Pi™ – 16GB MicroSD NOOBS-kaart

Raspberry Pi 3 + camerabehuizing – doorzichtig

Je hebt ook het volgende nodig:

• MicroUSB-stroomkabel
• HDMI-kabel
• USB-toetsenbord
• USB-muis
• Luidsprekers met 1/8″ koptelefoonpoort

Hardware-aansluiting

De Pi aansluiten op de andere hardware. Klik op het bedradingsschema om het van dichterbij te bekijken.

Hier is het Raspberry Pi 2 (en 3) Model B pinout-diagram:

1. Sluit de MCP3002 aan op de Raspberry Pi.

Close-up van de MCP3002

Er zijn vier SPI-pinnen voor SPI-communicatie:Serial Clock (“SCL”), Master Input Slave Output (“MISO”), Master Output Slave Input (“MOSI”) en Chip Select (“CS”). Deze pinnen komen overeen met respectievelijk Raspberry Pi GPIO pin 11 (SCLK), GPIO pin 9 (MISO), GPIO pin 10 (MOSI) en GPIO pin 8 (CE0).

Hier is het MCP302 pinout-diagram:

Maak de volgende verbindingen met MCP3002-pinnen:

• Verbind pin 1 met Raspberry Pi GPIO pin 8 (CE0)
• Sluit pin 2 aan op de analoge uitgang van de MEMS Microfoon breakout-kaart
• Verbind pin 4 met GND
• Verbind pin 5 met Raspberry Pi GPIO pin 10 (MOSI)
• Verbind pin 6 met Raspberry Pi GPIO pin 9 (MISO)
• Verbind pin 7 met Raspberry Pi GPIO pin 11 (SCLK)
• Sluit pin 8 aan op Raspberry Pi 3.3V uit

2. Soldeer draden naar de MEMS Microfoon breakout board. Maak verbinding met MCP3002 en Raspberry Pi.

• Verbind Vcc met Raspberry Pi 3.3V.
• Verbind GND met Raspberry Pi GND
• Verbind AUD met MCP3002 Pin 2

Pi-configuratie

RPi verbonden!

Stap 1:Controleer en installeer updates

Controleer op updates en installeer deze:
sudo apt-get update
sudo apt-get upgrade
sudo reboot

Stap 2:SPI-interface instellen voor MEMS-microfoon + MCP3002

Installeer het Python Dev-pakket:
sudo apt-get install python-dev

Maak een submap en installeer de seriële poortinterface (“SPI”):
mkdir py-spidev
git clone git://github.com/doceme/py-spidev
sudo python setup. py installeren

Hier is de SPI-Dev-documentatie als je problemen tegenkomt.

Stap 3:Geluiden afspelen met OMXPlayer

De OMXPlayer is een audio- en videospeler die vooraf is geladen op Raspbian OS (woo!). Het werkt met de meeste soorten geluidsbestanden, waaronder:.wav, .mp3 en .m4a. We gebruiken dit om onze "blafgeluiden" af te spelen.

Test de OMXPlayer in de terminal met het volgende commando:
omxplayer /home/pi/…/SongFilePath/SongFileName.mp3

Als dat niet werkt, probeer het dan via het lokale audio-uitgangsapparaat:
omxplayer -o local /home/pi/…/SongFilePath/SongFileName.mp3

Stap 4:Configureer CloudMQTT-server

Nu hebben we een MQTT-server opgezet! Om dit te doen met CloudMQTT, doet u het volgende:

1. Stel een CloudMQTT-account in (het 'Cute Cat'-abonnement is gratis).
2. Maak een nieuwe MyCloud-instantie.
3. Maak in de console een nieuwe ACL-regel.
4. U kunt gepubliceerde berichten volgen in de "Websocket UI" van uw CloudMQTT-console.

Installeer ten slotte de MQTT Paho Client Python-bibliotheek:
pip install paho-mqtt

Software-installatie

Ons doel met de Bark Back is tweeledig:(1) activeer een audiobestand wanneer de hond blaft en (2) stuur de volumegegevens naar een server.

Maar eerst hebben we wat "blaf-terug"-geluiden nodig om te spelen! Geluiden kun je eenvoudig opnemen in GarageBand (of op je smartphone) en naar de Raspberry Pi sturen. Sla de bestanden op een gemakkelijk toegankelijke locatie op (bijv. Desktop).

Nu ben je klaar om een ​​Bark Back Python-programma te schrijven! ...Of gebruik gewoon de mijne:

Dit is de GitHub-opslagplaats voor dit project. Je kunt ook de onderstaande code kopiëren en plakken (houd er rekening mee dat dit Python is!).
########################### #########################
#Bark Back:Monitor en interactie met huisdieren!##
##### ###############################################
# Code geschreven door jenfoxbot <[email protected]>
# Code is open-source, coffee/beerware-licentie.
# Bewaar kop + als je de inhoud leuk vindt,
# koop een koffie en/of biertje voor me als je me tegenkomt!
################################ #####################

# Veel dank aan de mensen die de bibliotheken maken en documenteren
# en functies die in dit project worden gebruikt.

#Bibliotheken
#SPI
import spidev
#OMXPlayer
van threading import Thread
import subproces
#MQTT
import paho.mqtt.client as paho
#Other
import random, time, os, urlparse
import time

songList =[“SongFile1”, #e.g. “/home/pi/Desktop/SongFile.mp3”
“SongFile2”,
“SongFile3”,
“SongFile4”]

creds ={
‘CloudMQTT URL’:‘INSERT_CLOUDMQTT_URL’, #e.g. 'https://m10.cloudmqtt.com'
'gebruiker':'INSERT_CLOUDMQTT_USERNAME',
'wachtwoord':'INSERT__CLOUDMQTT_PASSWORD',
'host':'INSERT_CLOUDMQTT_SERVER'
'port':'INSERT_CLOUDMQTT_PORT',
'topic':'INSERT_ACL_TOPIC'
}

###################################################################### ######
# SparkFun MEMS Microfoon Breakout Board lezen
############################# ###########################
#Start SPI-protocol.
spi =spidev.SpiDev()
spi.open(0,0) #Dit is de CE0-pin (GPIO 08) op de RPi, voor CE1, gebruik (0,1)

#Functie om in CE0-kanaal te lezen
def read_spi(kanaal):
spidata =spi.xfer2([96,0]) ##sending 2 bytes aan gegevens (96 en 0)
gegevens =((spidata[0] &3) <<8) + spidata[1]
retourneer gegevens

#Functie om de piek-tot-piek-amplitude te berekenen van MEMS mic
def PTPAmp():
sampleTime =0,05 #Sample Rate van 50 ms
startTime =time.time()

PTPAmp =0
maxAmp =0
minAmp =1023

while(time.time() – startTime micOut =read_spi(0) #Lees kanaal CE0 in
if(micOut <1023):#Voorkom foutieve metingen
if(micOut> maxAmp):
maxAmp =micOut
elif(micOut minAmp =micOut

PTPAmp =maxAmp – minAmp #Bereken piek-tot-piek versterker.
return PTPAmp

#Functie om piek-tot-piekversterker toe te wijzen aan een volume-eenheid tussen 0 en 10
def VolumeUnit(data, fromLow, fromHigh, toLow, toHigh):
return (data – fromLow) * (toHigh – naar laag) / (van hoog – van laag) + naar laag

###################################################################### ######
# Klasse om OMXPlayer voor audio te besturen
############################# ###########################
class OMXPlayer():
def call_omxplayer(self):
print (“afspelen” + 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()

#Functie om een ​​willekeurig nummer uit de lijst te selecteren
def pickRandom(songList):
return(random.choice(songList))

###################################################################### ######
# CloudMQTT-server
################################# #######################
# Definieer terugbellen van gebeurtenissen
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, Grant_qos):
print(“Geabonneerd:“ + str(mid) + ” “ + str(granted_qos))

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

###################################################################### ######
# Hoofdfunctie
################################# #######################
def main():
#Call Paho Python Client Server
mqttc =paho. Client()
#Assign event callbacks
mqttc.on_message =on_message
mqttc.on_connect =on_connect
mqttc.on_publish =on_publish
mqttc.on_subscribe =on_subscribe

# Uncomment om foutopsporingsberichten in te schakelen
#mqttc.on_log =on_log

# Parse CLOUDMQTT_URL (of fallback naar 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’])

# Begin met inschrijven, met QoS-niveau 0
mqttc.subscribe(creds[‘topic’], 0)

terwijl True:
#1. Zoek de ADC-waarde voor MEMS-microfoonpiek-tot-piekversterker
PTPamp =PTPAmp()
#2. Bereken ptp amp (volt)
PTPampV =round(((PTPamp*3.3) / 1024), 2)
#3. Wijs ptp amp (ADC-waarde) toe aan Volume Unit tussen 0 en 10
VolUnit =VolumeUnit(PTPamp, 0, 700, 0, 10)

#Voor foutopsporing
print(PTPamp, VolUnit)

#4. Als Volume Unit groter is dan 7, speel dan een van de nummers af
if(VolUnit> 7):
playBack =pickRandom(songList)
OMXPlayer(playBack)
time.sleep( 0.1)

#5. Gegevens uploaden naar CloudMQTT-server
mqttc.publish(“Volume”, str(VolUnit))
rc =True
while rc:
rc =mqttc.loop()
time.sleep(0.1)
print(“rc:“ + str(rc))

try:
while True:
pass
behalve KeyboardInterrupt:
myprocess.kill()

if __name__ ==‘__main__’:
main()

Vul het volgende in om het Bark Back-systeem goed te laten werken:

• liedjeslijst :schrijf het bestandspad en de bestandsnaam in voor elk van de nummers die u wilt afspelen.
• tegoeden :voer uw CloudMQTT-informatie in dit woordenboek in.

Voel je vrij om de code aan te passen en aan te passen (en dat doe je ook). Bekijk de Bronnen en verder gaan sectie voor projectvariaties en toevoegingen.

Lees meer informatie...

Bark Back Interactieve Huisdiermonitor