sam/voice_assistant
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First committ voice controller

Browse Source
This commit is contained in:
sam rolfe
2025-12-07 11:46:13 +11:00
commit 8cb584d155
9 changed files with 10551 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
.vscode/arduino.json vendored Normal file
View File

@@ -0,0 +1,7 @@
{
"board": "esp32:esp32:esp32s3",
"configuration": "JTAGAdapter=default,PSRAM=opi,FlashMode=qio,FlashSize=4M,LoopCore=1,EventsCore=1,USBMode=hwcdc,CDCOnBoot=cdc,MSCOnBoot=default,DFUOnBoot=default,UploadMode=default,PartitionScheme=default,CPUFreq=240,UploadSpeed=921600,DebugLevel=verbose,EraseFlash=none,ZigbeeMode=default",
"port": "/dev/ttyACM0",
"sketch": "voice_assistant.ino",
"output": "./build"
}

452
.vscode/c_cpp_properties.json vendored Normal file
View File

@@ -0,0 +1,452 @@
{
"version": 4,
"configurations": [
{
"name": "Arduino",
"compilerPath": "/home/sam/.arduino15/packages/esp32/tools/esp-x32/2411/bin/xtensa-esp32s3-elf-g++",
"compilerArgs": [
"-MMD",
"-w",
"-Werror=return-type",
"-iprefix"
],
"intelliSenseMode": "gcc-x64",
"includePath": [
"/media/sam/8294CD2994CD2111/Users/Dell/Documents/Arduino/voice_assistant",
"/home/sam/.arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.5-129cd0d2-v4/esp32s3/qio_opi/include",
"/home/sam/.arduino15/packages/esp32/hardware/esp32/3.3.1/cores/esp32",
"/home/sam/.arduino15/packages/esp32/hardware/esp32/3.3.1/variants/esp32s3",
"/home/sam/.arduino15/packages/esp32/tools/esp-x32/2411/xtensa-esp-elf/include/c++/14.2.0",
"/home/sam/.arduino15/packages/esp32/tools/esp-x32/2411/xtensa-esp-elf/include/c++/14.2.0/xtensa-esp-elf/esp32s3",
"/home/sam/.arduino15/packages/esp32/tools/esp-x32/2411/xtensa-esp-elf/include/c++/14.2.0/backward",
"/home/sam/.arduino15/packages/esp32/tools/esp-x32/2411/lib/gcc/xtensa-esp-elf/14.2.0/include",
"/home/sam/.arduino15/packages/esp32/tools/esp-x32/2411/lib/gcc/xtensa-esp-elf/14.2.0/include-fixed",
"/home/sam/.arduino15/packages/esp32/tools/esp-x32/2411/xtensa-esp-elf/include"
],
"forcedInclude": [
"/home/sam/.arduino15/packages/esp32/hardware/esp32/3.3.1/cores/esp32/Arduino.h"
],
"cStandard": "c11",
"cppStandard": "c++11",
"defines": [
"F_CPU=240000000L",
"ARDUINO=10607",
"ARDUINO_ESP32S3_DEV",
"ARDUINO_ARCH_ESP32",
"ARDUINO_BOARD=\"ESP32S3_DEV\"",
"ARDUINO_VARIANT=\"esp32s3\"",
"ARDUINO_PARTITION_default",
"ARDUINO_HOST_OS=\"linux\"",
"ARDUINO_FQBN=\"esp32:esp32:esp32s3:JTAGAdapter=default,PSRAM=opi,FlashMode=qio,FlashSize=4M,LoopCore=1,EventsCore=1,USBMode=hwcdc,CDCOnBoot=cdc,MSCOnBoot=default,DFUOnBoot=default,UploadMode=default,PartitionScheme=default,CPUFreq=240,UploadSpeed=921600,DebugLevel=verbose,EraseFlash=none,ZigbeeMode=default\"",
"ESP32=ESP32",
"CORE_DEBUG_LEVEL=5",
"ARDUINO_RUNNING_CORE=1",
"ARDUINO_EVENT_RUNNING_CORE=1",
"BOARD_HAS_PSRAM",
"ARDUINO_USB_MODE=1",
"ARDUINO_USB_CDC_ON_BOOT=1",
"ARDUINO_USB_MSC_ON_BOOT=0",
"ARDUINO_USB_DFU_ON_BOOT=0",
"__DBL_MIN_EXP__=(-1021)",
"__XCHAL_HAVE_FP=1",
"__cpp_nontype_template_parameter_auto=201606L",
"__UINT_LEAST16_MAX__=0xffff",
"__ATOMIC_ACQUIRE=2",
"__FLT_MIN__=1.1754943508222875e-38F",
"__GCC_IEC_559_COMPLEX=0",
"__XCHAL_HAVE_PREDICTED_BRANCHES=0",
"__cpp_aggregate_nsdmi=201304L",
"__UINT_LEAST8_TYPE__=unsigned char",
"__INTMAX_C(c)=c ## LL",
"__XCHAL_HAVE_ADDX=1",
"__CHAR_BIT__=8",
"__XCHAL_DCACHE_LINESIZE=16",
"__XTENSA_MARCH_EARLIEST=270012",
"__XCHAL_DCACHE_LINEWIDTH=4",
"__UINT8_MAX__=0xff",
"__WINT_MAX__=0xffffffffU",
"__FLT32_MIN_EXP__=(-125)",
"__cpp_static_assert=201411L",
"__ORDER_LITTLE_ENDIAN__=1234",
"__SIZE_MAX__=0xffffffffU",
"__WCHAR_MAX__=0xffff",
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1=1",
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2=1",
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4=1",
"__DBL_DENORM_MIN__=double(4.9406564584124654e-324L)",
"__GCC_ATOMIC_CHAR_LOCK_FREE=2",
"__GCC_IEC_559=0",
"__FLT32X_DECIMAL_DIG__=17",
"__FLT_EVAL_METHOD__=0",
"__cpp_binary_literals=201304L",
"__FLT64_DECIMAL_DIG__=17",
"__cpp_noexcept_function_type=201510L",
"__GCC_ATOMIC_CHAR32_T_LOCK_FREE=2",
"__cpp_variadic_templates=200704L",
"__UINT_FAST64_MAX__=0xffffffffffffffffULL",
"__SIG_ATOMIC_TYPE__=int",
"__DBL_MIN_10_EXP__=(-307)",
"__FINITE_MATH_ONLY__=0",
"__cpp_variable_templates=201304L",
"__XCHAL_HAVE_L32R=1",
"__FLT32X_MAX_EXP__=1024",
"__GNUC_PATCHLEVEL__=0",
"__FLT32_HAS_DENORM__=1",
"__UINT_FAST8_MAX__=0xffffffffU",
"__cpp_rvalue_reference=200610L",
"__XCHAL_HAVE_LOOPS=1",
"__cpp_nested_namespace_definitions=201411L",
"__XCHAL_DEBUGLEVEL=6",
"__INT8_C(c)=c",
"__XCHAL_HAVE_DFP_RECIP=0",
"__INT_LEAST8_WIDTH__=8",
"__cpp_variadic_using=201611L",
"__UINT_LEAST64_MAX__=0xffffffffffffffffULL",
"__INT_LEAST8_MAX__=0x7f",
"__cpp_attributes=200809L",
"__cpp_capture_star_this=201603L",
"__SHRT_MAX__=0x7fff",
"__LDBL_MAX__=1.7976931348623157e+308L",
"__cpp_if_constexpr=201606L",
"__XCHAL_ICACHE_LINESIZE=16",
"__LDBL_IS_IEC_60559__=1",
"__UINT_LEAST8_MAX__=0xff",
"__GCC_ATOMIC_BOOL_LOCK_FREE=2",
"__UINTMAX_TYPE__=long long unsigned int",
"__cpp_nsdmi=200809L",
"__FLT_EVAL_METHOD_TS_18661_3__=0",
"__UINT32_MAX__=0xffffffffUL",
"__GXX_EXPERIMENTAL_CXX0X__=1",
"__LDBL_MAX_EXP__=1024",
"__WINT_MIN__=0U",
"__FLT32X_IS_IEC_60559__=1",
"__XCHAL_HAVE_THREADPTR=1",
"__INT_LEAST16_WIDTH__=16",
"__SCHAR_MAX__=0x7f",
"__WCHAR_MIN__=0",
"__XCHAL_ICACHE_LINEWIDTH=4",
"__INT64_C(c)=c ## LL",
"__GCC_ATOMIC_POINTER_LOCK_FREE=2",
"__ATOMIC_SEQ_CST=5",
"__SIZEOF_INT__=4",
"__FLT32X_MANT_DIG__=53",
"__GCC_ATOMIC_CHAR16_T_LOCK_FREE=2",
"__cpp_aligned_new=201606L",
"__XCHAL_HAVE_FP_RECIP=1",
"__FLT32_MAX_10_EXP__=38",
"__STDC_HOSTED__=1",
"__XCHAL_HAVE_MUL32=1",
"__XTENSA_EL__=1",
"__cpp_decltype_auto=201304L",
"__DBL_DIG__=15",
"__XCHAL_HAVE_MUL16=1",
"__FLT_EPSILON__=1.1920928955078125e-7F",
"__GXX_WEAK__=1",
"__SHRT_WIDTH__=16",
"__FLT32_IS_IEC_60559__=1",
"__LDBL_MIN__=2.2250738585072014e-308L",
"__DBL_IS_IEC_60559__=1",
"__cpp_threadsafe_static_init=200806L",
"__cpp_enumerator_attributes=201411L",
"__XCHAL_HAVE_MMU=0",
"__FLT32X_HAS_INFINITY__=1",
"__INT32_MAX__=0x7fffffffL",
"__XCHAL_HAVE_DIV32=1",
"__INT_WIDTH__=32",
"__XTENSA_MARCH_LATEST=270012",
"__DECIMAL_DIG__=17",
"__FLT64_EPSILON__=2.2204460492503131e-16F64",
"__INT16_MAX__=0x7fff",
"__FLT64_MIN_EXP__=(-1021)",
"__XCHAL_DCACHE_SIZE=0",
"__LDBL_HAS_QUIET_NAN__=1",
"__cpp_return_type_deduction=201304L",
"__XCHAL_HAVE_BOOLEANS=1",
"__FLT64_MANT_DIG__=53",
"__XTHAL_ABI_WINDOWED=0",
"__GNUC__=14",
"__GXX_RTTI=1",
"__FLT_HAS_DENORM__=1",
"__SIZEOF_LONG_DOUBLE__=8",
"__XCHAL_HAVE_CONST16=0",
"__BIGGEST_ALIGNMENT__=16",
"__STDC_UTF_16__=1",
"__FLT64_MAX_10_EXP__=308",
"__cpp_delegating_constructors=200604L",
"__DBL_MAX__=double(1.7976931348623157e+308L)",
"__cpp_raw_strings=200710L",
"__INT_FAST32_MAX__=0x7fffffff",
"__DBL_HAS_INFINITY__=1",
"__cpp_deduction_guides=201703L",
"__HAVE_SPECULATION_SAFE_VALUE=1",
"__cpp_fold_expressions=201603L",
"__INTPTR_WIDTH__=32",
"__UINT_LEAST32_MAX__=0xffffffffUL",
"__FLT32X_HAS_DENORM__=1",
"__INT_FAST16_TYPE__=int",
"__XCHAL_HAVE_RELEASE_SYNC=1",
"__LDBL_HAS_DENORM__=1",
"__cplusplus=201703L",
"__cpp_ref_qualifiers=200710L",
"__INT_LEAST32_MAX__=0x7fffffffL",
"__DEPRECATED=1",
"__cpp_rvalue_references=200610L",
"__DBL_MAX_EXP__=1024",
"__WCHAR_WIDTH__=16",
"__FLT32_MAX__=3.4028234663852886e+38F32",
"__GCC_ATOMIC_LONG_LOCK_FREE=2",
"__PTRDIFF_MAX__=0x7fffffff",
"__FLT32_HAS_QUIET_NAN__=1",
"__GNUG__=14",
"__LONG_LONG_MAX__=0x7fffffffffffffffLL",
"__SIZEOF_SIZE_T__=4",
"__SIZEOF_WINT_T__=4",
"__FLT32X_DIG__=15",
"__LONG_LONG_WIDTH__=64",
"__cpp_initializer_lists=200806L",
"__FLT32_MAX_EXP__=128",
"__XCHAL_HAVE_MINMAX=1",
"__cpp_hex_float=201603L",
"__XCHAL_NUM_IBREAK=2",
"__GXX_ABI_VERSION=1019",
"__FLT_MIN_EXP__=(-125)",
"__cpp_lambdas=200907L",
"__INT_FAST64_TYPE__=long long int",
"__FP_FAST_FMAF=1",
"__FLT64_DENORM_MIN__=4.9406564584124654e-324F64",
"__DBL_MIN__=double(2.2250738585072014e-308L)",
"__SIZEOF_POINTER__=4",
"__DBL_HAS_QUIET_NAN__=1",
"__FLT32X_EPSILON__=2.2204460492503131e-16F32x",
"__XSHAL_HAVE_TEXT_SECTION_LITERALS=1",
"__FLT64_MIN_10_EXP__=(-307)",
"__REGISTER_PREFIX__",
"__UINT16_MAX__=0xffff",
"__XSHAL_USE_ABSOLUTE_LITERALS=0",
"__LDBL_HAS_INFINITY__=1",
"__FLT32_MIN__=1.1754943508222875e-38F32",
"__UINT8_TYPE__=unsigned char",
"__FLT_DIG__=6",
"__NO_INLINE__=1",
"__DEC_EVAL_METHOD__=2",
"__FLT_MANT_DIG__=24",
"__LDBL_DECIMAL_DIG__=17",
"__VERSION__=\"14.2.0\"",
"__UINT64_C(c)=c ## ULL",
"__XCHAL_NUM_AREGS=64",
"__cpp_unicode_characters=201411L",
"__XCHAL_HAVE_XEA3=0",
"__GCC_ATOMIC_INT_LOCK_FREE=2",
"__XCHAL_HAVE_DENSITY=1",
"__FLT32_MANT_DIG__=24",
"__FLOAT_WORD_ORDER__=__ORDER_LITTLE_ENDIAN__",
"__XCHAL_HAVE_CLAMPS=0",
"__XCHAL_HAVE_DFP_RSQRT=0",
"__cpp_aggregate_bases=201603L",
"__XCHAL_HAVE_NSA=1",
"__XCHAL_HAVE_WINDOWED=1",
"__SCHAR_WIDTH__=8",
"__INT32_C(c)=c ## L",
"__ORDER_PDP_ENDIAN__=3412",
"__INT_FAST32_TYPE__=int",
"__UINT_LEAST16_TYPE__=short unsigned int",
"__DBL_HAS_DENORM__=1",
"__XCHAL_HAVE_DEBUG=1",
"__cpp_rtti=199711L",
"__SIZE_TYPE__=unsigned int",
"__UINT64_MAX__=0xffffffffffffffffULL",
"__FLT_IS_IEC_60559__=1",
"__GNUC_WIDE_EXECUTION_CHARSET_NAME=\"UTF-16LE\"",
"__INT8_TYPE__=signed char",
"__cpp_digit_separators=201309L",
"__ELF__=1",
"__XSHAL_ABI=0",
"__xtensa__=1",
"__FLT_RADIX__=2",
"__INT_LEAST16_TYPE__=short int",
"__LDBL_EPSILON__=2.2204460492503131e-16L",
"__UINTMAX_C(c)=c ## ULL",
"__FLT32X_MIN__=2.2250738585072014e-308F32x",
"__XCHAL_HAVE_DFP_SQRT=0",
"__SIG_ATOMIC_MAX__=0x7fffffff",
"__XCHAL_HAVE_MAC16=1",
"__GCC_ATOMIC_WCHAR_T_LOCK_FREE=2",
"__USER_LABEL_PREFIX__",
"__SIZEOF_PTRDIFF_T__=4",
"__XCHAL_MMU_MIN_PTE_PAGE_SIZE=1",
"__XCHAL_DCACHE_IS_WRITEBACK=0",
"__SIZEOF_LONG__=4",
"__LDBL_DIG__=15",
"__FLT64_IS_IEC_60559__=1",
"__XCHAL_MAX_INSTRUCTION_SIZE=4",
"__FLT32X_MIN_EXP__=(-1021)",
"__INT_FAST16_MAX__=0x7fffffff",
"__GCC_CONSTRUCTIVE_SIZE=32",
"__FLT64_DIG__=15",
"__UINT_FAST32_MAX__=0xffffffffU",
"__UINT_LEAST64_TYPE__=long long unsigned int",
"__FLT_HAS_QUIET_NAN__=1",
"__FLT_MAX_10_EXP__=38",
"__FLT_HAS_INFINITY__=1",
"__GNUC_EXECUTION_CHARSET_NAME=\"UTF-8\"",
"__CHAR_UNSIGNED__=1",
"__cpp_unicode_literals=200710L",
"__UINT_FAST16_TYPE__=unsigned int",
"__INT_FAST32_WIDTH__=32",
"__CHAR16_TYPE__=short unsigned int",
"__PRAGMA_REDEFINE_EXTNAME=1",
"__SIZE_WIDTH__=32",
"__INT_LEAST16_MAX__=0x7fff",
"__INT64_MAX__=0x7fffffffffffffffLL",
"__FLT32_DENORM_MIN__=1.4012984643248171e-45F32",
"__SIG_ATOMIC_WIDTH__=32",
"__INT_LEAST64_TYPE__=long long int",
"__INT16_TYPE__=short int",
"__INT_LEAST8_TYPE__=signed char",
"__cpp_structured_bindings=201606L",
"__INT_FAST8_MAX__=0x7fffffff",
"__INTPTR_MAX__=0x7fffffff",
"__cpp_sized_deallocation=201309L",
"__cpp_guaranteed_copy_elision=201606L",
"__FLT64_HAS_QUIET_NAN__=1",
"__FLT32_MIN_10_EXP__=(-37)",
"__EXCEPTIONS=1",
"__UINT16_C(c)=c",
"__XCHAL_M_STAGE=2",
"__PTRDIFF_WIDTH__=32",
"__LDBL_MANT_DIG__=53",
"__cpp_range_based_for=201603L",
"__FLT64_HAS_INFINITY__=1",
"__STDCPP_DEFAULT_NEW_ALIGNMENT__=8",
"__SIG_ATOMIC_MIN__=(-__SIG_ATOMIC_MAX__ - 1)",
"__XCHAL_ICACHE_SIZE=0",
"__cpp_nontype_template_args=201411L",
"__INTPTR_TYPE__=int",
"__UINT16_TYPE__=short unsigned int",
"__WCHAR_TYPE__=short unsigned int",
"__XCHAL_HAVE_DEPBITS=0",
"__SIZEOF_FLOAT__=4",
"__UINTPTR_MAX__=0xffffffffU",
"__INT_FAST64_WIDTH__=64",
"__cpp_decltype=200707L",
"__FLT32_DECIMAL_DIG__=9",
"__INT_FAST64_MAX__=0x7fffffffffffffffLL",
"__GCC_ATOMIC_TEST_AND_SET_TRUEVAL=1",
"__FLT_NORM_MAX__=3.4028234663852886e+38F",
"__XCHAL_HAVE_DFP=0",
"__FLT32_HAS_INFINITY__=1",
"__UINT_FAST64_TYPE__=long long unsigned int",
"__cpp_inline_variables=201606L",
"__INT_MAX__=0x7fffffff",
"__XCHAL_HAVE_EXCLUSIVE=0",
"__STDCPP_THREADS__=1",
"__INT64_TYPE__=long long int",
"__XCHAL_HAVE_DFP_DIV=0",
"__FLT_MAX_EXP__=128",
"__XCHAL_INST_FETCH_WIDTH=4",
"__DBL_MANT_DIG__=53",
"__cpp_inheriting_constructors=201511L",
"__INT_LEAST64_MAX__=0x7fffffffffffffffLL",
"__FP_FAST_FMAF32=1",
"__WINT_TYPE__=unsigned int",
"__UINT_LEAST32_TYPE__=long unsigned int",
"__SIZEOF_SHORT__=2",
"__FLT32_NORM_MAX__=3.4028234663852886e+38F32",
"__LDBL_MIN_EXP__=(-1021)",
"__XCHAL_HAVE_S32C1I=1",
"__FLT64_MAX__=1.7976931348623157e+308F64",
"__WINT_WIDTH__=32",
"__cpp_template_auto=201606L",
"__INT_LEAST64_WIDTH__=64",
"__FLT32X_MAX_10_EXP__=308",
"__cpp_namespace_attributes=201411L",
"__WCHAR_UNSIGNED__=1",
"__LDBL_MAX_10_EXP__=308",
"__ATOMIC_RELAXED=0",
"__DBL_EPSILON__=double(2.2204460492503131e-16L)",
"__XCHAL_HAVE_SEXT=1",
"__INT_LEAST32_TYPE__=long int",
"__XTENSA_WINDOWED_ABI__=1",
"__UINT8_C(c)=c",
"__FLT64_MAX_EXP__=1024",
"__SIZEOF_WCHAR_T__=2",
"__XCHAL_HAVE_FP_POSTINC=1",
"__FLT64_NORM_MAX__=1.7976931348623157e+308F64",
"__INTMAX_MAX__=0x7fffffffffffffffLL",
"__INT_FAST8_TYPE__=int",
"__XCHAL_HAVE_MUL32_HIGH=1",
"__GNUC_STDC_INLINE__=1",
"__FLT64_HAS_DENORM__=1",
"__FLT32_EPSILON__=1.1920928955078125e-7F32",
"__DBL_DECIMAL_DIG__=17",
"__STDC_UTF_32__=1",
"__XCHAL_HAVE_FP_DIV=1",
"__INT_FAST8_WIDTH__=32",
"__FLT32X_MAX__=1.7976931348623157e+308F32x",
"__DBL_NORM_MAX__=double(1.7976931348623157e+308L)",
"__BYTE_ORDER__=__ORDER_LITTLE_ENDIAN__",
"__GCC_DESTRUCTIVE_SIZE=32",
"__XTENSA__=1",
"__INTMAX_WIDTH__=64",
"__ORDER_BIG_ENDIAN__=4321",
"__XTHAL_ABI_CALL0=1",
"__cpp_runtime_arrays=198712L",
"__FLT32_DIG__=6",
"__UINT64_TYPE__=long long unsigned int",
"__UINT32_C(c)=c ## UL",
"__cpp_alias_templates=200704L",
"__FLT_DENORM_MIN__=1.4012984643248171e-45F",
"__INT8_MAX__=0x7f",
"__LONG_WIDTH__=32",
"__UINT_FAST32_TYPE__=unsigned int",
"__FLT32X_NORM_MAX__=1.7976931348623157e+308F32x",
"__CHAR32_TYPE__=long unsigned int",
"__FLT_MAX__=3.4028234663852886e+38F",
"__cpp_constexpr=201603L",
"__XCHAL_HAVE_FP_RSQRT=1",
"__INT32_TYPE__=long int",
"__SIZEOF_DOUBLE__=8",
"__cpp_exceptions=199711L",
"__FLT_MIN_10_EXP__=(-37)",
"__FLT64_MIN__=2.2250738585072014e-308F64",
"__INT_LEAST32_WIDTH__=32",
"__INTMAX_TYPE__=long long int",
"__XCHAL_HAVE_ABS=1",
"__FLT32X_HAS_QUIET_NAN__=1",
"__ATOMIC_CONSUME=1",
"__XCHAL_NUM_DBREAK=2",
"__XCHAL_HAVE_WIDE_BRANCHES=0",
"__GNUC_MINOR__=2",
"__INT_FAST16_WIDTH__=32",
"__UINTMAX_MAX__=0xffffffffffffffffULL",
"__FLT32X_DENORM_MIN__=4.9406564584124654e-324F32x",
"__cpp_template_template_args=201611L",
"__DBL_MAX_10_EXP__=308",
"__LDBL_DENORM_MIN__=4.9406564584124654e-324L",
"__INT16_C(c)=c",
"__STDC__=1",
"__PTRDIFF_TYPE__=int",
"__LONG_MAX__=0x7fffffffL",
"__XCHAL_HAVE_FP_SQRT=1",
"__UINT32_TYPE__=long unsigned int",
"__FLT32X_MIN_10_EXP__=(-307)",
"__UINTPTR_TYPE__=unsigned int",
"__LDBL_MIN_10_EXP__=(-307)",
"__cpp_generic_lambdas=201304L",
"__SIZEOF_LONG_LONG__=8",
"__cpp_user_defined_literals=200809L",
"__GCC_ATOMIC_LLONG_LOCK_FREE=1",
"__FLT_DECIMAL_DIG__=9",
"__UINT_FAST16_MAX__=0xffffffffU",
"__LDBL_NORM_MAX__=1.7976931348623157e+308L",
"__GCC_ATOMIC_SHORT_LOCK_FREE=2",
"__XCHAL_HAVE_BE=0",
"__UINT_FAST8_TYPE__=unsigned int",
"__cpp_init_captures=201304L",
"__ATOMIC_ACQ_REL=4",
"__ATOMIC_RELEASE=3",
"USBCON"
]
}
]
}

