Bark Back Interactive Pet Monitor

Jelaskan (er, suara) pada misteri yang sulit dipahami dari kejenakaan hewan peliharaan Anda saat jauh dari rumah! Proyek Internet of Things (IoT) Bark Back ini memantau dan mengunggah tingkat kebisingan di rumah Anda ke Cloud sehingga Anda dapat memeriksa hewan peliharaan kesayangan Anda. Bagian terbaiknya:jika terlalu keras (yaitu, Fido menggonggong atau membuat keributan lainnya), program akan memutar file audio "menggonggong" Anda sendiri untuk membantu mengalihkan perhatian dan menenangkan anak anjing.

Project ini menggunakan Raspberry Pi untuk membaca papan breakout mikrofon MEMS SparkFun dan memicu pemutar audio. Data diunggah ke layanan CloudMQTT menggunakan protokol komunikasi MQTT.

Untuk demo, lihat video di bawah ini!

Dibahas dalam Tutorial Ini

Tutorial ini akan menunjukkan cara melakukan hal berikut:

• Hubungkan dan baca di Mikrofon MEMS SparkFun menggunakan Raspberry Pi 3
• Unggah tingkat volume ke layanan CloudMQTT
• Gunakan ambang batas volume untuk memicu "gonggongan balik" pada anjing Anda jika dia terlalu berisik

Bacaan yang Disarankan

Untuk membuat project ini, Anda memerlukan Raspberry Pi 3 yang terkonfigurasi sepenuhnya dan terhubung ke WiFi dengan Raspbian OS. Penting juga untuk mengetahui beberapa pemrograman Python serta tiga hal berikut:(1) menggunakan dan mengontrol pin GPIO Raspberry Pi, (2) komunikasi MQTT, dan (3) sinyal analog. Jika ada yang asing, atau jika Anda hanya ingin tahu (jadi penasaran!)

Protokol Komunikasi MQTT

MQTT (Message Query Telemetry Transport) adalah protokol komunikasi IoT yang populer. Kami akan menggunakan library Python Paho Client dan layanan MQTT yang disebut CloudMQTT.

1. Menjelajahi Protokol Komunikasi untuk IoT
2. Memulai CloudMQTT
3. Ikhtisar Pustaka Klien Python Eclipse Paho MQTT

Papan Breakout Mikrofon MEMS

Mikrofon MEMS adalah mikrofon analog, jadi Anda memerlukan MCP3002 Analog-to-Digital converter (“ADC”) untuk membaca sinyal analog dengan pin GPIO digital Raspberry Pi.

1. Memulai Papan Breakout Mikrofon MEMS SparkFun
2. Lembar Data Mikrofon MEMS
3. Lembar Data ADC MCP3002

Bahan

Anda memerlukan materi berikut untuk diikuti.

Bark Back:Pantau &Berinteraksi dengan Hewan Peliharaan! Daftar Keinginan SparkFun

Konverter Analog ke Digital – MCP3002

Breakout Mikrofon MEMS SparkFun – INMP401 (ADMP401)

Breadboard – Self-Adhesive (Putih)

Kabel Jumper – Terhubung 6″ (M/M, 20 paket)

Catu Daya Adaptor Dinding – 5V DC 2A (USB Micro-B)

Kabel Pita GPIO Raspberry Pi – 40-pin, 6″ (RPi 3, RPi2, B+)

LCD Raspberry Pi – Layar Sentuh 7″

Raspberry Pi 3

Raspberry Pi™ – Kartu MicroSD NOOBS 16GB

Raspberry Pi 3 + Kandang Kamera – Hapus

Anda juga memerlukan yang berikut ini:

• Kabel daya MicroUSB
• Kabel HDMI
• Keyboard USB
• mouse USB
• Speaker dengan port headphone 1/8″

Penghubung Perangkat Keras

Menghubungkan Pi ke perangkat keras lain. Klik diagram pengkabelan untuk melihat lebih dekat.

Berikut diagram pinout Raspberry Pi 2 (dan 3) Model B:

1. Hubungkan MCP3002 ke Raspberry Pi.

Close-up dari MCP3002

Ada empat pin SPI untuk komunikasi SPI:Serial Clock (“SCL”), Master Input Slave Output (“MISO”), Master Output Slave Input (“MOSI”) dan Chip Select (“CS”). Pin ini sesuai dengan Raspberry Pi GPIO pin 11 (SCLK), GPIO pin 9 (MISO), GPIO pin 10 (MOSI) dan GPIO pin 8 (CE0).

Berikut diagram pinout MCP302:

Buat koneksi berikut dengan pin MCP3002:

