Offline Voice Recognition Sensor DFRobot

11 czerwca 2024 20 lutego 2025 Arduino / Arduino IDE / ESP32 / PROGRAMOWANIE

https://dfimg.dfrobot.com/nobody/wiki/4f868c5f5b2b9ae909271b3865939655.png

Obsługa modułu

Uczenie dodatkowej frazy wybudzającej

Aby nauczyć moduł nowej frazy wybudzającej (zawsze aktywne pozostaje “Hello Robot!“) należy po wywołaniu standardowym wygłosić frazę: Learning wake word“. Następnie podać nowe sformułowanie wybudzające. Ja podałem Hello Jane. Trzeba to zrobić trzykrotnie słuchając poleceń.

Biblioteka MicroPython

Biblioteka lekko zmodyfikowana. W oryginalnej był błąd w metodzie get_cmdid(). Poprawiony przez Chat GPT.
Uwaga! Kody nie działają dla ESP8266. Prawdopodobnie problem tkwi w bibliotece I2C. Może trzeba użyć softI2C? Sprawdzę.
Wszystko dobrze działa na ESP32.

001from micropython import const
002from machine import I2C, Pin
003from utime import sleep
004 
005 
006DF2301Q_I2C_ADDR = const(0x64)
007 
008 
009class DFRobot_DF2301Q_I2C:
010    """
011    MicroPython class for communication with the DF2301Q from DFRobot via I2C
012    """
013 
014    DF2301Q_I2C_REG_CMDID = const(0x02)
015    DF2301Q_I2C_REG_PLAY_CMDID = const(0x03)
016    DF2301Q_I2C_REG_SET_MUTE = const(0x04)
017    DF2301Q_I2C_REG_SET_VOLUME = const(0x05)
018    DF2301Q_I2C_REG_WAKE_TIME = const(0x06)
019    DF2301Q_I2C_8BIT_RANGE = const(0xFF)
020    DF2301Q_I2C_PLAY_CMDID_DURATION = const(1)
021 
022    def __init__(self, sda, scl, i2c_addr=DF2301Q_I2C_ADDR, i2c_bus=0):
023        """
024        Initialize the DF2301Q I2C communication
025        :param sda: I2C SDA pin
026        :param scl: I2C SCL pin
027        :param i2c_addr: I2C address
028        :param i2c_bus: I2C bus number
029        """
030        self._addr = i2c_addr
031 
032        try:
033            self._i2c = I2C(i2c_bus, sda=Pin(sda), scl=Pin(scl))
034        except Exception as err:
035            print(f'Could not initialize i2c! bus: {i2c_bus}, sda: {sda}, scl: {scl}, error: {err}')
036 
037    def _write_reg(self, reg, data) -> None:
038        """
039        Writes data to the I2C register
040        :param reg: register address
041        :param data: data to write
042        :return: None
043        """
044        if isinstance(data, int):
045            data = [data]
046 
047        try:
048            self._i2c.writeto_mem(self._addr, reg, bytearray(data))
049        except Exception as err:
050            print(f'Write issue: {err}')
051 
052    def _read_reg(self, reg, length) -> bytes:
053        """
054        Reads data from the I2C register
055        :param reg: register address
056        :param length: number of bytes to read
057        :return: bytes
058        """
059        try:
060            result = self._i2c.readfrom_mem(self._addr, reg, length)
061        except Exception as err:
062            print(f'Read issue: {err}')
063            result = bytearray(length)
064 
065        return result
066 
067    def get_cmdid(self) -> int:
068        """
069        Returns the current command id
070        :return: int
071        """
072        data = self._read_reg(self.DF2301Q_I2C_REG_CMDID, 1)
073        return int(data[0])
074 
075    def get_wake_time(self) -> int:
076        """
077        Returns the current wake-up duration
078        :return: int
079        """
080        data = self._read_reg(self.DF2301Q_I2C_REG_WAKE_TIME, 1)
081        return int(data[0])
082 
083    def play_by_cmdid(self, cmdid: int) -> None:
084        """
085        Play the current command words by command id
086        :param cmdid: command words as integer
087        :return: None
088        """
089        self._write_reg(self.DF2301Q_I2C_REG_PLAY_CMDID, int(cmdid))
090        sleep(self.DF2301Q_I2C_PLAY_CMDID_DURATION)
091 
092    def set_wake_time(self, wake_time: int) -> None:
093        """
094        Set the wake-up duration of the device
095        :param wake_time: integer between 0 and 255
096        :return: None
097        """
098        wake_up_time = int(wake_time) & self.DF2301Q_I2C_8BIT_RANGE
099        self._write_reg(self.DF2301Q_I2C_REG_WAKE_TIME, wake_up_time)
100 
101    def set_volume(self, vol: int) -> None:
102        """
103        Set the volume of the device
104        :param vol: integer between 1 and 7
105        :return: None
106        """
107        self._write_reg(self.DF2301Q_I2C_REG_SET_VOLUME, int(vol))
108 
109    def set_mute_mode(self, mode) -> None:
110        """
111        Set the mute mode of the device
112        :param mode: integer 0 for off, 1 for on
113        :return: None
114        """
115        self._write_reg(self.DF2301Q_I2C_REG_SET_MUTE, int(bool(mode)))

Kod programu wyświetlającego na konsoli numery komend głosowych

01from DFRobot_DF2301Q_I2C import DFRobot_DF2301Q_I2C
02from micropython import const
03from utime import sleep
04 
05 
06SDA_PIN = const(21)
07SCL_PIN = const(22)
08SLEEP_SECONDS = const(3)
09 
10 
11def setup(sensor) -> None:
12    """
13    Set up the DFRobot DF2301Q sensor
14    :param sensor: instance of DFRobot_DF2301Q_I2C
15    :return: None
16    """
17    sensor.set_volume(5)
18    sensor.set_mute_mode(0)
19    sensor.set_wake_time(20)
20 
21 
22def get_cmd_id(sensor) -> int:
23    """
24    Get the command id from the DF2301Q sensor
25    :param sensor: instance of DFRobot_DF2301Q_I2C
26    :return: int
27    """
28    command_id = sensor.get_cmdid()
29    return command_id if command_id != 0 else None
30 
31 
32if __name__ == "__main__":
33    try:
34        voice_sensor = DFRobot_DF2301Q_I2C(sda=SDA_PIN, scl=SCL_PIN)
35        setup(sensor=voice_sensor)
36 
37        print('Speak your commands:')
38 
39        while True:
40            cmd_id = get_cmd_id(sensor=voice_sensor)
41 
42            if cmd_id is not None:
43                print(f'COMMAND ID: {cmd_id}')
44 
45            sleep(SLEEP_SECONDS)
46    except Exception as e:
47        print(f'Initialization error: {e}')

LINKI

Oficjalna biblioteka Arduino:
- https://github.com/DFRobot/DFRobot_DF2301Q
Dokumentacja:
- https://wiki.dfrobot.com/SKU_SEN0539-EN_Gravity_Voice_Recognition_Module_I2C_UART
Biblioteka MicroPython (uwaga, błąd!):
- https://github.com/Lupin3000/Micropython-I2C-DF2301Q
NerdCave, MicroPython
- https://nerdcave.xyz/docs/tutorials/gravity-offline-language-learning-voice-recognition-sensor/

Źródła:

Konfiguracja i działanie

Trening

Inne

Dodaj komentarz Anuluj pisanie odpowiedzi

Musisz się zalogować, aby móc dodać komentarz.