Monitor interactivo de mascotas con ladridos

¡Arroja algo de luz (eh, sonido) sobre los elusivos misterios de las payasadas de tus mascotas mientras están fuera de casa! Este proyecto Bark Back de Internet de las cosas (IoT) monitorea y carga el nivel de ruido en su hogar a la nube para que pueda controlar a sus queridas mascotas. La mejor parte:si se pone demasiado fuerte (es decir, Fido está ladrando o haciendo algún otro alboroto), el programa reproduce su propio archivo de audio de "ladrido" para ayudar a distraer y calmar al cachorro.

Este proyecto utiliza una Raspberry Pi para leer la placa de conexión del micrófono SparkFun MEMS y activar un reproductor de audio. Los datos se cargan en el servicio CloudMQTT utilizando el protocolo de comunicación MQTT.

¡Para ver una demostración, vea el video a continuación!

Cubierto en este tutorial

Este tutorial le mostrará cómo hacer lo siguiente:

Conecta y lee en el micrófono SparkFun MEMS usando la Raspberry Pi 3
Sube el nivel de volumen al servicio CloudMQTT
Use un umbral de volumen para activar su "ladrido" a su perro si se vuelve demasiado ruidoso

Lectura sugerida

Para construir este proyecto, necesitará una Raspberry Pi 3 con sistema operativo Raspbian completamente configurada y conectada a WiFi. También es útil conocer algo de programación en Python, así como las siguientes tres cosas:(1) usar y controlar los pines GPIO de Raspberry Pi, (2) comunicación MQTT y (3) señales analógicas. Si algo de esto no le resulta familiar, o si simplemente siente curiosidad (¡tenga curiosidad!)

Protocolo de comunicación MQTT

MQTT (Message Query Telemetry Transport) es un protocolo de comunicación de IoT popular. Usaremos la biblioteca Python del cliente Paho y un servicio MQTT llamado CloudMQTT.

Exploración de protocolos de comunicación para IoT
Introducción a CloudMQTT
Descripción general de la biblioteca cliente Python de Eclipse Paho MQTT

Placa de conexión de micrófono MEMS

El micrófono MEMS es un micrófono analógico, por lo que necesitará el convertidor analógico a digital ("ADC") MCP3002 para leer la señal analógica con los pines GPIO digitales de la Raspberry Pi.

Introducción a la placa de conexión de micrófono SparkFun MEMS
Hoja de datos del micrófono MEMS
Hoja de datos de MCP3002 ADC

Materiales

Necesitará los siguientes materiales para seguir adelante.

Bark Back:¡Monitorea e interactúa con mascotas! Lista de deseos de SparkFun

: Convertidor de analógico a digital - MCP3002

: Interrupción del micrófono SparkFun MEMS - INMP401 (ADMP401)

: Placa de pruebas:autoadhesiva (blanca)

: Cables de puente:conectados 6 ″ (M / M, paquete de 20)

: Fuente de alimentación del adaptador de pared - 5 V CC 2 A (USB Micro-B)

: Cable plano GPIO de Raspberry Pi - 40 pines, 6 ″ (RPi 3, RPi2, B +)

: Raspberry Pi LCD - Pantalla táctil de 7 ″

: Raspberry Pi 3

: Raspberry Pi ™ - Tarjeta MicroSD NOOBS de 16GB

: Carcasa para cámara Raspberry Pi 3 + - Transparente

También necesitará lo siguiente:

Cable de alimentación microUSB
cable HDMI
Teclado USB
Ratón USB
Altavoces con puerto para auriculares de 1/8 "

Conexión de hardware

Conexión de la Pi al otro hardware. Haga clic en el diagrama de cableado para ver más de cerca.

Aquí está el diagrama de distribución de pines del modelo B de Raspberry Pi 2 (y 3):

1. Conecte el MCP3002 a la Raspberry Pi.

Primer plano del MCP3002

Hay cuatro pines SPI para la comunicación SPI:reloj serial (“SCL”), entrada maestra, salida esclava (“MISO”), salida maestra, entrada esclava (“MOSI”) y selección de chip (“CS”). Estos pines corresponden al pin 11 (SCLK) de Raspberry Pi GPIO, pin 9 de GPIO (MISO), pin 10 de GPIO (MOSI) y pin 8 de GPIO (CE0), respectivamente.

Aquí está el diagrama de distribución de pines del MCP302:

Realice las siguientes conexiones con los pines MCP3002:

