split between to device to have bluetooth or usb otg function.

main/bluetooth/bt_hfp.c

@@ -5,19 +5,24 @@
  * Headset ist das HF (Hands-Free) Device
  *
  * Angepasst für ESP-IDF 5.x
+ * Nur auf ESP32 (nicht S3/C3) verfügbar
  */
 
 #include <string.h>
 #include "bt_hfp.h"
 #include "bt_manager.h"
 #include "esp_log.h"
+#include "sdkconfig.h"
+
+static const char* TAG = "BT_HFP";
+
+#if CONFIG_BT_ENABLED
+
 #include "esp_hf_ag_api.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/ringbuf.h"
 
-static const char* TAG = "BT_HFP";
-
 // Audio Buffer
 #define AUDIO_RINGBUF_SIZE  (8 * 1024)
 static RingbufHandle_t s_audio_out_ringbuf = NULL;
@@ -343,3 +348,57 @@ bool bt_hfp_is_audio_connected(void)
 {
     return s_audio_connected;
 }
+
+#else // CONFIG_BT_ENABLED not set - Stub-Implementierungen
+
+esp_err_t bt_hfp_init(void)
+{
+    ESP_LOGW(TAG, "HFP nicht verfügbar (Bluetooth Classic deaktiviert)");
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t bt_hfp_deinit(void)
+{
+    return ESP_OK;
+}
+
+esp_err_t bt_hfp_connect(const uint8_t* address)
+{
+    (void)address;
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t bt_hfp_disconnect(const uint8_t* address)
+{
+    (void)address;
+    return ESP_OK;
+}
+
+esp_err_t bt_hfp_audio_connect(void)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t bt_hfp_audio_disconnect(void)
+{
+    return ESP_OK;
+}
+
+esp_err_t bt_hfp_send_audio(const uint8_t* data, size_t len)
+{
+    (void)data;
+    (void)len;
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+bool bt_hfp_is_connected(void)
+{
+    return false;
+}
+
+bool bt_hfp_is_audio_connected(void)
+{
+    return false;
+}
+
+#endif // CONFIG_BT_ENABLED

main/bluetooth/bt_manager.c

@@ -2,14 +2,21 @@
  * Bluetooth Manager - Verwaltet Bluetooth Classic Headsets
  *
  * Unterstützt HFP (Hands-Free Profile) für Headsets
+ * Nur auf ESP32 (nicht S3/C3) verfügbar
  */
 
 #include <string.h>
 #include <stdio.h>
 #include "bt_manager.h"
+#include "sdkconfig.h"
+#include "esp_log.h"
+
+static const char* TAG = "BT_MGR";
+
+#if CONFIG_BT_ENABLED
+
 #include "bt_hfp.h"
 #include "config/config_manager.h"
-#include "esp_log.h"
 #include "esp_bt.h"
 #include "esp_bt_main.h"
 #include "esp_bt_device.h"
@@ -18,8 +25,6 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 
-static const char* TAG = "BT_MGR";
-
 // State
 static bool s_initialized = false;
 static bool s_discovering = false;
@@ -144,7 +149,6 @@ esp_err_t bt_manager_init(void)
 
     // Bluetooth Controller konfigurieren
     esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
-    // Mode wird bei esp_bt_controller_enable() gesetzt
 
     esp_err_t ret = esp_bt_controller_init(&bt_cfg);
     if (ret != ESP_OK) {
@@ -152,7 +156,7 @@ esp_err_t bt_manager_init(void)
         return ret;
     }
 
-    ret = esp_bt_controller_enable(ESP_BT_MODE_BTDM);
+    ret = esp_bt_controller_enable(ESP_BT_MODE_CLASSIC_BT);
     if (ret != ESP_OK) {
         ESP_LOGE(TAG, "BT Controller enable failed: %s", esp_err_to_name(ret));
         return ret;
@@ -388,29 +392,6 @@ void bt_manager_register_audio_data_callback(bt_audio_data_callback_t callback)
     s_audio_data_callback = callback;
 }
 
-// Utility Functions
-void bt_addr_to_str(const esp_bd_addr_t addr, char* str, size_t len)
-{
-    snprintf(str, len, "%02X:%02X:%02X:%02X:%02X:%02X",
-             addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
-}
-
-esp_err_t bt_str_to_addr(const char* str, esp_bd_addr_t addr)
-{
-    unsigned int values[6];
-    if (sscanf(str, "%02X:%02X:%02X:%02X:%02X:%02X",
-               &values[0], &values[1], &values[2],
-               &values[3], &values[4], &values[5]) != 6) {
-        return ESP_ERR_INVALID_ARG;
-    }
-
-    for (int i = 0; i < 6; i++) {
-        addr[i] = (uint8_t)values[i];
-    }
-
-    return ESP_OK;
-}
-
 // Internal: Wird von bt_hfp aufgerufen
 void bt_manager_notify_connected(const esp_bd_addr_t address)
 {
@@ -453,3 +434,122 @@ void bt_manager_notify_audio_data(const uint8_t* data, size_t len)
         s_audio_data_callback(data, len);
     }
 }
+
+bool bt_manager_is_available(void)
+{
+    return true;
+}
+
+#else // CONFIG_BT_ENABLED not set - Stub-Implementierung für ESP32-S3
+
+// Stub-Implementierungen wenn Bluetooth nicht verfügbar ist
+
+esp_err_t bt_manager_init(void)
+{
+    ESP_LOGW(TAG, "Bluetooth Classic nicht verfügbar auf diesem Chip");
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t bt_manager_deinit(void)
+{
+    return ESP_OK;
+}
+
+esp_err_t bt_manager_start_discovery(void)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t bt_manager_stop_discovery(void)
+{
+    return ESP_OK;
+}
+
+esp_err_t bt_manager_pair(const esp_bd_addr_t address)
+{
+    (void)address;
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t bt_manager_unpair(const esp_bd_addr_t address)
+{
+    (void)address;
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t bt_manager_connect(const esp_bd_addr_t address)
+{
+    (void)address;
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t bt_manager_disconnect(const esp_bd_addr_t address)
+{
+    (void)address;
+    return ESP_OK;
+}
+
+esp_err_t bt_manager_disconnect_all(void)
+{
+    return ESP_OK;
+}
+
+bool bt_manager_is_connected(void)
+{
+    return false;
+}
+
+esp_err_t bt_manager_get_connected_device(esp_bd_addr_t address)
+{
+    (void)address;
+    return ESP_ERR_NOT_FOUND;
+}
+
+esp_err_t bt_manager_set_discoverable(bool discoverable)
+{
+    (void)discoverable;
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t bt_manager_send_audio(const uint8_t* data, size_t len)
+{
+    (void)data;
+    (void)len;
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+void bt_manager_register_device_callback(bt_device_callback_t callback) { (void)callback; }
+void bt_manager_register_discovery_callback(bt_discovery_callback_t callback) { (void)callback; }
+void bt_manager_register_audio_callback(bt_audio_callback_t callback) { (void)callback; }
+void bt_manager_register_button_callback(bt_button_callback_t callback) { (void)callback; }
+void bt_manager_register_audio_data_callback(bt_audio_data_callback_t callback) { (void)callback; }
+
+bool bt_manager_is_available(void)
+{
+    return false;
+}
+
+#endif // CONFIG_BT_ENABLED
+
+// Utility Functions - immer verfügbar
+void bt_addr_to_str(const esp_bd_addr_t addr, char* str, size_t len)
+{
+    snprintf(str, len, "%02X:%02X:%02X:%02X:%02X:%02X",
+             addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
+}
+
+esp_err_t bt_str_to_addr(const char* str, esp_bd_addr_t addr)
+{
+    unsigned int values[6];
+    if (sscanf(str, "%02X:%02X:%02X:%02X:%02X:%02X",
+               &values[0], &values[1], &values[2],
+               &values[3], &values[4], &values[5]) != 6) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    for (int i = 0; i < 6; i++) {
+        addr[i] = (uint8_t)values[i];
+    }
+
+    return ESP_OK;
+}

main/bluetooth/bt_manager.h

@@ -3,7 +3,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include "esp_err.h"
-#include "esp_bt_defs.h"
+#include "sdkconfig.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -28,6 +28,14 @@ typedef enum {
     BT_AUDIO_STATE_STREAMING
 } bt_audio_state_t;
 
+// Bluetooth Address Type (für Plattform-Unabhängigkeit)
+#if CONFIG_BT_ENABLED
+#include "esp_bt_defs.h"
+#else
+typedef uint8_t esp_bd_addr_t[6];
+#define ESP_BD_ADDR_LEN 6
+#endif
+
 // Entdecktes Bluetooth-Gerät
 typedef struct {
     esp_bd_addr_t address;
@@ -140,6 +148,11 @@ void bt_addr_to_str(const esp_bd_addr_t addr, char* str, size_t len);
  */
 esp_err_t bt_str_to_addr(const char* str, esp_bd_addr_t addr);
 
+/**
+ * Prüft ob Bluetooth verfügbar ist (Hardware-Support)
+ */
+bool bt_manager_is_available(void);
+
 #ifdef __cplusplus
 }
 #endif

main/usb_audio/usb_audio_host.c

@@ -2,18 +2,23 @@
  * USB Audio Host - USB Headset Unterstützung
  *
  * Verwendet ESP32-S3 USB OTG im Host-Modus für USB Audio Class Geräte
+ * Nur auf ESP32-S3 verfügbar (USB OTG Hardware)
  */
 
 #include <string.h>
 #include "usb_audio_host.h"
 #include "esp_log.h"
+#include "sdkconfig.h"
+
+static const char* TAG = "USB_AUDIO";
+
+#if CONFIG_IDF_TARGET_ESP32S3
+
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/ringbuf.h"
 #include "usb/usb_host.h"
 
-static const char* TAG = "USB_AUDIO";
-
 // USB Audio Class Definitionen
 #define USB_CLASS_AUDIO         0x01
 #define USB_SUBCLASS_AUDIOCONTROL   0x01
@@ -354,3 +359,77 @@ void usb_audio_host_register_button_callback(usb_button_callback_t callback)
 {
     s_button_callback = callback;
 }
+
+bool usb_audio_host_is_available(void)
+{
+    return true;
+}
+
+#else // Nicht ESP32-S3 - Stub-Implementierungen
+
+esp_err_t usb_audio_host_init(void)
+{
+    ESP_LOGW(TAG, "USB Audio Host nicht verfügbar (nur ESP32-S3)");
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t usb_audio_host_deinit(void)
+{
+    return ESP_OK;
+}
+
+usb_audio_state_t usb_audio_host_get_state(void)
+{
+    return USB_AUDIO_STATE_NOT_CONNECTED;
+}
+
+bool usb_audio_host_is_connected(void)
+{
+    return false;
+}
+
+esp_err_t usb_audio_host_get_info(usb_audio_info_t* info)
+{
+    (void)info;
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t usb_audio_host_start_stream(void)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t usb_audio_host_stop_stream(void)
+{
+    return ESP_OK;
+}
+
+esp_err_t usb_audio_host_send(const uint8_t* data, size_t len)
+{
+    (void)data;
+    (void)len;
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t usb_audio_host_set_volume(uint8_t volume)
+{
+    (void)volume;
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t usb_audio_host_set_mute(bool mute)
+{
+    (void)mute;
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+void usb_audio_host_register_state_callback(usb_audio_state_callback_t callback) { (void)callback; }
+void usb_audio_host_register_data_callback(usb_audio_data_callback_t callback) { (void)callback; }
+void usb_audio_host_register_button_callback(usb_button_callback_t callback) { (void)callback; }
+
+bool usb_audio_host_is_available(void)
+{
+    return false;
+}
+
+#endif // CONFIG_IDF_TARGET_ESP32S3

main/usb_audio/usb_audio_host.h

@@ -3,6 +3,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include "esp_err.h"
+#include "sdkconfig.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -103,6 +104,11 @@ void usb_audio_host_register_state_callback(usb_audio_state_callback_t callback)
 void usb_audio_host_register_data_callback(usb_audio_data_callback_t callback);
 void usb_audio_host_register_button_callback(usb_button_callback_t callback);
 
+/**
+ * Prüft ob USB Audio Host verfügbar ist (Hardware-Support)
+ */
+bool usb_audio_host_is_available(void);
+
 #ifdef __cplusplus
 }
 #endif