Monitor de animais interativos Bark Back

Lance alguma luz (er, som) sobre os mistérios indescritíveis das travessuras de seus animais de estimação enquanto você está longe de casa! Este projeto Bark Back da Internet das Coisas (IoT) monitora e carrega o nível de ruído em sua casa para a nuvem para que você possa verificar seus amados animais de estimação. A melhor parte:se ficar muito alto (ou seja, Fido está latindo ou fazendo alguma outra confusão), o programa reproduz seu próprio arquivo de áudio "latir" para ajudar a distrair e acalmar o filhote.





Este projeto usa um Raspberry Pi para ler a placa de breakout do microfone SparkFun MEMS e acionar um reprodutor de áudio. Os dados são carregados para o serviço CloudMQTT usando o protocolo de comunicação MQTT.

Para uma demonstração, confira o vídeo abaixo!

Abordado neste tutorial

Este tutorial mostrará como fazer o seguinte:

• Conecte e leia no microfone SparkFun MEMS usando o Raspberry Pi 3
• Carregue o nível de volume para o serviço CloudMQTT
• Use um limite de volume para disparar o seu “latido” para o seu cão se ele ficar muito barulhento

Leitura sugerida

Para construir este projeto, você precisará de um Raspberry Pi 3 conectado por Wi-Fi totalmente configurado com Raspbian OS. Também é útil saber um pouco de programação Python, bem como as três coisas a seguir:(1) usar e controlar os pinos GPIO do Raspberry Pi, (2) comunicação MQTT e (3) sinais analógicos. Se alguma dessas coisas não lhe for familiar ou se você estiver apenas curioso (seja curioso!)

Protocolo de comunicação MQTT

MQTT (Message Query Telemetry Transport) é um protocolo de comunicação IoT popular. Usaremos a biblioteca Paho Client Python e um serviço MQTT chamado CloudMQTT.

1. Explorando protocolos de comunicação para IoT
2. Primeiros passos com CloudMQTT
3. Visão geral da biblioteca cliente Eclipse Paho MQTT Python

Quadro de discussão do microfone MEMS

O microfone MEMS é um microfone analógico, então você precisará do conversor analógico-digital MCP3002 (“ADC”) para ler o sinal analógico com os pinos GPIO digitais Raspberry Pi.

1. Primeiros passos com o SparkFun MEMS Microphone Breakout Board
2. Folha de dados do microfone MEMS
3. Folha de dados do ADC MCP3002

Materiais

Você precisará dos seguintes materiais para acompanhar.

Bark Back:Monitore e interaja com animais de estimação! Lista de desejos SparkFun

Conversor analógico para digital - MCP3002

SparkFun MEMS Microphone Breakout - INMP401 (ADMP401)

Breadboard - Autoadesivo (branco)

Jumper Wires - Conectado 6 ″ (M / M, 20 pack)

Fonte de alimentação do adaptador de parede - 5 V CC 2A (USB Micro-B)

Cabo de fita GPIO Raspberry Pi - 40 pinos, 6 ″ (RPi 3, RPi2, B +)

Raspberry Pi LCD - 7 ″ Touchscreen

Raspberry Pi 3

Raspberry Pi ™ - Cartão MicroSD NOOBS de 16 GB

Raspberry Pi 3 + Câmera - transparente

Você também precisará do seguinte:

• Cabo de alimentação MicroUSB
• cabo HDMI
• teclado USB
• mouse USB
• Alto-falantes com porta de fone de ouvido de 1/8 ″

Conexão de hardware

Conectando o Pi ao outro hardware. Clique no diagrama de fiação para uma visão mais detalhada.

Aqui está o diagrama de pinagem do Raspberry Pi 2 (e 3) Modelo B:

1 Conecte o MCP3002 ao Raspberry Pi.





Close-up do MCP3002

Existem quatro pinos SPI para comunicação SPI:Serial Clock (“SCL”), Master Input Slave Output (“MISO”), Master Output Slave Input (“MOSI”) e Chip Select (“CS”). Esses pinos correspondem ao pino 11 do Raspberry Pi GPIO (SCLK), pino 9 do GPIO (MISO), pino 10 do GPIO (MOSI) e pino 8 do GPIO (CE0), respectivamente.

Aqui está o diagrama de pinagem MCP302:





Faça as seguintes conexões com os pinos MCP3002:

