17 KiB

Raw Permalink Blame History

ಧ್ವನಿಯನ್ನು ಸೆರೆಹಿಡಿಯಿರಿ - ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈ

ಪಾಠದ ಈ ಭಾಗದಲ್ಲಿ, ನೀವು ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈಯ ಮೇಲೆ ಧ್ವನಿಯನ್ನು ಸೆರೆಹಿಡಿಯಲು ಕೋಡ್ ಬರೆಯುತ್ತೀರಿ. ಧ್ವನಿ ಸೆರೆಹಿಡಿಸುವಿಕೆಯನ್ನು ಒಂದು ಬಟನ್ ನಿಯಂತ್ರಿಸುತ್ತದೆ.

ಹಾರ್ಡ್ವೇರ್

ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈಗೆ ಧ್ವನಿ ಸೆರೆಹಿಡಿಸುವಿಕೆಯನ್ನು ನಿಯಂತ್ರಿಸಲು ಒಂದು ಬಟನ್ ಬೇಕು.

ನೀವು ಬಳಸುವ ಬಟನ್ ಒಂದು ಗ್ರೂವ್ ಬಟನ್ ಆಗಿದೆ. ಇದು ಸಿಗ್ನಲ್ ಅನ್ನು ಆನ್ ಅಥವಾ ಆಫ್ ಮಾಡಲು ಪರಿವರ್ತಿಸುವ ಡಿಜಿಟಲ್ ಸೆನ್ಸರ್ ಆಗಿದೆ. ಈ ಬಟನ್‌ಗಳನ್ನು ಪೆÇಸ್ ಮಾಡಿದಾಗ ಹೈ ಸಿಗ್ನಲ್ ಕಳುಹಿಸಲು ಮತ್ತು ಪೆÇಸ್ ಮಾಡದಾಗ ಲೋ ಸಿಗ್ನಲ್ ಕಳುಹಿಸಲು, ಅಥವಾ ಪೆÇಸ್ ಮಾಡಾಗ ಲೋ ಮತ್ತು ಪೆÇಸ್ ಮಾಡದಾಗ ಹೈ ಸಿಗ್ನಲ್ ಕಳುಹಿಸಲು ಸಂರಚಿಸಬಹುದು.

ನೀವು ಮൈಕ್ರೊಫೋನ್ ಆಗಿ ReSpeaker 2-Mics Pi HAT ಬಳಸುತ್ತಿದ್ದರೆ, ಈ ಹ್ಯಾಟ್ ಈಗಾಗಲೇ ಒಂದು ಬಟನ್ ಜೊತೆಗೆ ಇರುತ್ತದೆ, ಆದ್ದರಿಂದ ಬಟನ್ ಸಂಪರ್ಕಿಸುವ ಅವಶ್ಯಕತೆ ಇರುವುದಿಲ್ಲ. ಮುಂದಿನ ಭಾಗಕ್ಕೆ ಜಂಪ್ ಮಾಡಿ.

ಬಟನ್ ಸಂಪರ್ಕಿಸು

ಬಟನ್ ಅನ್ನು ಗ್ರೂವ್ ಬೇಸ್ ಹ್ಯಾಟ್‌ಗೆ ಸಂಪರ್ಕಿಸಬಹುದು.

ಕಾರ್ಯ - ಬಟನ್ ಅನ್ನು ಸಂಪರ್ಕಿಸು

