Moniteur interactif pour animaux de compagnie Bark Back

Éclairez (euh, sonez) les mystères insaisissables des singeries de vos animaux de compagnie loin de chez vous ! Ce projet Bark Back de l'Internet des objets (IoT) surveille et télécharge le niveau de bruit dans votre maison sur le cloud afin que vous puissiez vérifier vos animaux de compagnie bien-aimés. La meilleure partie :si cela devient trop fort (c'est-à-dire si Fido aboie ou fait un autre chahut), le programme joue votre propre fichier audio « aboiement » pour aider à distraire et à calmer le chiot.

Ce projet utilise un Raspberry Pi pour lire la carte de déploiement du microphone SparkFun MEMS et déclencher un lecteur audio. Les données sont téléchargées vers le service CloudMQTT à l'aide du protocole de communication MQTT.

Pour une démo, regardez la vidéo ci-dessous !

Abordé dans ce didacticiel

Ce didacticiel vous montrera comment effectuer les opérations suivantes :

• Connectez-vous et lisez dans le microphone SparkFun MEMS à l'aide du Raspberry Pi 3
• Télécharger le niveau de volume sur le service CloudMQTT
• Utilisez un seuil de volume pour déclencher votre « aboiement » contre votre chien s'il devient trop bruyant

Lecture suggérée

Pour construire ce projet, vous aurez besoin d'un Raspberry Pi 3 entièrement configuré et connecté au Wi-Fi avec Raspbian OS. Il est également utile de connaître la programmation Python ainsi que les trois éléments suivants :(1) utiliser et contrôler les broches GPIO du Raspberry Pi, (2) la communication MQTT et (3) les signaux analogiques. Si l'un de ces éléments ne vous est pas familier, ou si vous êtes simplement curieux (soyez curieux !)

Protocole de communication MQTT

MQTT (Message Query Telemetry Transport) est un protocole de communication IoT populaire. Nous utiliserons la bibliothèque Paho Client Python et un service MQTT appelé CloudMQTT.

1. Exploration des protocoles de communication pour l'IoT
2. Premiers pas avec CloudMQTT
3. Présentation de la bibliothèque cliente Python Eclipse Paho MQTT

Panneau de déploiement de microphone MEMS

Le microphone MEMS est un microphone analogique, vous aurez donc besoin du convertisseur analogique-numérique ("ADC") MCP3002 pour lire le signal analogique avec les broches GPIO numériques du Raspberry Pi.

1. Premiers pas avec la carte de déploiement de microphone SparkFun MEMS
2. Fiche technique du microphone MEMS
3. Fiche technique du CAN MCP3002

Matériaux

Vous aurez besoin des documents suivants pour suivre.

Aboyez en arrière :surveillez et interagissez avec les animaux ! Liste de souhaits SparkFun

Convertisseur analogique-numérique – MCP3002

Sortie de microphone SparkFun MEMS - INMP401 (ADMP401)

Planche à pain – Autocollante (Blanc)

Cavaliers - Connectés 6″ (M/M, paquet de 20)

Alimentation pour adaptateur mural - 5V DC 2A (USB Micro-B)

Câble ruban GPIO Raspberry Pi - 40 broches, 6″ (RPi 3, RPi2, B+)

LCD Raspberry Pi – Écran tactile 7″

Raspberry Pi 3

Raspberry Pi™ – Carte MicroSD NOOBS 16 Go

Raspberry Pi 3 + Boîtier de caméra - Transparent

Vous aurez également besoin des éléments suivants :

• Câble d'alimentation microUSB
• Câble HDMI
• Clavier USB
• Souris USB
• Enceintes avec port casque 1/8"

Raccordement matériel

Connecter le Pi à l'autre matériel. Cliquez sur le schéma de câblage pour un aperçu plus détaillé.

Voici le schéma de brochage du Raspberry Pi 2 (et 3) modèle B :

1. Connectez le MCP3002 au Raspberry Pi.

Gros plan sur le MCP3002

Il y a quatre broches SPI pour la communication SPI :Serial Clock (« SCL »), Master Input Slave Output (« MISO »), Master Output Slave Input (« MOSI ») et Chip Select (« CS »). Ces broches correspondent respectivement à la broche GPIO 11 du Raspberry Pi (SCLK), à la broche GPIO 9 (MISO), à la broche GPIO 10 (MOSI) et à la broche GPIO 8 (CE0).

Voici le schéma de brochage du MCP302 :