• Conecte o pino 1 ao pino 8 do Raspberry Pi GPIO (CE0)
• Conecte o pino 2 à saída analógica da placa de breakout do microfone MEMS
• Conecte o pino 4 ao GND
• Conecte o pino 5 ao pino 10 do Raspberry Pi GPIO (MOSI)
• Conecte o pino 6 ao pino 9 do Raspberry Pi GPIO (MISO)
• Conecte o pino 7 ao pino 11 do Raspberry Pi GPIO (SCLK)
• Conecte o pino 8 à saída Raspberry Pi 3.3V

2. Solde os fios na placa de fuga do microfone MEMS. Conecte-se a MCP3002 e Raspberry Pi.

• Conecte o Vcc ao Raspberry Pi 3.3V.
• Conecte o GND ao Raspberry Pi GND
• Conecte AUD ao MCP3002 pino 2

Configuração Pi

RPi conectado!

Etapa 1:Verificar e instalar atualizações

Verifique e instale atualizações:
sudo apt-get update
sudo apt-get upgrade
sudo reboot

Etapa 2:Configurar interface SPI para microfone MEMS + MCP3002

Instale o pacote Python Dev:
sudo apt-get install python-dev

Crie uma subpasta e instale a interface de porta serial (“SPI”):
mkdir py-spidev
git clone git://github.com/doceme/py-spidev
configuração do sudo python. py install

Aqui está a documentação do SPI-Dev se você tiver algum problema.

Etapa 3:Tocando sons com OMXPlayer

O OMXPlayer é um reprodutor de áudio e vídeo pré-carregado no Raspbian OS (woo!). Funciona com a maioria dos tipos de arquivos de som, incluindo:.wav, .mp3 e .m4a. Vamos usar isso para tocar nossos sons de "latido".

No terminal, teste o OMXPlayer usando o seguinte comando:
omxplayer /home/pi/…/SongFilePath/SongFileName.mp3

Se isso não funcionar, tente forçar no dispositivo de saída de áudio local:
omxplayer -o local /home/pi/…/SongFilePath/SongFileName.mp3

Etapa 4:Configurar o servidor CloudMQTT

Agora configuramos um servidor MQTT! Para fazer isso usando CloudMQTT, faça o seguinte:

1. Configure uma conta CloudMQTT (o plano “Cute Cat” é gratuito).
2. Crie uma nova instância MyCloud.
3. No console, crie uma nova regra ACL.
4. Você pode monitorar as mensagens publicadas no “Websocket UI” do seu console CloudMQTT.

Finalmente, instale a biblioteca MQTT Paho Client Python:
pip install paho-mqtt

Configuração do software

Nosso objetivo com o Bark Back é duplo:(1) acionar um arquivo de áudio quando o cachorro late e (2) enviar os dados de nível de volume para um servidor.





Mas primeiro precisamos de alguns sons de “latido” para tocar! Você pode gravar sons facilmente no GarageBand (ou no seu smartphone) e enviá-los para o Raspberry Pi. Salve os arquivos em um local de fácil acesso (por exemplo, área de trabalho).

Agora você está pronto para escrever um programa Bark Back Python! … Ou apenas use o meu:

Aqui está o repositório GitHub para este projeto. Você também pode copiar e colar o código abaixo (lembre-se de que é Python!).
################################# #################################
#Bark Back:Monitore e Interaja com Animais de Estimação! ##
##### ############################################################
# Código escrito por jenfoxbot <[email protected]>
# O código é de código aberto, licença para café / cerveja.
# Por favor, mantenha o cabeçalho + se você gostar do conteúdo,
# compre-me um café e / ou cerveja se me encontrar!
##################################### ##########################

# Muito obrigado às pessoas que criaram e documentaram as bibliotecas
# e funções usadas neste projeto.

# Bibliotecas
#SPI
importar spidev
#OMXPlayer
do threading importar Thread
importar subprocesso
#MQTT
importar paho.mqtt.client como paho
#Outro
import random, time, os, urlparse
import time

songList =[“SongFile1”, # por exemplo. “/Home/pi/Desktop/SongFile.mp3”
“SongFile2”,
“SongFile3”,
“SongFile4”]

creds ={
‘CloudMQTT URL’:‘INSERT_CLOUDMQTT_URL’, # por exemplo 'https://m10.cloudmqtt.com'
'usuário':'INSERT_CLOUDMQTT_USERNAME',
'senha':'INSERT__CLOUDMQTT_PASSWORD',
'host':'INSERT_CLOUDMQTT_SERVER'
'porta':'INSERT_CLOUDMQTT_PORT',
'tópico':'INSERT_ACL_TOPIC'
}