93
README.md Normal file
View File

@@ -0,0 +1,93 @@
# AI Voice Assistant Gateway (ESP32-S3 + Docker)
## 🎯 Project Objective
A private, local voice assistant system that separates high-bandwidth audio streaming from smart home command logic.
- **Frontend:** ESP32-S3 acts as a dumb "microphone-to-MQTT" bridge.
- **Backend:** Docker container performs Wake Word detection (OpenWakeWord) and Speech-to-Text (Faster-Whisper).
- **Controller:** Home Assistant receives clean text commands for execution.
## 🏗️ Architecture
The system uses a **Dual-Broker** strategy to prevent flooding Home Assistant with raw audio data.
```mermaid
graph LR
Mic[INMP441] -->|I2S| ESP32
ESP32 -->|Raw Audio (Voice Broker)| MQTT_Voice[Mosquitto .13]
subgraph Docker Server [.13]
MQTT_Voice -->|Sub Audio| Bridge[Python Bridge]
Bridge -->|HTTP| Whisper[Whisper API]
Whisper -->|Text| Bridge
end
Bridge -->|Text Command (HA Broker)| MQTT_HA[Mosquitto .30]
MQTT_HA -->|Trigger| HA[Home Assistant]
HA -->|Action| Lights/Scripts
```
## 📂 File Structure
### 1. Firmware (Client)
Location: `~/Documents/Arduino/voice_assistant/`
* **`voice_assistant.ino`**: Main ESP32 firmware. Handles I2S reading, VAD (Voice Activity Detection), and MQTT streaming.
* **Dependencies**: `PubSubClient`, `Freenove_WS2812_Lib_for_ESP32`.
### 2. Backend (Server)
Location: `~/voice_bridge/` (On Server .13)
* **`docker-compose.yml`**: Orchestrates the Whisper and Bridge containers.
* **`mqtt_audio_bridge.py`**: The "Brain".
* Listens to Audio on `.13`.
* Buffers audio and checks for Wake Word ("Hey Jarvis").
* Sends valid audio to Whisper.
* Publishes resulting text to Home Assistant Broker `.30`.
* **`app.py`**: A lightweight Flask wrapper for `faster-whisper` (running in separate container).
## 🚦 LED Status Indicators (ESP32)
The LED Ring provides real-time feedback on the device state.
| Color | State | Trigger |
| :--- | :--- | :--- |
| **Off** | Idle | Listening for sound (VAD). |
| **Green** | Recording | Sound detected above threshold. Streaming audio. |
| **Blue** | Processing | Silence detected. End of stream sent to server. |
| **Rainbow** | Acknowledged | "Wake Word" detected by server OR Command executed. |
| **Red** | Error | Wi-Fi or MQTT connection loss. |
## ⚙️ Configuration Details
### Hardware Config (ESP32-S3)
* **Mic SCK:** GPIO 4
* **Mic WS:** GPIO 5
* **Mic SD:** GPIO 6
* **LED Pin:** GPIO 5
* **VAD Threshold:** `1000` (Adjust based on noise floor)
* **Soft Gain:** `x6` (Multiplies raw input to match Whisper requirements)
### Docker Environment
* **Network:** Internal bridge network between Bridge and Whisper.
* **Models:**
* Wake Word: `hey_jarvis` (OpenWakeWord)
* STT: `small.en` (Faster-Whisper, int8 quantization)
## 🚀 Setup & Commands
**1. Flash ESP32**
```bash
arduino-cli upload -v -p /dev/ttyACM0 --fqbn esp32:esp32:esp32s3:CDCOnBoot=cdc,USBMode=hwcdc,PSRAM=disabled,FlashMode=dio,DebugLevel=info --input-dir ./build
```
**2. Start Backend**
```bash
cd ~/voice_bridge
docker compose up -d
```
**3. Monitor Logs**
```bash
docker compose logs -f voice_bridge
```
**4. Monitor Audio Stream (Debug)**
```bash
mosquitto_sub -h 192.168.20.13 -u "MQTT_USER_REDACTED" -P "pass" -t "voice/audio_stream" | awk '{printf "."}'
```