• Hubungkan pin 1 ke Raspberry Pi GPIO pin 8 (CE0)
• Hubungkan pin 2 ke output analog papan breakout Mikrofon MEMS
• Hubungkan pin 4 ke GND
• Hubungkan pin 5 ke Raspberry Pi GPIO pin 10 (MOSI)
• Hubungkan pin 6 ke Raspberry Pi GPIO pin 9 (MISO)
• Hubungkan pin 7 ke Raspberry Pi GPIO pin 11 (SCLK)
• Hubungkan pin 8 ke Raspberry Pi 3.3V keluar

2. Solder kabel ke papan breakout MEMS Microphone. Hubungkan ke MCP3002 dan Raspberry Pi.

• Hubungkan Vcc ke Raspberry Pi 3.3V.
• Hubungkan GND ke Raspberry Pi GND
• Hubungkan AUD ke MCP3002 Pin 2

Konfigurasi Pi

RPi terhubung!

Langkah 1:Periksa &Instal Pembaruan

Periksa dan instal pembaruan:
Sudo apt-get update
Sudo apt-get upgrade
Sudo reboot

Langkah 2:Siapkan Antarmuka SPI untuk Mikrofon MEMS + MCP3002

Instal paket Python Dev :
Sudo apt-get install python-dev

Buat subfolder dan instal Serial Port Interface (“SPI”):
mkdir py-spidev
git clone git://github.com/doceme/py-spidev
sudo python setup. instal

Berikut Dokumentasi SPI-Dev jika Anda mengalami masalah.

Langkah 3:Memutar Suara dengan OMXPlayer

OMXPlayer adalah pemutar audio dan video yang dimuat sebelumnya di Raspbian OS (woo!). Ia bekerja dengan sebagian besar jenis file suara, termasuk:.wav, .mp3 dan .m4a. Kami akan menggunakan ini untuk memainkan suara “bark back” kami.

Di terminal, uji OMXPlayer menggunakan perintah berikut:
omxplayer /home/pi/…/SongFilePath/SongFileName.mp3

Jika tidak berhasil, coba paksakan melalui perangkat keluaran audio lokal:
omxplayer -o local /home/pi/…/SongFilePath/SongFileName.mp3

Langkah 4:Konfigurasi Server CloudMQTT

Sekarang kami menyiapkan server MQTT! Untuk melakukannya menggunakan CloudMQTT, lakukan hal berikut:

1. Siapkan akun CloudMQTT (paket “Kucing Lucu” gratis).
2. Buat instance MyCloud baru.
3. Di Konsol, buat aturan ACL baru.
4. Anda dapat memantau pesan yang dipublikasikan di “UI Websocket” konsol CloudMQTT Anda.

Terakhir, instal pustaka MQTT Paho Client Python:
pip install paho-mqtt

Pengaturan Perangkat Lunak

Tujuan kami dengan Bark Back ada dua:(1) memicu file audio saat anjing menggonggong dan (2) mengirim data tingkat volume ke server.

Tapi pertama-tama kita perlu beberapa suara "menggonggong" untuk dimainkan! Anda dapat dengan mudah merekam suara di GarageBand (atau di ponsel cerdas Anda) dan mengirimkannya ke Raspberry Pi. Simpan file di lokasi yang mudah diakses (mis., Desktop).

Sekarang Anda siap untuk menulis program Bark Back Python! …Atau gunakan saja milik saya:

Berikut Repositori GitHub untuk project ini. Anda juga dapat menyalin dan menempelkan kode di bawah ini (ingat ini Python!).
######################################## ########################
#Bark Back:Memantau &Berinteraksi dengan Hewan Peliharaan!##
##### ###############################################################
# Kode ditulis oleh jenfoxbot <[email protected]>
# Kode open-source, lisensi coffee/beer-ware.
# Harap simpan header + jika Anda menyukai kontennya,
# belikan saya kopi dan/atau bir jika Anda bertemu saya!
############################################ ####################

# Banyak terima kasih kepada orang-orang yang membuat &mendokumentasikan perpustakaan
# dan fungsi yang digunakan dalam proyek ini.

#Libraries
#SPI
import spidev
#OMXPlayer
dari threading import Thread
import subprocess
#MQTT
import paho.mqtt.client sebagai paho
#Other
import random, time, os, urlparse
import time

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

creds ={
‘CloudMQTT URL’:‘INSERT_CLOUDMQTT_URL’, #mis. 'https://m10.cloudmqtt.com'
'pengguna':'INSERT_CLOUDMQTT_USERNAME',
'sandi':'INSERT__CLOUDMQTT_PASSWORD',
'host':'INSERT_CLOUDMQTT_SERVER'
'port':'INSERT_CLOUDMQTT_PORT',
'topic':'INSERT_ACL_TOPIC'
}