Conecte el pin 1 al pin 8 de GPIO de Raspberry Pi (CE0)
Conecte el pin 2 a la salida analógica de la placa de conexión del micrófono MEMS
Conecte el pin 4 a GND
Conecte el pin 5 al pin 10 de GPIO de Raspberry Pi (MOSI)
Conecte el pin 6 al pin 9 de GPIO de Raspberry Pi (MISO)
Conecte el pin 7 al pin 11 de GPIO de Raspberry Pi (SCLK)
Conecte el pin 8 a la salida de 3.3V de Raspberry Pi

2. Suelde los cables a la placa de conexión del micrófono MEMS. Conéctese a MCP3002 y Raspberry Pi.

Conecte Vcc a Raspberry Pi 3.3V.
Conecte GND a Raspberry Pi GND
Conecte AUD al pin 2 del MCP3002

Configuración de Pi

¡RPi conectado!

Paso 1:comprobar e instalar actualizaciones

Busque e instale actualizaciones:
sudo apt-get update
sudo apt-get upgrade
sudo reboot

Paso 2:Configure la interfaz SPI para el micrófono MEMS + MCP3002

Instale el paquete Python Dev:
sudo apt-get install python-dev

Cree una subcarpeta e instale la Interfaz de puerto serie ("SPI"):
mkdir py-spidev
git clone git://github.com/doceme/py-spidev
sudo python setup. instalación py

Aquí está la documentación de SPI-Dev si tiene algún problema.

Paso 3:reproducción de sonidos con OMXPlayer

El OMXPlayer es un reproductor de audio y video precargado en Raspbian OS (¡woo!). Funciona con la mayoría de los tipos de archivos de sonido, incluidos:.wav, .mp3 y .m4a. Usaremos esto para reproducir nuestros sonidos de "ladrido".

En la terminal, pruebe OMXPlayer con el siguiente comando:
omxplayer /home/pi/…/SongFilePath/SongFileName.mp3

Si eso no funciona, intente forzarlo a través del dispositivo de salida de audio local:
omxplayer -o local /home/pi/…/SongFilePath/SongFileName.mp3

Paso 4:Configurar el servidor CloudMQTT

¡Ahora configuramos un servidor MQTT! Para hacer esto usando CloudMQTT, haga lo siguiente:

Configure una cuenta de CloudMQTT (el plan "Cute Cat" es gratuito).
Cree una nueva instancia de MyCloud.
En la consola, cree una nueva regla de ACL.
Puede monitorear los mensajes publicados en la "IU de Websocket" de su consola CloudMQTT.

Finalmente, instale la biblioteca Python del cliente Paho MQTT:
pip install paho-mqtt

Configuración del software

Nuestro objetivo con Bark Back es doble:(1) activar un archivo de audio cuando el perro ladra y (2) enviar los datos del nivel de volumen a un servidor.

¡Pero primero necesitamos algunos sonidos de "ladrido" para reproducir! Puede grabar fácilmente sonidos en GarageBand (o en su teléfono inteligente) y enviarlos a la Raspberry Pi. Guarde los archivos en una ubicación de fácil acceso (por ejemplo, escritorio).

¡Ahora está listo para escribir un programa Bark Back Python! ... O simplemente usa el mío:

Aquí está el repositorio de GitHub para este proyecto. También puede copiar y pegar el código a continuación (¡tenga en cuenta que esto es Python!).
##################################################################### ########################
#Bark Back:¡Monitorea e interactúa con mascotas! ##
##### ############################################
# Código escrito por jenfoxbot <[email protected]>
# El código es de código abierto, licencia para café / cerveza.
# Conserve el encabezado + si le gusta el contenido,
# ¡Cómprame un café y / o cerveza si te encuentras conmigo!
############################## #####################

# Muchas gracias a las personas que crean y documentan las bibliotecas
# y las funciones utilizadas en este proyecto.

#Bibliotecas
#SPI
importar spidev
#OMXPlayer
desde subproceso importar subproceso
importar subproceso
#MQTT
importar paho.mqtt.client as paho
#Otros
import random, time, os, urlparse
import time

songList =["SongFile1", # p. ej. “/Home/pi/Desktop/SongFile.mp3”
“SongFile2”,
“SongFile3”,
“SongFile4”]

creds ={
"URL de CloudMQTT":"INSERT_CLOUDMQTT_URL", # p. ej. 'https://m10.cloudmqtt.com'
'usuario':'INSERT_CLOUDMQTT_USERNAME',
'contraseña':'INSERT__CLOUDMQTT_PASSWORD',
'host':'INSERT_CLOUDMQTT_SERVER'
'puerto':'INSERT_CLOUDMQTT_PORT',
'tema':'INSERT_ACL_TOPIC'
}

################################################ ######
# Lectura SparkFun MEMS Microphone Breakout Board
########################### ##########################
#Iniciar el protocolo SPI.
spi =spidev.SpiDev ()
spi.open (0,0) # Este es el Pin CE0 (GPIO 08) en el RPi, para CE1, use (0,1)