31
config.h Normal file
View File

@@ -0,0 +1,31 @@
#pragma once
// --- WiFi ---
const char* WIFI_SSID = "Aussie Broadband 8729";
const char* WIFI_PASS = "WIFI_PASS_REDACTED";
// --- MQTT ---
const char* MQTT_BROKER = "192.168.20.30";
const int MQTT_PORT = 1883;
const char* MQTT_USER = "MQTT_USER_REDACTED";
const char* MQTT_PASS = "MQTT_PASS_REDACTED";
// --- MQTT Topics ---
const char* TOPIC_AUDIO = "homeassistant/voice/audio";
const char* TOPIC_ACK = "homeassistant/voice/ack"; // HA replies here
// --- Hardware Pins (ESP32-S3) ---
// CHECK YOUR BOARD IMAGE FOR THESE PINS
#define I2S_SD 10 // Serial Data (INMP441 SD)
#define I2S_WS 11 // Word Select (INMP441 WS/LRCK)
#define I2S_SCK 12 // Serial Clock (INMP441 SCK/BCLK)
// --- LED Ring ---
#define LED_PIN 48 // CHECK PIN (Often 48 on S3-Zero, or 21, 38, etc)
#define NUM_LEDS 12
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
// --- Audio ---
#define SAMPLE_RATE 16000
#define BUFFER_LEN 1024 // Buffer size for MQTT chunks