ಒಂದು ತುದಿಯನ್ನು ಗ್ರೂವ್ ಕೇಬಲ್‌ನಿಂದ ಬಟನ್ ಮಾಡ್ಯೂಳಿನ ಅವಯವದಲ್ಲಿ ಹಾಕಿ. ಇದು ಒಂದು ದಿಕ್ಕಿನಲ್ಲಿ ಮಾತ್ರ ಹಾಕಬಹುದು.
ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈ ನೆಲಗೂರುವಿಕೆಯ ಸ್ಥಿತಿಯಲ್ಲಿ ಇರುತ್ತಿದ್ದಾಗ, ಗ್ರೂವ್ ಕೇಬಲ್‌ನ ಇನ್ನೊಂದು ತುದಿಯನ್ನು ಪೈಗೆ ಹತ್ತಿಸಿರುವ ಗ್ರೂವ್ ಬೇಸ್ ಹ್ಯಾಟ್‌ನ D5 ಎಂದು ಗುರುತಿಸಲಾಗಿರುವ ಡಿಜಿಟಲ್ ಅವಯವಕ್ಕೆ ಸಂಪರ್ಕಿಸು. ಈ ಅವಯವವು GPIO ಪಿನ್ಗಳ ಹತ್ತಿರದ ಸಾಲಿನಲ್ಲಿ ಎಡದಿಂದ ಎರಡನೆದು.

ಧ್ವನಿಯನ್ನು ಸೆರೆಹಿಡಿಯೋಣ

ನೀವು ಪೈಠಾನ್ ಕೋಡ್ ಬಳಸಿ ಮೈಕ್ರೊಫೋನಿನಿಂದ ಧ್ವನಿಯನ್ನು ಸೆರೆಹಿಡಿಯಬಹುದು.

ಕಾರ್ಯ - ಧ್ವನಿಯನ್ನು ಸೆರೆಹಿಡಿಯಿರಿ

ಪೈನ POWER ON ಮಾಡಿ ಮತ್ತು ಬೂಟ್ Finish ಆಗಲು ಕಾಯಿರಿ
VS Code ಪ್ರಾರಂಭಿಸಿ, ಪೈ ನೇರವಾಗಿ ಅಥವಾ Remote SSH ವಿಸ್ತರಣೆ ಮೂಲಕ ಸಂಪರ್ಕ ಮಾಡಿ.
PyAudio ಪಿಪ್ ಪ್ಯಾಕೇಜ್ ಧ್ವನಿಯನ್ನು ದಾಖಲಿಸಲು ಮತ್ತು ಪ್ಲೇ ಮಾಡಲು ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದೆ. ಈ ಪ್ಯಾಕೇಜ್ ಕೆಲವು ಧ್ವನಿ ಗ್ರಂಥಾಲಯಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ, ಅವನ್ನು ಮೊದಲಿಗೆ ಸ್ಥಾಪಿಸಬೇಕಾಗುತ್ತದೆ. ಈ ಕೆಳಗಿನ ಆದೇಶಗಳನ್ನು ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಓಡಿಸಿ:
```
sudo apt update
sudo apt install libportaudio0 libportaudio2 libportaudiocpp0 portaudio19-dev libasound2-plugins --yes 
```
PyAudio ಪಿಪ್ ಪ್ಯಾಕೇಜ್ ಸ್ಥಾಪಿಸಿ.
```
pip3 install pyaudio
```
smart-timer ಎಂಬ ಹೊಸ ಫೋಲ್ಡರ್ ರಚಿಸಿ ಮತ್ತು ಅದರೊಳಗೆ app.py ಎಂಬ ಫೈಲ್ ಸೇರಿಸಿ.
ಈ ಫೈಲ್‌ದ ಮೇಲ್ಭಾಗಕ್ಕೆ ಕೆಳಗಿನ ಆಮದುಗಳನ್ನು ಸೇರಿಸಿ:
```
import io
import pyaudio
import time
import wave

from grove.factory import Factory
```
ಇದು pyaudio ಮೋಡ್ಯೂಲ್, ವೇವ್ ಫೈಲ್ಗಳನ್ನು കൈಗಾರಿಕೆಯ ಮಾಡಲು ಕೆಲವು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಪೈಥನ್ ಮೋಡ್ಯೂಲ್‌ಗಳನ್ನು ಹಾಗೂ ಬಟನ್ ಕ್ಲಾಸ್ ಸೃಷ್ಟಿಸಲು Grove ನ Factory ಮೋಡ್ಯೂಲ್ ಅನ್ನು ಆಮದು ಮಾಡುತ್ತದೆ.
ಇದೀಗಿಂತ ಕೆಳಗೆ, ಗ್ರೂವ್ ಬಟನ್ ಸೃಷ್ಟಿಸುವ ಕೋಡ್ ಸೇರಿಸಿ.