#Función para leer en el canal CE0
def read_spi (canal):
spidata =spi.xfer2 ([96,0]) ## enviando 2 bytes de datos (96 y 0)
datos =((spidata [0] &3) <<8) + spidata [1]
devolver datos

#Función para calcular la amplitud pico a pico desde el micrófono MEMS
def PTPAmp ():
sampleTime =0.05 #Sample Rate of 50 ms
startTime =time.time ()

PTPAmp =0
maxAmp =0
minAmp =1023

while (time.time () - startTime micOut =read_spi (0) #Leer en el canal CE0
if (micOut <1023):#Evitar lecturas erróneas
if (micOut> maxAmp):
maxAmp =micOut
elif (micOut minAmp =micOut

PTPAmp =maxAmp - minAmp # Calcular el amperaje pico a pico.
return PTPAmp

#Función para mapear amplificador pico a pico a una unidad de volumen entre 0 y 10
def VolumeUnit (data, fromLow, fromHigh, toLow, toHigh):
return (data - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow

################################################ ######
# Clase para controlar OMXPlayer para audio
########################### ##########################
class OMXPlayer ():
def call_omxplayer (self):
print ("reproduciendo" + self.file_path + '\ n')
pid =subprocess.Popen (['omxplayer', '-o', 'local',
self.file_path], stderr =subproceso.PIPE,
stdout =subproceso.PIPE)
self.is_running =False

def play_song (self):
si no self.is_running:
self.song_thread =Thread (target =self.call_omxplayer, args =())
self.song_thread.start ()
self.is_running =Verdadero

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

#Función para seleccionar una canción aleatoria de la lista
def pickRandom (songList):
return (random.choice (songList))

################################################ ######
# CloudMQTT Server
############################### ######################
# Define callbacks de eventos
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, given_qos):
print ("Suscrito:" + str (mid) + "" + str (given_qos))

def on_log (mosq, obj, nivel, cadena):
print (cadena)

################################################ ######
# Función principal
############################### ######################
def main ():
#Call Paho Python Client Server
mqttc =paho. Cliente ()
# Asignar devoluciones de llamada de eventos
mqttc.on_message =on_message
mqttc.on_connect =on_connect
mqttc.on_publish =on_publish
mqttc.on_subscribe =on_subscribe

# Descomentar para habilitar mensajes de depuración
# mqttc.on_log =on_log

# Analizar CLOUDMQTT_URL (o volver a localhost)
url_str =os.environ.get (creds ['CloudMQTT URL'], 'mqtt:// localhost:1883')
url =urlparse.urlparse (url_str )

# Connect
mqttc.username_pw_set (creds ["usuario"], creds ["contraseña"])
mqttc.connect (creds ["host"], creds ["puerto"])

# Comience a suscribirse, con QoS nivel 0
mqttc.subscribe (creds ["tema"], 0)

mientras que Verdadero:
# 1. Encuentre el valor ADC para el amplificador pico a pico del micrófono MEMS
PTPamp =PTPAmp ()
# 2. Calcule el amperaje ptp (voltios)
PTPampV =round (((PTPamp * 3.3) / 1024), 2)
# 3. Asigne el amplificador ptp (valor ADC) a la unidad de volumen entre 0 y 10
VolUnit =VolumeUnit (PTPamp, 0, 700, 0, 10)

# Para fines de depuración
print (PTPamp, VolUnit)

# 4. Si la unidad de volumen es mayor que 7, reproduce una de las canciones
si (VolUnit> 7):
playBack =pickRandom (songList)
OMXPlayer (playBack)
time.sleep ( 0.1)

# 5. Subir datos al servidor CloudMQTT
mqttc.publish ("Volumen", str (VolUnit))
rc =True
while rc:
rc =mqttc.loop ()
time.sleep (0.1)
print ("rc:" + str (rc))

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

if __name__ ==‘__main__’:
main ()

Para que el sistema Bark Back funcione correctamente, complete lo siguiente:

lista de canciones :Escriba la ruta del archivo y el nombre del archivo para cada una de las canciones que desea reproducir.
créditos :Ingrese su información de CloudMQTT en este diccionario.

Siéntase libre de (y hágalo) ajustar y modificar el código. Consulte Recursos y más. sección para variaciones y adiciones del proyecto.

Leer más información…

Monitor interactivo para mascotas Bark Back

Posture Pal con Walabot Uso del sensor de radar pulsado A111 con una Raspberry Pi

Proceso de manufactura

Impresión 3d

Sistema de control de automatización

Tecnología Industrial