75
led_control.h Normal file
View File

@@ -0,0 +1,75 @@
#pragma once
#include <Freenove_WS2812_Lib_for_ESP32.h>
#include "config.h"
// Initialize (LED_COUNT, LED_PIN, CHANNEL, TYPE)
// Channel 0 is fine.
Freenove_ESP32_WS2812 strip(NUM_LEDS, LED_PIN, 0, TYPE_GRB);
enum DeviceState {
STATE_IDLE,
STATE_WAKE_DETECTED,
STATE_RECORDING,
STATE_TRANSMITTING,
STATE_ACK_RECEIVED,
STATE_ERROR
};
DeviceState currentState = STATE_IDLE;
unsigned long stateTimer = 0;
void setupLEDs() {
strip.begin();
strip.setBrightness(30);
strip.show(); // Off
}
// Helper for Color compatibility
uint32_t Color(uint8_t r, uint8_t g, uint8_t b) {
return strip.Wheel((r << 16) | (g << 8) | b); // Not used by this lib but keeps API
}
void setRingColor(uint32_t r, uint8_t g, uint8_t b) {
strip.setAllLedsColor(r, g, b);
}
// Overload for compatibility with previous code calling Color()
// We actually just need to rewrite the helper slightly
void setRingColor(uint32_t color) {
// Extract RGB from 32-bit int
uint8_t r = (uint8_t)(color >> 16);
uint8_t g = (uint8_t)(color >> 8);
uint8_t b = (uint8_t)color;
strip.setAllLedsColor(r, g, b);
}
void updateLEDs() {
switch (currentState) {
case STATE_IDLE:
strip.setAllLedsColor(0, 0, 0);
break;
case STATE_WAKE_DETECTED:
strip.setAllLedsColor(255, 0, 0);
break;
case STATE_RECORDING:
strip.setAllLedsColor(0, 255, 0);
break;
case STATE_TRANSMITTING:
strip.setAllLedsColor(0, 0, 255);
break;
case STATE_ERROR:
strip.setAllLedsColor(255, 255, 255);
break;
case STATE_ACK_RECEIVED:
// Simple rainbow
for (int j = 0; j < 255; j += 2) {
for (int i = 0; i < NUM_LEDS; i++) {
strip.setLedColorData(i, strip.Wheel((i * 256 / NUM_LEDS + j) & 255));
}
strip.show();
delay(10);
}
currentState = STATE_IDLE;
break;
}
}