############################################################# ######
# Membaca SparkFun MEMS Microphone Breakout Board
################################### ##########################
#Mulai protokol SPI.
spi =spidev.SpiDev()
spi.open(0,0) #Ini adalah Pin CE0 (GPIO 08) pada RPi, untuk CE1, gunakan (0,1)

#Fungsi membaca di saluran CE0
def read_spi(saluran):
spidata =spi.xfer2([96,0]) ##mengirim 2 byte data (96 dan 0)
data =((spidata[0] &3) <<8) + spidata[1]
mengembalikan data

#Fungsi untuk menghitung Peak to Peak Amplitude dari MEMS mic
def PTPAmp():
sampleTime =0.05 #Sample Rate 50 ms
startTime =time.time()

PTPAmp =0
maxAmp =0
minAmp =1023

while(time.time() – startTime micOut =read_spi(0) #Read in channel CE0
if(micOut <1023):#Cegah pembacaan yang salah
if(micOut> maxAmp):
maxAmp =micOut
elif(micOut minAmp =micOut

PTPAmp =maxAmp – minAmp #Calculate peak-to-peak amp.
kembalikan PTPAmp

#Fungsi untuk memetakan peak-to-peak amp ke unit volume antara 0 dan 10
def VolumeUnit(data, fromLow, fromHigh, toLow, toHigh):
return (data – fromLow) * (toHigh – keRendah) / (dariTinggi – dariRendah) + keRendah

############################################################# ######
# Kelas untuk Mengontrol OMXPlayer untuk Audio
######################################### ###########################
class OMXPlayer():
def call_omxplayer(self):
print (“bermain “ + self.file_path + '\n')
pid =subprocess.Popen(['omxplayer', '-o', 'local',
self.file_path], stderr=subprocess.PIPE,
stdout=subprocess.PIPE)
self.is_running =Salah

def play_song(self):
jika bukan self.is_running:
self.song_thread =Thread(target=self.call_omxplayer, args=())
self.song_thread.start()
self.is_running =Benar

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

#Fungsi untuk memilih lagu secara acak dari daftar
def pickRandom(songList):
return(random.choice(songList))

############################################################# ######
# Server CloudMQTT
############################################# #######################
# Tentukan panggilan balik acara
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(“Berlangganan:“ + str(mid) + ” “ + str(granted_qos))

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

############################################################# ######
# Fungsi Utama
############################################# #######################
def main():
#Panggil Server Klien Python Paho
mqttc =paho. Client()
#Menetapkan panggilan balik acara
mqttc.on_message =on_message
mqttc.on_connect =on_connect
mqttc.on_publish =on_publish
mqttc.on_subscribe =on_subscribe

# Batalkan komentar untuk mengaktifkan pesan debug
#mqttc.on_log =on_log

# Parsing CLOUDMQTT_URL (atau mundur ke localhost)
url_str =os.environ.get(creds['CloudMQTT URL'], 'mqtt://localhost:1883')
url =urlparse.urlparse(url_str )

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

# Mulai berlangganan, dengan QoS level 0
mqttc.subscribe(creds['topic'], 0)

sedangkan Benar:
#1. Temukan nilai ADC untuk amp puncak ke puncak mikrofon MEMS
PTPamp =PTPAmp()
#2. Hitung ptp amp (Volt)
PTPampV =round(((PTPamp*3.3) / 1024), 2)
#3. Petakan ptp amp (nilai ADC) ke Unit Volume antara 0 dan 10
VolUnit =VolumeUnit(PTPamp, 0, 700, 0, 10)

#Untuk keperluan debugging
print(PTPamp, VolUnit)

#4. Jika Unit Volume lebih besar dari 7, mainkan salah satu lagu
if(VolUnit> 7):
playBack =pickRandom(songList)
OMXPlayer(playBack)
time.sleep( 0.1)

#5. Unggah data ke Server CloudMQTT
mqttc.publish(“Volume”, str(VolUnit))
rc =True
while rc:
rc =mqttc.loop()
waktu.sleep(0.1)
print(“rc:“ + str(rc))

coba:
while True:
lulus
kecuali KeyboardInterrupt:
myprocess.kill()

if __name__ ==‘__main__’:
main()

Agar sistem Bark Back berfungsi dengan baik, isi berikut ini:

• Daftar Lagu :Tulis di jalur file dan nama file untuk setiap lagu yang ingin Anda putar.
• kepercayaan :Masukkan informasi CloudMQTT Anda dalam kamus ini.

Jangan ragu untuk (dan silakan) menyesuaikan dan memodifikasi kode – lihat Sumber Daya dan Melangkah Lebih Jauh bagian untuk variasi dan penambahan proyek.

Baca Info Selengkapnya…

Bark Back Interactive Pet Monitor