ನೀವು ReSpeaker 2-Mics Pi HAT ಬಳಸುತ್ತಿದ್ದರೆ, ಈ ಕೆಳಗಿನ ಕೋಡ್ ಬಳಸಿ:
```
# ReSpeaker 2-Mics Pi HAT上的按钮
button = Factory.getButton("GPIO-LOW", 17)
```
ಇದು ಪೋರ್ಟ್ D17 ನಲ್ಲಿ ಬಟನ್ ಸೃಷ್ಟಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ReSpeaker 2-Mics Pi HAT ಬಟನ್ ಇದಕ್ಕೆ ಸಂಪರ್ಕಿಸಿದೆ. ಈ ಬಟನ್ ಅನ್ನು ಪೆÇಸ್ ಮಾಡಿದಾಗ ಲೋ ಸಿಗ್ನಲ್ ಕಳುಹಿಸಲು ಸಿದ್ಧಪಡಿಸಲಾಗಿದೆ.

ನೀವು ReSpeaker 2-Mics Pi HAT ಬಳಸುತ್ತಿರುವುದಿಲ್ಲ ಮತ್ತು ಗ್ರೂವ್ ಬಟನ್ ಬೇಸ್ ಹ್ಯಾಟ್‌ಗೆ ಸಂಪರ್ಕಿಸಲಾಗಿದೆ ಎಂದು ಇದ್ದರೆ, ಈ ಕೋಡ್ ಬಳಸಿ.
```
button = Factory.getButton("GPIO-HIGH", 5)
```
ಇದು ಪೋರ್ಟ್ D5 ನಲ್ಲಿ ಬಟನ್ ಸೃಷ್ಟಿಸುತ್ತದೆ, ಇದು ಪೆÇಸ್ ಮಾಡಿದಾಗ ಹೈ ಸಿಗ್ನಲ್ ಕಳುಹಿಸಲು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ.
ಇದರ ಕೆಳಗೆ, PyAudio ಕ್ಲಾಸಿನ ಒಂದು ಉದಾಹರಣೆ ಧ್ವನಿಯನ್ನು ಸಂಭಾಳಿಸಲು ಸೃಷ್ಟಿಸಿ:
```
audio = pyaudio.PyAudio()
```
ಮೈಸರ್ಕೊಫೋನ್ ಮತ್ತು ಸ್ಪೀಕರ್ ಹಾರ್ಡ್ವೇರ್ ಕಾರ್ಡ್ ಸಂಖ್ಯೆ ಘೋಷಿಸಿ. ನೀವು ಈ ಪಾಠದಲ್ಲಿ ಮುಂಚೆ arecord -l ಮತ್ತು aplay -l ಆಜ್ಞೆಗಳನ್ನು ಓಡಿಸಿ ಕಂಡುಹಿಡಿದ ಕಾರ್ಡ್ ಸಂಖ್ಯೆಯೇ ಇದು ಆಗಿರುತ್ತದೆ.
```
microphone_card_number = <microphone card number>
speaker_card_number = <speaker card number>
```
<microphone card number> ಅನ್ನು ನಿಮ್ಮ ಮೈಸರ್ಕೊಫೋನ್ ಕಾರ್ಡ್ ಸಂಖ್ಯೆಯಿಂದ ಬದಲಾಯಿಸಿ.