105
mqtt_audio_bridge.py Normal file
View File

@@ -0,0 +1,105 @@
import paho.mqtt.client as mqtt
import requests
import wave
import io
import numpy as np
import openwakeword
from openwakeword.model import Model
# --- CONFIG ---
MQTT_BROKER = "192.168.20.30"
MQTT_USER = "MQTT_USER_REDACTED"
MQTT_PASS = "MQTT_PASS_REDACTED"
TOPIC_AUDIO = "homeassistant/voice/audio"
TOPIC_ACK = "homeassistant/voice/ack"
TOPIC_TEXT = "homeassistant/voice/text"
WHISPER_URL = "http://localhost:5000/transcribe"
WAKE_WORD_MODEL = "hey_jarvis" # or 'alexa', 'hey_mycroft', 'timer', 'weather'
# --- STATE ---
# We buffer audio here.
# 1. We feed it to WakeWord.
# 2. If WakeWord triggers, we KEEP recording for the command.
audio_buffer = bytearray()
is_command_mode = False
command_buffer = bytearray()
print("Loading OpenWakeWord...")
owwModel = Model(wakeword_models=[WAKE_WORD_MODEL])
def send_to_whisper(raw_data):
print(f"Sending {len(raw_data)} bytes to Whisper...")
wav_io = io.BytesIO()
with wave.open(wav_io, "wb") as wav_file:
wav_file.setnchannels(1)
wav_file.setsampwidth(2)
wav_file.setframerate(16000)
wav_file.writeframes(raw_data)
wav_io.seek(0)
try:
files = {'audio': ('cmd.wav', wav_io, 'audio/wav')}
res = requests.post(WHISPER_URL, files=files)
if res.status_code == 200:
text = res.json().get("transcript", "")
print(f"COMMAND: {text}")
client.publish(TOPIC_TEXT, text)
client.publish(TOPIC_ACK, "OK") # Rainbow LED
else:
print("Whisper Error")
except Exception as e:
print(f"Error: {e}")
def on_message(client, userdata, msg):
global audio_buffer, is_command_mode, command_buffer
if msg.topic == TOPIC_AUDIO:
payload = msg.payload
# 1. If we are already listening for a command, just accumulate
if is_command_mode:
command_buffer.extend(payload)
# If buffer gets too big (e.g. 5 seconds), cut it off
if len(command_buffer) > 16000 * 2 * 5:
print("Timeout. Sending...")
send_to_whisper(command_buffer)
is_command_mode = False
command_buffer = bytearray()
return
# 2. If NOT in command mode, feed OpenWakeWord
# OWW needs 1280 samples (2560 bytes) chunks usually
audio_buffer.extend(payload)
# Process in chunks
chunk_size = 1280 * 2 # 1280 samples * 2 bytes
while len(audio_buffer) >= chunk_size:
chunk = audio_buffer[:chunk_size]
audio_buffer = audio_buffer[chunk_size:]
# Convert to numpy for OWW
audio_int16 = np.frombuffer(chunk, dtype=np.int16)
# Predict
prediction = owwModel.predict(audio_int16)
# Check score (0.0 to 1.0)
if prediction[WAKE_WORD_MODEL] > 0.5:
print(f"WAKE WORD DETECTED: {WAKE_WORD_MODEL}")
is_command_mode = True
command_buffer = bytearray() # Start fresh for command
# Optional: Send "Awake" LED command to ESP32 here
elif msg.topic == "homeassistant/voice/status" and msg.payload.decode() == "processing":
# ESP32 finished its VAD stream.
if is_command_mode:
send_to_whisper(command_buffer)
is_command_mode = False
command_buffer = bytearray()
client = mqtt.Client()
client.username_pw_set(MQTT_USER, MQTT_PASS)
client.connect(MQTT_BROKER, 1883)
client.subscribe([(TOPIC_AUDIO, 0), ("homeassistant/voice/status", 0)])
client.loop_forever()

