Sensor Suara Dengan Raspberry Pi | Pelatihan Python

Hai guys, hari ini saya akan menunjukkan tutorial lain tentang raspberry pie yang satu itu Sensor suara dengan Raspberry Pi | Pelatihan Python | Nilai digital dari sensor suara sangat umum di kalangan pemula dan penggemar untuk membuat beberapa hal dasar seperti VU meter dan musik LED reaktif. Kita juga akan melihat jenis proyek ini, tetapi pertama-tama, mari kita lihat fungsi dan kode aslinya. Untuk pemahaman yang lebih baik, lihat tutorial Arduino melalui Tutorial Sensor Arduino. Jadi mari kita mulai hari ini.

Sensor suara

Sensor suara mirip dengan sensor lain seperti IR dan kelembaban tanah, tetapi seperti biasa kinerja masing-masing sensor berbeda tetapi struktur dan desain dasarnya sama. Sensor suara tersedia dalam berbagai sensor mulai dari IC LM393 internal hingga modul Sparkfun. Juga, sensor analog dan digital sangat berbeda dalam hal kinerja dan kinerja.

Dalam versi aslinya, IC LM393 digunakan untuk memperkuat tegangan yang dihasilkan oleh mikrofon kapasitif. Tegangan yang dihasilkan oleh mikrofon sangat rendah sehingga sulit untuk dideteksi oleh Raspberry Pi. Jika Anda memiliki osiloskop, Anda akan terbiasa dengan keadaan gelombang n trigonometrinya. Jadi untuk menempatkan tegangan pada rentang yang dapat dideteksi, kita perlu menggunakan IC penguat seperti LM393.

Sensor memiliki LED built-in yang menyala ketika mendeteksi suara atau kebisingan di mikrofon. Selain itu, modul memiliki potensiometer yang dapat digunakan untuk memotong permukaan dan rentang tegangan. Tetapi dalam nilai analog, ada peningkatan tegangan yang konstan untuk proyek-proyek seperti VU meter dan LED musik reaktif. Kami akan membahas proyek ini di tutorial lain.

Bahan yang dibutuhkan

• Raspberry Pi (dengan layar dan keyboard)
• Sensor suara
• Papan roti
• Kabel jumper
• Kepemimpinan

Sensor suara dengan diagram sirkuit Raspberry Pi

PI raspberry	Sensor suara
GPIO 4 pin	D0
+5 volt	+5 volt, VCC
GND	GND
PI raspberry	LCD 16*2
GPIO2 (SDA)	pin SDA
GPIO 3 (SCL)	pin SCL
+5 volt	VCC
GND	GND
PI raspberry	Kepemimpinan	Resistansi 220 ohm
GPIO 7 pin	Terminal anoda (+)
GND		Terminal 1
	Terminal katoda (-)	Terminal 2

Kode dan deskripsi

Penjelasan

Agar kode berfungsi, Anda harus terlebih dahulu menyimpan beberapa modul di direktori Raspberry Pi Python atau tempat Anda menyimpan kode asli Anda. Salin kode modul yang diperlukan di bawah ini dan simpan dengan nama LiquidCrystal_I2C.py.

Penjelasan rinci tentang semua perintahnya diberikan dalam tutorial LiquidCrystal kami di Raspberry Pi. Lihat untuk informasi lebih lanjut Sekarang mari kita beralih ke kode utama. Pada kode utama, pertama kita atur beberapa modul penting seperti liquidCrystal_I2C, fungsi sleep dari modul waktu dan modul RPi.GPIO sebagai GP.

Kemudian kami mengatur papan penomoran pin gpio sesuai dengan kontrak papan dan mengatur pin 7 sebagai basis input sensor suara. Karena Raspberry Pi hanya memiliki pin digital, kami hanya dapat menggunakan output digital dari sensor suara, bukan nilai analog.

Kami kemudian menginisialisasi LCD I2C dan membuat objek LCD bernama variabel LCD, dan kemudian memerintahkan kami untuk menghapus data sebelumnya di memori LCD. Kemudian kami meletakkan beberapa string awal pada layar LCD dan kemudian menggunakannya dalam loop while untuk mencoba dan menulis loop utama secara terus menerus.

Dalam loop while, setiap kali input pin 7 naik, kami mencetak kabel yang berbicara di layar LCD, yaitu suara dideteksi oleh sensor suara.

Sensor suara dengan kode Raspberry Pi