<speaker card number> ಅನ್ನು ನಿಮ್ಮ ಸ್ಪೀಕರ್ ಕಾರ್ಡ್ ಸಂಖ್ಯೆಯಿಂದ ಬದಲಾಯಿಸಿ, ಅದೇ ಸಂಖ್ಯೆಯನ್ನು ನೀವು alsa.conf ಫೈಲ್‌ಗಳಲ್ಲಿ ಸೆಟ್ ಮಾಡಿದ್ದೀರಿ.
ಇದರ ಕೆಳಗೆ, ಧ್ವನಿಯ ಸೆರೆಹಿಡಿಕೆ ಮತ್ತು ಪ್ಲೇಬ್ಯಾಕ್‌ಗೆ ಬಳಸಲಾದ ಸಂದರ್ಶನ ದರವನ್ನು ಘೋಷಿಸಿ. ನಿಮ್ಮ ಹಾರ್ಡ್ವೇರ್ ಅವಲಂಬಿಸಿ ಇದನ್ನು ಬದಲಾಯಿಸಬೇಕಾಗಬಹುದು.
```
rate = 48000 #48ಕೆಹರ್ಝ್
```
ಈ ಕೋಡ್ ಮರುನಡೆಸುವಾಗ ಸಂದರ್ಶನ ದರ ದೋಷಗಳು ಬಂದರೆ, ಈ ಮೌಲ್ಯವನ್ನು 44100 ಅಥವಾ 16000 ಗೆ ಬದಲಾಯಿಸಿ. ಮೌಲ್ಯ ಹೆಚ್ಚು ಇದ್ದರೆ ಧ್ವನಿಯ ಗುಣಮಟ್ಟ ಉತ್ತಮವಾಗಿರುತ್ತದೆ.
ಇದರ ಕೆಳಗೆ, capture_audio ಎಂಬ ಹೊಸ ಫಂಕ್ಷನ್ ರಚಿಸಿ. ಇದು ಮೈಸರ್ಕೊಫೋನಿನಿಂದ ಧ್ವನಿಯನ್ನು ಸೆರೆಹಿಡಿಯಲು ಕರೆಮಾಡಲಾಗುತ್ತದೆ:
```
def capture_audio():
```
ಈ ಫಂಕ್ಷಣನೊಳಗೆ ಕೆಳಗಿನ ವ್ಯವಹಾರಗಳನ್ನು ಸೇರಿಸಿ:
```
stream = audio.open(format = pyaudio.paInt16,
                    rate = rate,
                    channels = 1, 
                    input_device_index = microphone_card_number,
                    input = True,
                    frames_per_buffer = 4096)

frames = []

while button.is_pressed():
    frames.append(stream.read(4096))

stream.stop_stream()
stream.close()
```
ಈ ಕೋಡ್ PyAudio ವಸ್ತುವನ್ನು ಉಪಯೋಗಿಸಿ ಧ್ವನಿ ಇನ್‌ಪುಟ್ ಸ್ಟ್ರೀಂ ತೆರೆಯುತ್ತದೆ. ಈ ಸ್ಟ್ರೀಮ್ ಮೈಸರ್ಕೊಫೋನಿನಿಂದ 16KHz ನಲ್ಲಿ ಧ್ವನಿಯನ್ನು ಸೆರೆಹಿಡಿಯುತ್ತದೆ, ಮತ್ತು ಪ್ರತಿಯೊಂದು ಬಾರಿ 4096 ಬೈಟ್ ಗಾತ್ರದ ಬಫರ್ಸ್‌ಗಳಲ್ಲಿ ಸೆರೆಹಿಡಿಯುತ್ತದೆ.

ಕೋಡ್ ನಂತರ Grove ಬಟನ್ ಪೆÇಸ್ ಆಗಿರುವಾಗ ಲೂಪ್ ಮಾಡುತ್ತದೆ, ಪ್ರತಿಯೊಂದು ಬಾರಿ ಈ 4096 ಬೈಟ್ ಬಫರ್ಸ್‌ನ್ನು ಒಂದು ಅರೇಗೆ ಓದುತ್ತದೆ.