9620
okay_nabu.h Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
okay_nabu.tflite Normal file
View File

Binary file not shown.

168
voice_assistant.ino Normal file
View File

@@ -0,0 +1,168 @@
#include <WiFi.h>
#include <PubSubClient.h>
#include <driver/i2s.h>
#include <Freenove_WS2812_Lib_for_ESP32.h>
// --- CONNECTIVITY ---
const char* WIFI_SSID = "Aussie Broadband 8729";
const char* WIFI_PASS = "WIFI_PASS_REDACTED";
// POINT TO VOICE SERVER (Not Home Assistant)
const char* MQTT_BROKER = "192.168.20.13";
const int MQTT_PORT = 1883;
const char* MQTT_USER = "MQTT_USER_REDACTED";
const char* MQTT_PASS = "MQTT_PASS_REDACTED";
const char* TOPIC_AUDIO = "voice/audio_stream";
const char* TOPIC_ACK = "voice/status";
// --- HARDWARE ---
#define I2S_SCK 4
#define I2S_WS 5
#define I2S_SD 6
#define I2S_PORT I2S_NUM_0
#define LED_PIN 5
#define NUM_LEDS 12
// --- AUDIO TUNING ---
// Increased to 2000 to ignore footsteps/typing (Range is 0-32768)
#define VAD_THRESHOLD 1000
const int BLOCK_SIZE = 512;
int16_t sBuffer[BLOCK_SIZE];
// ... (Rest of Objects/Config remains standard) ...
WiFiClient espClient;
PubSubClient mqtt(espClient);
Freenove_ESP32_WS2812 strip(NUM_LEDS, LED_PIN, 0, TYPE_GRB);
enum DeviceState { STATE_IDLE, STATE_RECORDING, STATE_TRANSMITTING, STATE_ACK_RECEIVED };
DeviceState currentState = STATE_IDLE;
unsigned long stateTimer = 0;
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 16000,
.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = I2S_COMM_FORMAT_STAND_I2S,
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64,
.use_apll =true
};
const i2s_pin_config_t pin_config = {
.bck_io_num = I2S_SCK,
.ws_io_num = I2S_WS,
.data_out_num = I2S_PIN_NO_CHANGE,
.data_in_num = I2S_SD
};
// ... (LED Helpers remain the same) ...
void setRingColor(uint8_t r, uint8_t g, uint8_t b) {
strip.setAllLedsColor(r, g, b);
strip.show();
}
void updateLEDs() {
if (currentState == STATE_ACK_RECEIVED) {
for (int j = 0; j < 255; j += 10) {
for (int i = 0; i < NUM_LEDS; i++) {
byte pos = (i * 256 / NUM_LEDS + j) & 255;
if(pos < 85) { strip.setLedColorData(i, pos * 3, 255 - pos * 3, 0); }
else if(pos < 170) { pos -= 85; strip.setLedColorData(i, 255 - pos * 3, 0, pos * 3); }
else { pos -= 170; strip.setLedColorData(i, 0, pos * 3, 255 - pos * 3); }
}
strip.show();
delay(5);
}
currentState = STATE_IDLE;
setRingColor(0,0,0);
}
}
void mqttCallback(char* topic, byte* payload, unsigned int length) {
// If Bridge sends a "WAKE" or "OK" message
currentState = STATE_ACK_RECEIVED;
}
void setup() {
delay(2000);
Serial.begin(115200);
// High Buffer for Audio
mqtt.setBufferSize(2048);
strip.begin();
strip.setBrightness(30);
setRingColor(50, 50, 50);
i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
i2s_set_pin(I2S_PORT, &pin_config);
WiFi.begin(WIFI_SSID, WIFI_PASS);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
setRingColor(0, 0, 255); delay(100); setRingColor(0,0,0);
}
mqtt.setServer(MQTT_BROKER, MQTT_PORT);
mqtt.setCallback(mqttCallback);
setRingColor(0,0,0);
}
void loop() {
if (!mqtt.connected()) {
if (mqtt.connect("ESP32Mic", MQTT_USER, MQTT_PASS)) {
mqtt.subscribe(TOPIC_ACK);
}
}
mqtt.loop();
updateLEDs();
size_t bytesRead;
i2s_read(I2S_PORT, &sBuffer, sizeof(sBuffer), &bytesRead, portMAX_DELAY);
// --- GAIN BOOST (x8) ---
for (int i = 0; i < bytesRead / 2; i++) {
int32_t boosted = sBuffer[i] * 6;
if (boosted > 32767) boosted = 32767;
if (boosted < -32768) boosted = -32768;
sBuffer[i] = (int16_t)boosted;
}
long sum = 0;
for (int i = 0; i < bytesRead / 2; i++) {
sum += abs(sBuffer[i]);
}
int avg = sum / (bytesRead / 2);
// Debug (View this to tune threshold)
// Serial.printf("Vol: %d\n", avg);
if (currentState == STATE_IDLE && avg > VAD_THRESHOLD) {
currentState = STATE_RECORDING;
stateTimer = millis();
setRingColor(0, 255, 0); // Green
mqtt.publish(TOPIC_AUDIO, (const uint8_t*)sBuffer, bytesRead);
}
if (currentState == STATE_RECORDING) {
mqtt.publish(TOPIC_AUDIO, (const uint8_t*)sBuffer, bytesRead);
if (avg > VAD_THRESHOLD) stateTimer = millis();
// Silence Timeout (1.5s)
if (millis() - stateTimer > 1500) {
currentState = STATE_TRANSMITTING;
// Send marker to Voice Server
mqtt.publish("voice/status", "processing");
setRingColor(0, 0, 255); // Blue
}
}
if (currentState == STATE_TRANSMITTING && millis() - stateTimer > 4000) {
currentState = STATE_IDLE;
setRingColor(0,0,0);
}
}