Modul yang dibutuhkan:

 import smbus  
 from time import *  
 class i2c_device:  
   def __init__(self, addr, port=1):  
    self.addr = addr  
    self.bus = smbus.SMBus(port)  
 # Write a single command  
   def write_cmd(self, cmd):  
    self.bus.write_byte(self.addr, cmd)  
    sleep(0.0001)  
 # Write a command and argument  
   def write_cmd_arg(self, cmd, data):  
    self.bus.write_byte_data(self.addr, cmd, data)  
    sleep(0.0001)  
 # Write a block of data  
   def write_block_data(self, cmd, data):  
    self.bus.write_block_data(self.addr, cmd, data)  
    sleep(0.0001)  
 # Read a single byte  
   def read(self):  
    return self.bus.read_byte(self.addr)  
 # Read  
   def read_data(self, cmd):  
    return self.bus.read_byte_data(self.addr, cmd)  
 # Read a block of data  
   def read_block_data(self, cmd):  
    return self.bus.read_block_data(self.addr, cmd)  
 # LCD Address  
 ADDRESS = 0x27  
 # commands  
 LCD_CLEARDISPLAY = 0x01  
 LCD_RETURNHOME = 0x02  
 LCD_ENTRYMODESET = 0x04  
 LCD_DISPLAYCONTROL = 0x08  
 LCD_CURSORSHIFT = 0x10  
 LCD_FUNCTIONSET = 0x20  
 LCD_SETCGRAMADDR = 0x40  
 LCD_SETDDRAMADDR = 0x80  
 # flags for display entry mode  
 LCD_ENTRYRIGHT = 0x00  
 LCD_ENTRYLEFT = 0x02  
 LCD_ENTRYSHIFTINCREMENT = 0x01  
 LCD_ENTRYSHIFTDECREMENT = 0x00  
 # flags for display on/off control  
 LCD_DISPLAYON = 0x04  
 LCD_DISPLAYOFF = 0x00  
 LCD_CURSORON = 0x02  
 LCD_CURSOROFF = 0x00  
 LCD_BLINKON = 0x01  
 LCD_BLINKOFF = 0x00  
 # flags for display/cursor shift  
 LCD_DISPLAYMOVE = 0x08  
 LCD_CURSORMOVE = 0x00  
 LCD_MOVERIGHT = 0x04  
 LCD_MOVELEFT = 0x00  
 # flags for function set  
 LCD_8BITMODE = 0x10  
 LCD_4BITMODE = 0x00  
 LCD_2LINE = 0x08  
 LCD_1LINE = 0x00  
 LCD_5x10DOTS = 0x04  
 LCD_5x8DOTS = 0x00  
 # flags for backlight control  
 LCD_BACKLIGHT = 0x08  
 LCD_NOBACKLIGHT = 0x00  
 En = 0b00000100 # Enable bit  
 Rw = 0b00000010 # Read/Write bit  
 Rs = 0b00000001 # Register select bit  
 class lcd:  
   #initializes objects and lcd  
   def __init__(self):  
    self.lcd_device = i2c_device(0x3f)  
    self.lcd_write(0x03)  
    self.lcd_write(0x03)  
    self.lcd_write(0x03)  
    self.lcd_write(0x02)  
    self.lcd_write(LCD_FUNCTIONSET | LCD_2LINE | LCD_5x8DOTS | LCD_4BITMODE)  
    self.lcd_write(LCD_DISPLAYCONTROL | LCD_DISPLAYON)  
    self.lcd_write(LCD_CLEARDISPLAY)  
    self.lcd_write(LCD_ENTRYMODESET | LCD_ENTRYLEFT)  
    sleep(0.2)  
   # clocks EN to latch command  
   def lcd_strobe(self, data):  
    self.lcd_device.write_cmd(data | En | LCD_BACKLIGHT)  
    sleep(.0005)  
    self.lcd_device.write_cmd(((data & ~En) | LCD_BACKLIGHT))  
    sleep(.0001)  
   def lcd_write_four_bits(self, data):  
    self.lcd_device.write_cmd(data | LCD_BACKLIGHT)  
    self.lcd_strobe(data)  
   # write a command to lcd  
   def lcd_write(self, cmd, mode=0):  
    self.lcd_write_four_bits(mode | (cmd & 0xF0))  
    self.lcd_write_four_bits(mode | ((cmd << 4) & 0xF0))  
   # write a character to lcd (or character rom) 0x09: backlight | RS=DR<  
   # works!  
   def lcd_write_char(self, charvalue, mode=1):  
    self.lcd_write_four_bits(mode | (charvalue & 0xF0))  
    self.lcd_write_four_bits(mode | ((charvalue << 4) & 0xF0))  
   # put string function  
   def display_line(self, string, line):  
    if line == 1:  
      self.lcd_write(0x80)  
    if line == 2:  
      self.lcd_write(0xC0)  
    if line == 3:  
      self.lcd_write(0x94)  
    if line == 4:  
      self.lcd_write(0xD4)  
    for char in string:  
      self.lcd_write(ord(char), Rs)  
   # clear lcd and set to home  
   def clear(self):  
    self.lcd_write(LCD_CLEARDISPLAY)  
    self.lcd_write(LCD_RETURNHOME)  
   # define backlight on/off (lcd.backlight(1); off= lcd.backlight(0)  
   def backlight(self, state): # for state, 1 = on, 0 = off  
    if state == 1:  
      self.lcd_device.write_cmd(LCD_BACKLIGHT)  
    elif state == 0:  
      self.lcd_device.write_cmd(LCD_NOBACKLIGHT)  
   # add custom characters (0 - 7)  
   def lcd_load_custom_chars(self, fontdata):  
    self.lcd_write(0x40);  
    for char in fontdata:  
      for line in char:  
       self.lcd_write_char(line)       
   # define precise positioning (addition from the forum)  
   def display(self, string, line, pos):  
   if line == 1:  
    pos_new = pos  
   elif line == 2:  
    pos_new = 0x40 + pos  
   elif line == 3:  
    pos_new = 0x14 + pos  
   elif line == 4:  
    pos_new = 0x54 + pos  
   self.lcd_write(0x80 + pos_new)  
   for char in string:  
    self.lcd_write(ord(char), Rs)  

Lakukan ini dengan LiquidCrystal_I2C.py

Kode utama ada di sini:

 import LiquidCrystal_I2C  
 from time import sleep  
 import RPi.GPIO as gp  
 gp.setmode(gp.BOARD)  
 gp.setup(7,gp.IN)  
 lcd=LiquidCrystal_I2C.lcd()  
 lcd.clear()  
 lcd.display("Initiating Mic...",1,0)  
 sleep(1)  
 lcd.display("Listening",2,4)  
 sleep(1)  
 while True:  
   try:  
     while(gp.input(7)==1):  
       print("SPEAKING...")  
       lcd.display("SPEAKING",1,1)  
     else:  
       lcd.clear()  
   except KeyboardInterrupt:  
     gp.cleanup()  
     break  

Dengan itu, kami menyelesaikan tutorial kami tentang sensor suara dengan Raspberry Pi.