💁 ನೀವು open ವಿಧಾನಕ್ಕೆ ನೀಡಲಾದ ಆಯ್ಕೆಗಳ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ಓದಿಕೊಳ್ಳಲು PyAudio ಡಾಕ್ಯುമെಂಟೇಶನ್ ನೋಡಬಹುದು.

ಬಟನ್ ಬಿಡುಗಡೆ ಆದಾಗ, ಸ್ಟ್ರೀಂ ನಿಲ್ಲಿಸಿ ಮುಚ್ಚಲಾಗುತ್ತದೆ.
ಈ ಫಂಕ್ಷನ್ ಕೊನೆಯಲ್ಲಿ ಕೆಳಗಿನ ವ್ಯವಹಾರ ಸೇರಿಸಿ:
```
wav_buffer = io.BytesIO()
with wave.open(wav_buffer, 'wb') as wavefile:
    wavefile.setnchannels(1)
    wavefile.setsampwidth(audio.get_sample_size(pyaudio.paInt16))
    wavefile.setframerate(rate)
    wavefile.writeframes(b''.join(frames))
    wav_buffer.seek(0)

return wav_buffer
```
ಈ ಕೋಡ್ ಒಂದು ದ್ವಮೀಯ ಬಫರ್ ಸೃಷ್ಟಿಸುತ್ತದೆ ಮತ್ತು ಸೆರೆಹಿಡಿದ ಧ್ವನಿಯನ್ನು WAV ಫೈಲ್ ಆಗಿ ಬರೆದು ಅದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಇದು ಒತ್ತಡವಿಲ್ಲದ ಧ್ವನಿಯನ್ನು ಫೈಲ್‌ಗೆ ಬರೆಯುವ ಸಾಮಾನ್ಯ ವಿಧಾನ.
ಆಡಿಯೋ ಬಫರ್ ಅನ್ನು ಪ್ಲೇ ಮಾಡಲು ಕೆಳಗಿನ play_audio ಫಂಕ್ಷನ್ ಸೇರಿಸಿ:
```
def play_audio(buffer):
    stream = audio.open(format = pyaudio.paInt16,
                        rate = rate,
                        channels = 1,
                        output_device_index = speaker_card_number,
                        output = True)

    with wave.open(buffer, 'rb') as wf:
        data = wf.readframes(4096)

        while len(data) > 0:
            stream.write(data)
            data = wf.readframes(4096)

        stream.close()
```
ಈ ಫಂಕ್ಷನ್ ಇನ್ನೊಂದು ಆಡಿಯೋ ಸ್ಟ್ರೀಂ ತೆರೆಯುತ್ತದೆ, ಇದೀಗ ಔಟ್‌풋್ ಗಾಗಿ - ಧ್ವನಿಯನ್ನು ಪ್ಲೇ ಮಾಡಲು. ಇದು ಇನ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್‌ನಂತೆಯೇ ನಿಭಂಧನೆಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಬಫರ್ ಅನ್ನು ವೇವ್ ಫೈಲ್ ಆಗಿ ತೆರೆಯುವ ಮೂಲಕ 4096 ಬೈಟ್ ತುಂಡುಗಳಲ್ಲಿ ಔಟ್‌ಪುಟ್ ಸ್ಟ್ರೀಂಗೆ ಬರೆಯುತ್ತಾ ಧ್ವನಿಯನ್ನು ಪ್ಲೇ ಮಾಡುತ್ತದೆ. ನಂತರ ಸ್ಟ್ರೀಂ ಮುಚ್ಚಲ್ಪಡುತ್ತದೆ.
capture_audio ಫಂಕ್ಷನ್ ಕೆಳಗೆ ಈ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ, ಬಟನ್ ಪೆÇಸ್ ಆಗುವವರೆಗೂ ಲೂಪ್ ಮಾಡುತ್ತದೆ. ಬಟನ್ ಪೆÇಸ್ ಆದಾಗ, ಧ್ವನಿ ಸೆರೆಹಿಡಿಯಲ್ಪಟ್ಟ, ನಂತರ ಪ್ಲೇ ಮಾಡಲ್ಪಟ್ಟಿರುತ್ತದೆ.
```
while True:
    while not button.is_pressed():
        time.sleep(.1)

    buffer = capture_audio()
    play_audio(buffer)
```
ಕೋಡ್ ಅನ್ನು ಓಡಿಸಿ. ಬಟನ್ ಅನ್ನು ಒತ್ತಿ ಮತ್ತು ಮೈಕ್ರೊಫೋನಿಗೆ ಮಾತನಾಡಿ. ಪೂರ್ಣಗೊಂಡಾಗ ಬಟನ್ ಬಿಡುಗಡೆ ಮಾಡಿ, நீங்கள் ನೋಡುವಿರಿ ರೆಕಾರ್ಡಿಂಗ್ ಕೇಳಿಸುತ್ತಿದೆ.