Effectuez les connexions suivantes avec les broches du MCP3002 :

• Connectez la broche 1 à la broche 8 GPIO Raspberry Pi (CE0)
• Connectez la broche 2 à la sortie analogique de la carte de dérivation du microphone MEMS
• Connectez la broche 4 à GND
• Connectez la broche 5 à la broche 10 GPIO du Raspberry Pi (MOSI)
• Connectez la broche 6 à la broche 9 GPIO du Raspberry Pi (MISO)
• Connectez la broche 7 à la broche 11 GPIO du Raspberry Pi (SCLK)
• Connectez la broche 8 à la sortie Raspberry Pi 3,3 V

2. Souder les fils à la carte de dérivation du microphone MEMS. Connectez-vous au MCP3002 et au Raspberry Pi.

• Connectez Vcc au Raspberry Pi 3.3V.
• Connectez GND au Raspberry Pi GND
• Connectez l'AUD à la broche 2 du MCP3002

Configuration Pi

RPi connecté !

Étape 1 :Vérifier et installer les mises à jour

Recherchez et installez les mises à jour :
sudo apt-get update
sudo apt-get upgrade
sudo reboot

Étape 2 :Configurer l'interface SPI pour le microphone MEMS + MCP3002

Installez le package Python Dev :
sudo apt-get install python-dev

Créez un sous-dossier et installez l'interface de port série ("SPI") :
mkdir py-spidev
git clone git://github.com/doceme/py-spidev
sudo python setup. py installer

Voici la documentation SPI-Dev si vous rencontrez des problèmes.

Étape 3 :Jouer des sons avec OMXPlayer

L'OMXPlayer est un lecteur audio et vidéo préchargé sur Raspbian OS (woo!). Il fonctionne avec la plupart des types de fichiers audio, notamment :.wav, .mp3 et .m4a. Nous l'utiliserons pour jouer nos sons « aboiements ».

Dans le terminal, testez l'OMXPlayer à l'aide de la commande suivante :
omxplayer /home/pi/…/SongFilePath/SongFileName.mp3

Si cela ne fonctionne pas, essayez de le forcer sur le périphérique de sortie audio local :
omxplayer -o local /home/pi/…/SongFilePath/SongFileName.mp3

Étape 4 :Configurer le serveur CloudMQTT

Maintenant, nous mettons en place un serveur MQTT ! Pour ce faire à l'aide de CloudMQTT, procédez comme suit :

1. Configurez un compte CloudMQTT (le forfait "Cute Cat" est gratuit).
2. Créez une nouvelle instance MyCloud.
3. Dans la console, créez une nouvelle règle ACL.
4. Vous pouvez surveiller les messages publiés dans l'« interface utilisateur Websocket » de votre console CloudMQTT.

Enfin, installez la bibliothèque Python MQTT Paho Client :
pip install paho-mqtt

Configuration du logiciel

Notre objectif avec le Bark Back est double :(1) déclencher un fichier audio lorsque le chien aboie et (2) envoyer les données de niveau de volume à un serveur.

Mais nous avons d'abord besoin de quelques sons « aboiements » pour jouer ! Vous pouvez facilement enregistrer des sons dans GarageBand (ou sur votre smartphone) et les envoyer au Raspberry Pi. Enregistrez les fichiers dans un emplacement facilement accessible (par exemple, le bureau).

Vous êtes maintenant prêt à écrire un programme Python Bark Back ! …Ou utilisez simplement le mien :