############################################################### #######
# Reading SparkFun MEMS Microphone Breakout Board
##################################################################################################################### ####################################
#Iniciar protocolo SPI.
spi =spidev.SpiDev ()
spi.open (0,0) #Este é o Pino CE0 (GPIO 08) no RPi, para CE1, use (0,1)

#Função para ler no canal CE0
def read_spi (canal):
spidata =spi.xfer2 ([96,0]) ## enviando 2 bytes de dados (96 e 0)
dados =((spidata [0] &3) <<8) + spidata [1]
dados de retorno

#Função para calcular a amplitude de pico a pico de MEMS mic
def PTPAmp ():
sampleTime =0,05 # Taxa de amostra de 50 ms
startTime =time.time ()

PTPAmp =0
maxAmp =0
minAmp =1023

while (time.time () - startTime micOut =read_spi (0) #Leia no canal CE0
if (micOut <1023):#Prevent leituras erradas
if (micOut> maxAmp):
maxAmp =micOut
elif (micOut minAmp =micOut

PTPAmp =maxAmp - minAmp # Calcular amp pico a pico.
retornar PTPAmp

#Função para mapear amp pico a pico para uma unidade de volume entre 0 e 10
def VolumeUnit (dados, deLow, fromHigh, toLow, toHigh):
return (data - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow

############################################################### ########
# Classe para controlar OMXPlayer para áudio
#################################################################################################################### ###################################
classe OMXPlayer ():
def call_omxplayer (self):
print (“jogando“ + 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):
se não 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 ()

#Função para selecionar música aleatória da lista
def pickRandom (songList):
return (random.choice (songList))

############################################################### #######
# Servidor CloudMQTT
####################################### ################################
# Definir callbacks de evento
def on_connect (mosq, obj, rc):
imprimir (“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 (“Inscrito:“ + str (mid) + ”“ + str (concedido_qos))

def on_log (mosq, obj, nível, string):
print (string)

############################################################### #######
# Função principal
####################################### #################################
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

# Remova o comentário para habilitar mensagens de depuração
# mqttc.on_log =on_log

# Analisar CLOUDMQTT_URL (ou fallback para localhost)
url_str =os.environ.get (creds ['CloudMQTT URL'], 'mqtt:// localhost:1883')
url =urlparse.urlparse (url_str )

# Connect
mqttc.username_pw_set (creds [‘usuário’], creds [‘senha’])
mqttc.connect (creds [‘host’], creds [‘porta’])

# Comece a assinar, com QoS nível 0
mqttc.subscribe (creds [‘tópico’], 0)

enquanto verdadeiro:
# 1. Encontre o valor ADC para o amplificador pico a pico do microfone MEMS
PTPamp =PTPAmp ()
# 2. Calcule amp ptp (Volts)
PTPampV =redondo (((PTPamp * 3.3) / 1024), 2)
# 3. Mapeie o amp ptp (valor ADC) para a unidade de volume entre 0 e 10
VolUnit =VolumeUnit (PTPamp, 0, 700, 0, 10)

#Para fins de depuração
imprimir (PTPamp, VolUnit)

# 4. Se a unidade de volume for maior que 7, toque uma das músicas
if (VolUnit> 7):
playBack =pickRandom (songList)
OMXPlayer (playBack)
time.sleep ( 0,1)

# 5. Carregar dados para CloudMQTT Server
mqttc.publish (“Volume”, str (VolUnit))
rc =True
enquanto rc:
rc =mqttc.loop ()
time.sleep (0.1)
print (“rc:“ + str (rc))

try:
enquanto True:
passar
exceto KeyboardInterrupt:
myprocess.kill ()

if __name__ ==‘__main__’:
principal ()

Para que o sistema Bark Back funcione corretamente, preencha o seguinte:

• songList :Escreva o caminho e o nome do arquivo para cada uma das músicas que deseja tocar.
• creds :Insira suas informações CloudMQTT neste dicionário.

Sinta-se à vontade para ajustar e modificar o código (e faça-o) - confira Recursos e informações adicionais seção para variações e acréscimos do projeto.

Leia mais informações ...

Bark Back Interactive Pet Monitor

Postura Pal com Walabot Usando o sensor de radar pulsado A111 com um Raspberry Pi