PyAudio ಉದಾಹರಣೆ ಸೃಷ್ಟಿಸುವಾಗ ನೀವು ಕೆಲವು ALSA ದೋಷಗಳನ್ನು ಕಾಣಬಹುದು. ಈ ದೋಷಗಳು ನಿಮ್ಮ ಪೈ ಇತರೆ ಆಡಿಯೋ ಸಾಧನಗಳಿಗೆ ಸಂರಚನೆಯ ಕುರಿತು ಆಗಿರಬಹುದು. ನೀವು ಅವುಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸಬಹುದು.
```
pi@raspberrypi:~/smart-timer $ python3 app.py 
ALSA lib pcm.c:2565:(snd_pcm_open_noupdate) Unknown PCM cards.pcm.front
ALSA lib pcm.c:2565:(snd_pcm_open_noupdate) Unknown PCM cards.pcm.rear
ALSA lib pcm.c:2565:(snd_pcm_open_noupdate) Unknown PCM cards.pcm.center_lfe
ALSA lib pcm.c:2565:(snd_pcm_open_noupdate) Unknown PCM cards.pcm.side
```
ನೀವು ಕೆಳಗಿನ ದೋಷವನ್ನು ಕಾಣುವುದಾದರೆ:
```
OSError: [Errno -9997] Invalid sample rate
```
rate ಅನ್ನು 44100 ಅಥವಾ 16000 ಗೆ ಬದಲಾಯಿಸಿ.

💁 ನೀವು ಈ ಕೋಡ್ ಅನ್ನು code-record/pi ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಕಾಣಬಹುದು.

😀 ನಿಮ್ಮ ಧ್ವನಿ ದಾಖಲು ಕಾರ್ಯಕ್ರಮ ಯಶಸ್ವಿಯಾಯಿತು!

ತಪ್ಪು ಹೇಳಿಕೆ:
ಈ ದಾಖಲೆಯನ್ನು AI ಅನುವಾದ ಸೇವೆ Co-op Translator ಬಳಸಿ ಅನುವದಿಸಲಾಗಿದೆ. ನಿಖರತೆಯತ್ತ ನಾವು ಪ್ರಯತ್ನಿಸುವುದಾದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ತಪ್ಪುಗಳಿರುವ ಸಾಧ್ಯತೆ ಇದ್ದು ತನ್ನದಾಗಿದೆ. ಮೂಲ ಭಾಷೆಯ ಮೂಲ ದಾಖಲೆ ಅಧಿಕೃತ ಮೂಲ ಎಂದು ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವದಾದರೂ ತಪ್ಪುಧಾರಣೆಗಳು ಅಥವಾ ತಪ್ಪು ಅರ್ಥಗರ್ಭಿತತೆಗಳಿಗೆ ನಾವು ಜವಾಬ್ದಾರರಾಗುವುದಿಲ್ಲ.

17 KiB Raw Permalink Blame History