Voici le référentiel GitHub pour ce projet. Vous pouvez également copier et coller le code ci-dessous (n'oubliez pas qu'il s'agit de Python !).
########################### ########################
#Bark Back :Surveillez et interagissez avec les animaux de compagnie !##
##### ################################################
# Code écrit par jelfoxbot <[email protected]>
# Le code est open-source, licence café/bière.
# Veuillez conserver l'en-tête + si vous aimez le contenu,
# achetez-moi un café et/ou une bière si vous me rencontrez !
################################ ######################

# Un grand merci aux personnes qui créent et documentent les bibliothèques
# et les fonctions utilisées dans ce projet.

#Bibliothèques
#SPI
import spidev
#OMXPlayer
à partir du thread import Thread
import subprocess
#MQTT
import paho.mqtt.client as paho
#Autre
import random, time, os, urlparse
import time

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

creds ={
« URL CloudMQTT » : « INSERT_CLOUDMQTT_URL », #par exemple. 'https://m10.cloudmqtt.com'
'utilisateur' :'INSERT_CLOUDMQTT_USERNAME',
'mot de passe' :'INSERT__CLOUDMQTT_PASSWORD',
'hôte' :'INSERT_CLOUDMQTT_SERVER'
'port' :'INSERT_CLOUDMQTT_PORT',
'sujet' :'INSERT_ACL_TOPIC'
}

##################################################### ######
# Lecture de la carte de déploiement de microphone SparkFun MEMS
############################# ###########################
#Démarrer le protocole SPI.
spi =spidev.SpiDev()
spi.open(0,0) #Ceci est la broche CE0 (GPIO 08) sur le RPi, pour CE1, utilisez (0,1)

#Fonction à lire dans le canal CE0
def read_spi(canal):
spidata =spi.xfer2([96,0]) ##envoi de 2 octets de données (96 et 0)
data =((spidata[0] &3) <<8) + spidata[1]
renvoie les données

#Fonction pour calculer l'amplitude crête à crête à partir du micro MEMS
def PTPAmp() :
sampleTime =0,05 #Taux d'échantillonnage de 50 ms
startTime =time.time()

PTPAmp =0
maxAmp =0
minAmp =1023

while(time.time() – startTime micOut =read_spi(0) #Lire dans le canal CE0
if(micOut <1023) :#Empêcher les lectures erronées
if(micOut> maxAmp):
maxAmp =micOut
elif(micOut minAmp =micOut

PTPAmp =maxAmp – minAmp #Calculer l'ampli crête à crête.
retourner PTPAmp

#Fonction pour mapper un ampli crête à crête sur une unité de volume comprise entre 0 et 10
def VolumeUnit(data, fromLow, fromHigh, toLow, toHigh):
return (data – fromLow) * (toHigh – toLow) / (fromHigh – fromLow) + toLow

##################################################### ######
# Classe pour contrôler OMXPlayer pour l'audio
############################# ###########################
class OMXPlayer() :
def call_omxplayer(self) :
print ("lecture de " + 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) :
sinon 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()

#Function pour sélectionner une chanson au hasard dans la liste
def pickRandom(songList):
return(random.choice(songList))

##################################################### ######
# Serveur CloudMQTT
################################## #######################
# Définir les rappels d'événements
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("Abonné :" + str(mid) + " " + str(granted_qos))

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

##################################################### ######
# Fonction principale
################################ ######################
def main() :
#Appeler Paho Python Client Server
mqttc =paho. Client()
#Attribuer des rappels d'événements
mqttc.on_message =on_message
mqttc.on_connect =on_connect
mqttc.on_publish =on_publish
mqttc.on_subscribe =on_subscribe

# Décommentez pour activer les messages de débogage
#mqttc.on_log =on_log

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

# Commencez à vous abonner, avec le niveau de QoS 0
mqttc.subscribe(creds[‘topic’], 0)

tandis que True :
#1. Trouver la valeur ADC pour l'ampli micro MEMS crête à crête
PTPamp =PTPAmp()
#2. Calculer ptp amp (Volts)
PTPampV =round(((PTPamp*3.3) / 1024), 2)
#3. Mapper ptp amp (valeur ADC) à l'unité de volume entre 0 et 10
VolUnit =VolumeUnit(PTPamp, 0, 700, 0, 10)

#À des fins de débogage
print(PTPamp, VolUnit)

#4. Si l'unité de volume est supérieure à 7, jouez l'une des chansons
if(VolUnit> 7):
playBack =pickRandom(songList)
OMXPlayer(playBack)
time.sleep( 0.1)

#5. Télécharger des données sur le serveur CloudMQTT
mqttc.publish(« Volume », str(VolUnit))
rc =True
tandis que rc :
rc =mqttc.loop()
time.sleep(0.1)
print("rc:" + str(rc))

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

if __name__ =='__main__' :
main()

Pour que le système Bark Back fonctionne correctement, remplissez les champs suivants :

• liste des chansons  : écrivez le chemin d'accès et le nom du fichier pour chacune des chansons que vous souhaitez lire.
• crédits  :saisissez vos informations CloudMQTT dans ce dictionnaire.

N'hésitez pas à (et veuillez le faire) ajuster et modifier le code :consultez les Ressources et aller plus loin section pour les variations et les ajouts du projet.

Lire plus d'informations…

Moniteur interactif pour animaux de compagnie Bark Back