/* ============================================================ FeTAp 611 KI-Telefon - Bauprojekt V1.3 ============================================================ Funktionen: - FeTAp 611 Gabelkontakt: LOW = Hörer abgehoben - Wählscheibe NSI an GPIO 8, interner Pull-Up - INMP441 Mikrofon an GPIO 16/15/17 - MAX98357A an GPIO 4/5/6 - OpenAI Realtime API über WebSocket/SSL - Server VAD + Unterbrechung der KI-Antwort - Wetter über Open-Meteo - Datum/Uhrzeit über NTP, Zeitzone Europe/Berlin - Wikipedia-Suche über de.wikipedia.org - Wählscheibe: 1 Hilfe, 2 freier Chat, 3 Wetter, 4 Datum/Uhrzeit, 5 Wikipedia - Ziffern 6-9 und 0 sind für spätere Funktionen reserviert WICHTIG: In der Bibliothek "WebSockets by Markus Sattler" muss für den ESP32 in WebSockets.h die maximale Datenlänge auf 64 KB erhöht sein, damit die Realtime-Audio-JSON-Nachrichten nicht verworfen werden: #define WEBSOCKETS_MAX_DATA_SIZE (64 * 1024) Nur die ESP32-Stelle ändern. Arduino Board: - ESP32S3 Dev Module - PSRAM: OPI PSRAM Benötigte Bibliotheken: - WiFi (ESP32 Core) - WebSockets by Markus Sattler - HTTPClient (ESP32 Core) - WiFiClientSecure (ESP32 Core) - time.h (ESP32 Core) ============================================================ */ #include #include #include #include #include #include #include #include #include #include #include "esp_heap_caps.h" // ============================================================ // WLAN / OPENAI // ============================================================ const char* WIFI_SSID = "WLAN Name"; const char* WIFI_PASSWORD = "WLAN Schlüssel"; // Deinen bereits vorhandenen OpenAI API-Key hier einsetzen. const char* OPENAI_API_KEY = "APK-Key"; // ============================================================ // FE(T)AP / ESP32 PINS // ============================================================ constexpr int PIN_HOOK = 7; // HIGH = aufgelegt, LOW = abgehoben constexpr int PIN_DIAL = 8; // NSI, interner Pull-Up // INMP441 constexpr int PIN_MIC_SCK = 16; constexpr int PIN_MIC_WS = 15; constexpr int PIN_MIC_SD = 17; // MAX98357A constexpr int PIN_AMP_BCLK = 4; constexpr int PIN_AMP_LRC = 5; constexpr int PIN_AMP_DIN = 6; // ============================================================ // AUDIO // ============================================================ constexpr int SAMPLE_RATE = 24000; constexpr int MIC_RAW_SAMPLES = 960; // 40 ms bei 24 kHz // Ein Realtime-Audio-Delta ist bei 24 kHz/16 Bit typischerweise // deutlich kleiner als 20 kB Rohdaten. 20.000 Byte geben Reserve. constexpr size_t OUTPUT_PCM_CAPACITY = 20000; // 32 Slots wie in der funktionierenden V1.0/V1.1 Architektur. constexpr int OUTPUT_SLOTS = 64; constexpr int PLAYBACK_SAMPLES_PER_WRITE = 960; struct OutputSlot { uint8_t* data = nullptr; size_t length = 0; }; OutputSlot outputSlots[OUTPUT_SLOTS]; QueueHandle_t outputFreeQueue = nullptr; QueueHandle_t outputReadyQueue = nullptr; volatile bool playbackBusy = false; volatile bool playbackCancelRequested = false; volatile int currentOutputSlot = -1; volatile unsigned long receivedAudioBlocks = 0; volatile unsigned long droppedAudioBlocks = 0; TaskHandle_t playbackTaskHandle = nullptr; // ============================================================ // I2S HANDLES // ============================================================ i2s_port_t I2S_MIC = I2S_NUM_1; i2s_port_t I2S_AMP = I2S_NUM_0; int32_t micRawBuffer[MIC_RAW_SAMPLES]; int16_t micPcmBuffer[MIC_RAW_SAMPLES]; // ============================================================ // WEBSOCKET / SESSION STATUS // ============================================================ WebSocketsClient webSocket; volatile bool realtimeConnected = false; volatile bool sessionReady = false; volatile bool phoneActive = false; // Realtime-Antwortsteuerung. V1.2 nutzt VAD weiterhin zur // Spracherkennung, erzeugt Responses aber gezielt selbst. // So vermeiden wir Doppel-Response-Fehler bei Function Calling. volatile bool responseInProgress = false; volatile bool responseCancelPending = false; volatile bool speechEndedWaiting = false; bool lastHookState = HIGH; // ============================================================ // WÄHLSCHEIBE // ============================================================ bool dialCounting = false; int dialPulseCount = 0; int lastDialState = HIGH; unsigned long lastDialPulseMs = 0; unsigned long dialDebounceMs = 0; constexpr unsigned long DIAL_END_MS = 650; constexpr unsigned long DIAL_DEBOUNCE_MS = 12; // Wählscheiben-Modus: // 0 = frei / noch nicht gewählt // 1 = Hilfe // 2 = Freier Chat // 3 = Wetter // 4 = Datum/Uhrzeit // 5 = Wikipedia volatile int dialMode = 2; volatile bool pendingDialAnnouncement = false; // ============================================================ // VORWÄRTSDEKLARATIONEN // ============================================================ void initI2S(); void initClock(); void startPhoneCall(); void stopPhoneCall(); void sendSessionUpdate(); void sendMicrophoneAudio(); void handleDial(); void webSocketEvent(WStype_t type, uint8_t* payload, size_t length); bool hasEventType(const String& json, const char* eventType); void setDialMode(int digit); String dialModeInstructions(); String dialModeGreeting(); void audioPlaybackTask(void* parameter); void clearOutputQueue(); void stopPlayback(); void executeFunction(const String& functionName, const String& arguments, const String& callId); void sendFunctionResult(const String& callId, const String& result); void requestResponse(const char* reason); String jsonEscape(const String& input); String urlEncode(const String& input); String extractJsonString(const String& json, const String& key); String extractJsonStringFrom(const String& json, const String& key, int startPos); double extractJsonNumber(const String& json, const String& key, bool* ok = nullptr); double extractJsonNumberInObject(const String& json, const String& objectKey, const String& valueKey, bool* ok = nullptr); double extractJsonArrayNumberAfter(const String& json, const String& sectionKey, const String& arrayKey, int index, bool* ok = nullptr); String getDateTime(); String getWeather(const String& location); String wikipediaSearch(const String& query); String stripHtml(String text); String weatherDescription(int code); String base64Encode(const uint8_t* data, size_t len); size_t base64Decode(const String& input, uint8_t* output, size_t outputCapacity); int base64Value(char c); // ============================================================ // JSON EVENT TYPE ERKENNUNG // ============================================================ bool hasEventType(const String& json, const char* eventType) { String compact = String("\"type\":\"") + eventType + "\""; String spaced = String("\"type\": ") + String("\"") + eventType + "\""; return json.indexOf(compact) >= 0 || json.indexOf(spaced) >= 0; } // ============================================================ // HILFSFUNKTIONEN JSON // ============================================================ String jsonEscape(const String& input) { String out; out.reserve(input.length() + 16); for (size_t i = 0; i < input.length(); ++i) { unsigned char c = (unsigned char)input[i]; switch (c) { case '"': out += "\\\""; break; case '\\': out += "\\\\"; break; case '\b': out += "\\b"; break; case '\f': out += "\\f"; break; case '\n': out += "\\n"; break; case '\r': out += "\\r"; break; case '\t': out += "\\t"; break; default: if (c < 0x20) { out += ' '; } else { out += (char)c; } break; } } return out; } String extractJsonStringFrom(const String& json, const String& key, int startPos) { String pattern = "\"" + key + "\""; int keyPos = json.indexOf(pattern, startPos); if (keyPos < 0) return ""; int colon = json.indexOf(':', keyPos + pattern.length()); if (colon < 0) return ""; int valueStart = colon + 1; while (valueStart < (int)json.length() && isspace((unsigned char)json[valueStart])) valueStart++; if (valueStart >= (int)json.length() || json[valueStart] != '"') return ""; valueStart++; String result; result.reserve(128); bool escaped = false; for (int i = valueStart; i < (int)json.length(); ++i) { char c = json[i]; if (escaped) { switch (c) { case '"': result += '"'; break; case '\\': result += '\\'; break; case '/': result += '/'; break; case 'b': result += '\b'; break; case 'f': result += '\f'; break; case 'n': result += '\n'; break; case 'r': result += '\r'; break; case 't': result += '\t'; break; case 'u': // Für unsere Tool-Argumente genügt es, Unicode-Escapes // nicht zu zerlegen. Die Realtime-API liefert deutsche // Umlaute normalerweise direkt als UTF-8. break; default: result += c; break; } escaped = false; continue; } if (c == '\\') { escaped = true; continue; } if (c == '"') break; result += c; } return result; } String extractJsonString(const String& json, const String& key) { return extractJsonStringFrom(json, key, 0); } double extractJsonNumberInObject(const String& json, const String& objectKey, const String& valueKey, bool* ok) { if (ok) *ok = false; String objectPattern = String("\"") + objectKey + "\""; int objectKeyPos = json.indexOf(objectPattern); if (objectKeyPos < 0) return 0.0; int colon = json.indexOf(':', objectKeyPos + objectPattern.length()); if (colon < 0) return 0.0; int objectStart = json.indexOf('{', colon + 1); if (objectStart < 0) return 0.0; int depth = 0; bool inString = false; bool escaped = false; int objectEnd = -1; for (int i = objectStart; i < (int)json.length(); ++i) { char c = json[i]; if (inString) { if (escaped) escaped = false; else if (c == '\\') escaped = true; else if (c == '"') inString = false; continue; } if (c == '"') { inString = true; continue; } if (c == '{') depth++; else if (c == '}') { depth--; if (depth == 0) { objectEnd = i; break; } } } if (objectEnd < 0) return 0.0; String objectText = json.substring(objectStart, objectEnd + 1); return extractJsonNumber(objectText, valueKey, ok); } double extractJsonNumber(const String& json, const String& key, bool* ok) { if (ok) *ok = false; String pattern = "\"" + key + "\""; int keyPos = json.indexOf(pattern); if (keyPos < 0) return 0.0; int colon = json.indexOf(':', keyPos + pattern.length()); if (colon < 0) return 0.0; int valueStart = colon + 1; while (valueStart < (int)json.length() && isspace((unsigned char)json[valueStart])) valueStart++; String number; while (valueStart < (int)json.length()) { char c = json[valueStart]; if ((c >= '0' && c <= '9') || c == '-' || c == '+' || c == '.' || c == 'e' || c == 'E') { number += c; valueStart++; } else { break; } } if (number.length() == 0) return 0.0; char* endPtr = nullptr; double value = strtod(number.c_str(), &endPtr); if (endPtr == number.c_str()) return 0.0; if (ok) *ok = true; return value; } double extractJsonArrayNumberAfter(const String& json, const String& sectionKey, const String& arrayKey, int index, bool* ok) { if (ok) *ok = false; int sectionPos = json.indexOf("\"" + sectionKey + "\""); if (sectionPos < 0) return 0.0; int sectionEnd = json.indexOf('}', sectionPos); if (sectionEnd < 0) sectionEnd = json.length(); String section = json.substring(sectionPos, sectionEnd + 1); String arrayPattern = "\"" + arrayKey + "\""; int arrayPos = section.indexOf(arrayPattern); if (arrayPos < 0) return 0.0; int openBracket = section.indexOf('[', arrayPos + arrayPattern.length()); if (openBracket < 0) return 0.0; int p = openBracket + 1; int currentIndex = 0; while (p < (int)section.length()) { while (p < (int)section.length() && (isspace((unsigned char)section[p]) || section[p] == ',')) p++; if (section[p] == ']') break; int valueStart = p; while (p < (int)section.length()) { char c = section[p]; if ((c >= '0' && c <= '9') || c == '-' || c == '+' || c == '.' || c == 'e' || c == 'E') { p++; } else { break; } } if (valueStart == p) break; if (currentIndex == index) { String number = section.substring(valueStart, p); char* endPtr = nullptr; double value = strtod(number.c_str(), &endPtr); if (endPtr != number.c_str()) { if (ok) *ok = true; return value; } return 0.0; } currentIndex++; while (p < (int)section.length() && section[p] != ',') { if (section[p] == ']') return 0.0; p++; } } return 0.0; } // ============================================================ // URL ENCODING // ============================================================ String urlEncode(const String& input) { const char* hex = "0123456789ABCDEF"; String encoded; encoded.reserve(input.length() * 2); for (size_t i = 0; i < input.length(); ++i) { uint8_t c = (uint8_t)input[i]; if ( (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == '~' ) { encoded += (char)c; } else { encoded += '%'; encoded += hex[(c >> 4) & 0x0F]; encoded += hex[c & 0x0F]; } } return encoded; } // ============================================================ // BASE64 // ============================================================ const char BASE64_TABLE[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; String base64Encode(const uint8_t* data, size_t len) { String out; out.reserve(((len + 2) / 3) * 4); size_t i = 0; while (i < len) { uint32_t a = data[i++]; uint32_t b = (i < len) ? data[i++] : 0; uint32_t c = (i < len) ? data[i++] : 0; uint32_t triple = (a << 16) | (b << 8) | c; out += BASE64_TABLE[(triple >> 18) & 0x3F]; out += BASE64_TABLE[(triple >> 12) & 0x3F]; out += (i - 1 < len) ? BASE64_TABLE[(triple >> 6) & 0x3F] : '='; out += (i < len + 1) ? BASE64_TABLE[triple & 0x3F] : '='; } // Korrektur für Padding bei Länge % 3. size_t mod = len % 3; if (mod == 1) { out.setCharAt(out.length() - 2, '='); out.setCharAt(out.length() - 1, '='); } else if (mod == 2) { out.setCharAt(out.length() - 1, '='); } return out; } int base64Value(char c) { if (c >= 'A' && c <= 'Z') return c - 'A'; if (c >= 'a' && c <= 'z') return c - 'a' + 26; if (c >= '0' && c <= '9') return c - '0' + 52; if (c == '+') return 62; if (c == '/') return 63; return -1; } size_t base64Decode(const String& input, uint8_t* output, size_t outputCapacity) { size_t outLen = 0; int val = 0; int valBits = -8; for (size_t i = 0; i < input.length(); ++i) { char c = input[i]; if (c == '=') break; int v = base64Value(c); if (v < 0) continue; val = (val << 6) | v; valBits += 6; if (valBits >= 0) { if (outLen >= outputCapacity) return 0; output[outLen++] = (uint8_t)((val >> valBits) & 0xFF); valBits -= 8; } } return outLen; } // ============================================================ // WETTER // ============================================================ String weatherDescription(int code) { switch (code) { case 0: return "klar"; case 1: return "überwiegend klar"; case 2: return "teilweise bewölkt"; case 3: return "bedeckt"; case 45: case 48: return "Nebel"; case 51: case 53: case 55: return "Nieselregen"; case 56: case 57: return "gefrierender Nieselregen"; case 61: case 63: case 65: return "Regen"; case 66: case 67: return "gefrierender Regen"; case 71: case 73: case 75: return "Schneefall"; case 77: return "Schneekörner"; case 80: case 81: case 82: return "Regenschauer"; case 85: case 86: return "Schneeschauer"; case 95: return "Gewitter"; case 96: case 99: return "Gewitter mit Hagel"; default: return "unbekanntes Wetter"; } } String getWeather(const String& location) { Serial.print(">>> WETTERABFRAGE: "); Serial.println(location); if (location.length() == 0) { return "{\"error\":\"Es wurde kein Ort angegeben.\"}"; } WiFiClientSecure client; client.setInsecure(); HTTPClient http; http.setTimeout(8000); String geoUrl = "https://geocoding-api.open-meteo.com/v1/search?name=" + urlEncode(location) + "&count=1&language=de&format=json"; if (!http.begin(client, geoUrl)) { return "{\"error\":\"Die Wetter-Geocodierung konnte nicht gestartet werden.\"}"; } http.addHeader("User-Agent", "FeTAp-611-KI-Telefon/1.2"); int code = http.GET(); if (code != HTTP_CODE_OK) { http.end(); return "{\"error\":\"Der Ort konnte bei Open-Meteo nicht gefunden werden.\"}"; } String geo = http.getString(); http.end(); bool okLat = false; bool okLon = false; double lat = extractJsonNumber(geo, "latitude", &okLat); double lon = extractJsonNumber(geo, "longitude", &okLon); String placeName = extractJsonString(geo, "name"); String country = extractJsonString(geo, "country"); if (!okLat || !okLon) { return "{\"error\":\"Zu diesem Ort wurden keine Koordinaten gefunden.\"}"; } String forecastUrl = "https://api.open-meteo.com/v1/forecast?latitude=" + String(lat, 6) + "&longitude=" + String(lon, 6) + "¤t=temperature_2m,apparent_temperature,weather_code,wind_speed_10m" + "&daily=weather_code,temperature_2m_max,temperature_2m_min" + "&forecast_days=2&timezone=Europe%2FBerlin"; if (!http.begin(client, forecastUrl)) { return "{\"error\":\"Die Wetterabfrage konnte nicht gestartet werden.\"}"; } http.addHeader("User-Agent", "FeTAp-611-KI-Telefon/1.2"); code = http.GET(); if (code != HTTP_CODE_OK) { http.end(); return "{\"error\":\"Open-Meteo lieferte keine Wetterdaten.\"}"; } String weather = http.getString(); http.end(); bool okTemp = false; bool okFeels = false; bool okCode = false; bool okWind = false; bool okTomorrowMax = false; bool okTomorrowMin = false; bool okTomorrowCode = false; double temperature = extractJsonNumberInObject(weather, "current", "temperature_2m", &okTemp); double feels = extractJsonNumberInObject(weather, "current", "apparent_temperature", &okFeels); int currentCode = (int)extractJsonNumberInObject(weather, "current", "weather_code", &okCode); double wind = extractJsonNumberInObject(weather, "current", "wind_speed_10m", &okWind); double tomorrowMax = extractJsonArrayNumberAfter( weather, "daily", "temperature_2m_max", 1, &okTomorrowMax ); double tomorrowMin = extractJsonArrayNumberAfter( weather, "daily", "temperature_2m_min", 1, &okTomorrowMin ); int tomorrowCode = (int)extractJsonArrayNumberAfter( weather, "daily", "weather_code", 1, &okTomorrowCode ); Serial.print(">>> Wetter Parser: Temperatur="); Serial.print(okTemp ? "OK" : "FEHLER"); Serial.print(" Wettercode="); Serial.print(okCode ? "OK" : "FEHLER"); Serial.print(" Wind="); Serial.print(okWind ? "OK" : "FEHLER"); Serial.print(" MorgenMax="); Serial.print(okTomorrowMax ? "OK" : "FEHLER"); Serial.print(" MorgenMin="); Serial.print(okTomorrowMin ? "OK" : "FEHLER"); Serial.print(" MorgenCode="); Serial.println(okTomorrowCode ? "OK" : "FEHLER"); if (!okTemp || !okCode) { Serial.println(">>> Wetter-JSON konnte im current-Block nicht gelesen werden."); return "{\"error\":\"Die Wetterdaten konnten nicht gelesen werden.\"}"; } String result = "{"; result += "\"location\":\""; result += jsonEscape(placeName.length() ? placeName : location); result += "\","; result += "\"country\":\""; result += jsonEscape(country); result += "\","; result += "\"temperature_c\":"; result += String(temperature, 1); result += ","; if (okFeels) { result += "\"feels_like_c\":"; result += String(feels, 1); result += ","; } result += "\"condition\":\""; result += jsonEscape(weatherDescription(currentCode)); result += "\","; if (okWind) { result += "\"wind_kmh\":"; result += String(wind, 1); result += ","; } result += "\"tomorrow_condition\":\""; result += jsonEscape(okTomorrowCode ? weatherDescription(tomorrowCode) : "nicht verfügbar"); result += "\","; if (okTomorrowMax) { result += "\"tomorrow_max_c\":"; result += String(tomorrowMax, 1); result += ","; } if (okTomorrowMin) { result += "\"tomorrow_min_c\":"; result += String(tomorrowMin, 1); result += ","; } result += "\"source\":\"Open-Meteo\""; result += "}"; Serial.println(">>> WETTER ERGEBNIS:"); Serial.println(result); return result; } // ============================================================ // DATUM / UHRZEIT // ============================================================ void initClock() { Serial.println(">>> NTP-Zeit wird synchronisiert..."); configTzTime( "CET-1CEST,M3.5.0,M10.5.0", "pool.ntp.org", "time.nist.gov" ); struct tm timeinfo; unsigned long start = millis(); while (!getLocalTime(&timeinfo) && millis() - start < 10000) { delay(250); } if (getLocalTime(&timeinfo)) { char buffer[64]; strftime( buffer, sizeof(buffer), "%d.%m.%Y %H:%M:%S", &timeinfo ); Serial.print(">>> Uhrzeit synchronisiert: "); Serial.println(buffer); } else { Serial.println(">>> NTP-Synchronisation fehlgeschlagen"); } } String getDateTime() { struct tm timeinfo; if (!getLocalTime(&timeinfo)) { return "{\"error\":\"Die aktuelle Uhrzeit konnte nicht ermittelt werden.\"}"; } const char* weekdays[] = { "Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag" }; const char* months[] = { "Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember" }; char iso[32]; char dateText[80]; char timeText[32]; strftime( iso, sizeof(iso), "%Y-%m-%dT%H:%M:%S", &timeinfo ); snprintf( dateText, sizeof(dateText), "%s, %d. %s %d", weekdays[timeinfo.tm_wday], timeinfo.tm_mday, months[timeinfo.tm_mon], timeinfo.tm_year + 1900 ); snprintf( timeText, sizeof(timeText), "%02d:%02d:%02d Uhr", timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec ); String result = "{"; result += "\"datetime\":\""; result += iso; result += "\","; result += "\"date\":\""; result += jsonEscape(dateText); result += "\","; result += "\"time\":\""; result += jsonEscape(timeText); result += "\","; result += "\"weekday\":\""; result += jsonEscape(weekdays[timeinfo.tm_wday]); result += "\","; result += "\"timezone\":\"Europe/Berlin\""; result += "}"; Serial.print(">>> DATUM/UHRZEIT: "); Serial.println(result); return result; } // ============================================================ // WIKIPEDIA // ============================================================ String stripHtml(String text) { text.replace("", ""); text.replace("", ""); while (true) { int start = text.indexOf('<'); if (start < 0) break; int end = text.indexOf('>', start); if (end < 0) break; text.remove(start, end - start + 1); } text.replace(""", "\""); text.replace("'", "'"); text.replace("&", "&"); text.replace("<", "<"); text.replace(">", ">"); return text; } String wikipediaSearch(const String& query) { Serial.print(">>> WIKIPEDIA SUCHE: "); Serial.println(query); if (query.length() == 0) { return "{\"error\":\"Es wurde kein Wikipedia-Suchbegriff angegeben.\"}"; } WiFiClientSecure client; client.setInsecure(); HTTPClient http; http.setTimeout(10000); // ---------------------------------------------------------- // Direkter Wikipedia-REST-Endpunkt für die Zusammenfassung. // Beispiel: // /api/rest_v1/page/summary/Albert_Einstein // ---------------------------------------------------------- String title = query; title.trim(); title.replace(" ", "_"); String encodedTitle = urlEncode(title); String summaryUrl = "https://de.wikipedia.org/api/rest_v1/page/summary/" + encodedTitle; Serial.print(">>> Wikipedia Summary URL: "); Serial.println(summaryUrl); if (!http.begin(client, summaryUrl)) { Serial.println(">>> Wikipedia: Verbindung konnte nicht gestartet werden."); return "{\"error\":\"Wikipedia konnte nicht erreicht werden.\"}"; } // Wikimedia fordert einen aussagekräftigen User-Agent. http.addHeader( "User-Agent", "FeTAp-611-KI-Telefon/1.2 (private project)" ); http.addHeader("Accept", "application/json"); http.addHeader("Accept-Language", "de"); int httpCode = http.GET(); Serial.print(">>> Wikipedia HTTP Status: "); Serial.println(httpCode); if (httpCode == 429) { String retryAfter = http.header("Retry-After"); Serial.print(">>> Wikipedia 429 - Retry-After: "); Serial.println(retryAfter); http.end(); return "{\"error\":\"Wikipedia begrenzt momentan automatisierte Zugriffe. Bitte später erneut versuchen.\"}"; } if (httpCode == 404) { http.end(); Serial.print(">>> Wikipedia: Artikel nicht gefunden: "); Serial.println(query); return "{\"error\":\"Zu diesem Suchbegriff wurde kein passender Wikipedia-Artikel gefunden.\"}"; } if (httpCode != HTTP_CODE_OK) { Serial.print(">>> Wikipedia HTTP Fehler: "); Serial.println(httpCode); http.end(); return "{\"error\":\"Die Wikipedia-Abfrage lieferte einen Fehler.\"}"; } String payload = http.getString(); http.end(); // ---------------------------------------------------------- // JSON der REST-Summary auswerten // ---------------------------------------------------------- String resultTitle = extractJsonString( payload, "title" ); String description = extractJsonString( payload, "description" ); String extract = extractJsonString( payload, "extract" ); // Falls es sich um eine reine Weiterleitung handelt, // kann der API-Titel vom Suchbegriff abweichen. if (resultTitle.length() == 0) { return "{\"error\":\"Wikipedia lieferte keinen Artikeltitel.\"}"; } if (extract.length() == 0) { return "{\"error\":\"Für diesen Wikipedia-Artikel wurde kein Kurztext gefunden.\"}"; } if (extract.length() > 1400) { extract = extract.substring(0, 1400); } Serial.print(">>> Wikipedia Treffer: "); Serial.println(resultTitle); String result = "{"; result += "\"source\":\"de.wikipedia.org\","; result += "\"title\":\""; result += jsonEscape(resultTitle); result += "\","; result += "\"description\":\""; result += jsonEscape(description); result += "\","; result += "\"excerpt\":\""; result += jsonEscape(extract); result += "\""; result += "}"; Serial.println(">>> WIKIPEDIA ERGEBNIS:"); Serial.println(result); return result; } // ============================================================ // I2S INITIALISIERUNG // ============================================================ void initI2S() { // ---------------------------------------------------------- // INMP441 // ---------------------------------------------------------- i2s_config_t micConfig = {}; micConfig.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX); micConfig.sample_rate = SAMPLE_RATE; micConfig.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT; micConfig.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT; micConfig.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB); micConfig.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1; micConfig.dma_buf_count = 8; micConfig.dma_buf_len = 256; micConfig.use_apll = false; micConfig.tx_desc_auto_clear = false; micConfig.fixed_mclk = 0; i2s_pin_config_t micPins = {}; micPins.bck_io_num = PIN_MIC_SCK; micPins.ws_io_num = PIN_MIC_WS; micPins.data_out_num = I2S_PIN_NO_CHANGE; micPins.data_in_num = PIN_MIC_SD; i2s_driver_install(I2S_MIC, &micConfig, 0, nullptr); i2s_set_pin(I2S_MIC, &micPins); i2s_set_clk( I2S_MIC, SAMPLE_RATE, I2S_BITS_PER_SAMPLE_32BIT, I2S_CHANNEL_MONO ); // ---------------------------------------------------------- // MAX98357A // ---------------------------------------------------------- i2s_config_t ampConfig = {}; ampConfig.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX); ampConfig.sample_rate = SAMPLE_RATE; ampConfig.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT; ampConfig.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT; ampConfig.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB); ampConfig.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1; ampConfig.dma_buf_count = 8; ampConfig.dma_buf_len = 256; ampConfig.use_apll = false; ampConfig.tx_desc_auto_clear = true; ampConfig.fixed_mclk = 0; i2s_pin_config_t ampPins = {}; ampPins.bck_io_num = PIN_AMP_BCLK; ampPins.ws_io_num = PIN_AMP_LRC; ampPins.data_out_num = PIN_AMP_DIN; ampPins.data_in_num = I2S_PIN_NO_CHANGE; i2s_driver_install(I2S_AMP, &Config, 0, nullptr); i2s_set_pin(I2S_AMP, &Pins); i2s_set_clk( I2S_AMP, SAMPLE_RATE, I2S_BITS_PER_SAMPLE_16BIT, I2S_CHANNEL_STEREO ); i2s_zero_dma_buffer(I2S_AMP); Serial.println(">>> I2S Mikrofon und Verstärker gestartet"); } // ============================================================ // AUDIO-QUEUE // ============================================================ void initAudioQueues() { outputFreeQueue = xQueueCreate(OUTPUT_SLOTS, sizeof(int)); outputReadyQueue = xQueueCreate(OUTPUT_SLOTS, sizeof(int)); if (!outputFreeQueue || !outputReadyQueue) { Serial.println(">>> FEHLER: Audio-Queues konnten nicht erstellt werden"); return; } for (int i = 0; i < OUTPUT_SLOTS; ++i) { outputSlots[i].data = (uint8_t*)heap_caps_malloc( OUTPUT_PCM_CAPACITY, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT ); if (!outputSlots[i].data) { // Fallback auf normales RAM, falls nötig. outputSlots[i].data = (uint8_t*)malloc(OUTPUT_PCM_CAPACITY); } outputSlots[i].length = 0; if (!outputSlots[i].data) { Serial.print(">>> FEHLER: Audio-Slot fehlt: "); Serial.println(i); continue; } xQueueSend(outputFreeQueue, &i, portMAX_DELAY); } Serial.println(">>> Audio-Puffer: 64 Slots bereit"); } void clearOutputQueue() { if (!outputReadyQueue || !outputFreeQueue) return; int slot; while (xQueueReceive(outputReadyQueue, &slot, 0) == pdTRUE) { outputSlots[slot].length = 0; xQueueSend(outputFreeQueue, &slot, 0); } } void stopPlayback() { playbackCancelRequested = true; clearOutputQueue(); // Wenn gerade nichts abgespielt wird, Flag direkt wieder löschen. if (!playbackBusy) { playbackCancelRequested = false; } } // ============================================================ // AUDIO PLAYBACK TASK // ============================================================ void audioPlaybackTask(void* parameter) { // Mono -> Stereo für MAX98357A. // 960 Samples = 20 ms @ 24 kHz. int16_t stereoBuffer[PLAYBACK_SAMPLES_PER_WRITE * 2]; while (true) { int slot = -1; if (xQueueReceive(outputReadyQueue, &slot, portMAX_DELAY) != pdTRUE) continue; if (slot < 0 || slot >= OUTPUT_SLOTS || !outputSlots[slot].data) continue; currentOutputSlot = slot; playbackBusy = true; size_t pos = 0; while ( pos + 1 < outputSlots[slot].length && realtimeConnected && !playbackCancelRequested ) { size_t remainingBytes = outputSlots[slot].length - pos; size_t samples = remainingBytes / sizeof(int16_t); if (samples > PLAYBACK_SAMPLES_PER_WRITE) samples = PLAYBACK_SAMPLES_PER_WRITE; const int16_t* mono = reinterpret_cast(outputSlots[slot].data + pos); for (size_t i = 0; i < samples; ++i) { int16_t sample = mono[i]; stereoBuffer[2 * i] = sample; stereoBuffer[2 * i + 1] = sample; } size_t bytesToWrite = samples * 2 * sizeof(int16_t); size_t bytesWritten = 0; i2s_write( I2S_AMP, stereoBuffer, bytesToWrite, &bytesWritten, portMAX_DELAY ); pos += samples * sizeof(int16_t); } outputSlots[slot].length = 0; currentOutputSlot = -1; playbackBusy = false; int returnSlot = slot; xQueueSend(outputFreeQueue, &returnSlot, portMAX_DELAY); // Das Cancel-Flag gilt nur für den aktuell laufenden Slot. if (playbackCancelRequested) playbackCancelRequested = false; } } // ============================================================ // SESSION UPDATE // ============================================================ void sendSessionUpdate() { // Raw String vermeidet die früheren Probleme mit falsch // gesetzten Escape-Zeichen im JSON. String sessionUpdate = R"JSON( { "type": "session.update", "session": { "type": "realtime", "model": "gpt-realtime-2.1", "instructions": "Du bist der Assistent eines privaten FeTAp 611 KI-Telefons. Antworte kurz, freundlich und auf Deutsch. Verwende bei aktuellen Wetterfragen immer get_weather. Verwende bei Fragen nach aktueller Uhrzeit, Datum oder Wochentag immer get_datetime. Verwende bei Wissensfragen, bei denen eine Wikipedia-Recherche sinnvoll ist, wikipedia_search. Erfinde niemals Wetter-, Datums- oder Wikipedia-Daten. Formuliere die Antwort natürlich zum Vorlesen über einen alten Telefonhörer. Lange Antworten vermeiden.", "output_modalities": ["audio"], "audio": { "input": { "format": { "type": "audio/pcm", "rate": 24000 }, "turn_detection": { "type": "server_vad", "threshold": 0.5, "prefix_padding_ms": 300, "silence_duration_ms": 700, "create_response": false, "interrupt_response": false } }, "output": { "format": { "type": "audio/pcm", "rate": 24000 }, "voice": "marin" } }, "tools": [ { "type": "function", "name": "get_weather", "description": "Liefert aktuelle Wetterdaten und die Wettervorhersage für morgen für einen vom Benutzer genannten Ort. Verwende diese Funktion immer, wenn der Benutzer nach aktuellem Wetter oder einer Wettervorhersage fragt. Erfinde keine Wetterdaten.", "parameters": { "type": "object", "properties": { "location": { "type": "string", "description": "Stadt oder Ort, für den das Wetter abgefragt werden soll, zum Beispiel Köln, Berlin oder Straelen." } }, "required": ["location"] } }, { "type": "function", "name": "get_datetime", "description": "Liefert das aktuelle lokale Datum, den Wochentag und die Uhrzeit in Deutschland. Verwende diese Funktion immer, wenn der Benutzer nach dem aktuellen Datum, dem Wochentag oder der Uhrzeit fragt.", "parameters": { "type": "object", "properties": {}, "required": [] } }, { "type": "function", "name": "wikipedia_search", "description": "Sucht in der deutschsprachigen Wikipedia nach Informationen über Personen, Orte, Begriffe, historische Ereignisse, technische Themen und andere enzyklopädische Inhalte. Verwende die Funktion, wenn eine Wikipedia-Recherche sinnvoll ist. Erfinde keine Informationen, die nicht aus dem Ergebnis hervorgehen.", "parameters": { "type": "object", "properties": { "query": { "type": "string", "description": "Suchbegriff oder Thema für die deutschsprachige Wikipedia." } }, "required": ["query"] } } ], "tool_choice": "auto" } } )JSON"; webSocket.sendTXT(sessionUpdate); Serial.println(">>> Session-Update gesendet"); } // ============================================================ // FUNCTION CALL RESULTAT // ============================================================ String dialModeInstructions() { switch (dialMode) { case 1: return "Der Benutzer hat die Hilfe gewählt. Erkläre kurz und freundlich die Bedienung des FeTAp: 1 Hilfe, 2 freier Chat, 3 Wetter, 4 Datum und Uhrzeit, 5 Wikipedia. Danach keine weiteren Funktionen erfinden."; case 2: return "Der Benutzer hat den freien Chat gewählt. Beantworte seine gesprochenen Fragen allgemein, kurz, freundlich und auf Deutsch. Verwende bei Bedarf weiterhin die vorhandenen Funktionen."; case 3: return "WICHTIG: Der Benutzer hat ausdrücklich den WETTERMODUS über die Wählscheibe gewählt. Bleibe in diesem Modus. Beantworte nur Fragen zum aktuellen Wetter oder zur Wettervorhersage. Verwende dafür IMMER die Funktion get_weather. Wenn kein Ort genannt wird, frage ausschließlich nach dem Ort. Beantworte in diesem Modus keine allgemeinen Wissensfragen. Erfinde niemals Wetterdaten."; case 4: return "WICHTIG: Der Benutzer hat ausdrücklich den MODUS DATUM UND UHRZEIT über die Wählscheibe gewählt. Verwende für Datum, Wochentag und Uhrzeit IMMER die Funktion get_datetime. Erfinde niemals Datum oder Uhrzeit."; case 5: return "WICHTIG: Der Benutzer hat ausdrücklich den WIKIPEDIA-MODUS über die Wählscheibe gewählt. Verwende für Wissensfragen in diesem Modus IMMER die Funktion wikipedia_search. Bleibe bei enzyklopädischen Themen und erfinde keine Wikipedia-Inhalte."; default: return "Antworte kurz, freundlich und auf Deutsch. Verwende die vorhandenen Funktionen, wenn sie für die Frage benötigt werden."; } } String dialModeGreeting() { switch (dialMode) { case 1: return "Du hast die Hilfe gewählt. Ich nenne dir kurz die Funktionen. Eins ist Hilfe, zwei ist freier Chat, drei ist Wetter, vier sind Datum und Uhrzeit und fünf ist Wikipedia."; case 2: return "Der freie Chat ist aktiviert. Was möchtest du wissen?"; case 3: return "Der Wettermodus ist aktiviert. Für welchen Ort möchtest du das aktuelle Wetter oder die Wettervorhersage?"; case 4: return "Datum und Uhrzeit werden jetzt abgefragt."; case 5: return "Der Wikipedia-Modus ist aktiviert. Nach welcher Person, welchem Begriff oder welchem Thema soll ich suchen?"; default: return "Was möchtest du wissen?"; } } void setDialMode(int digit) { if (digit < 0 || digit > 9) return; if (digit >= 1 && digit <= 5) { dialMode = digit; Serial.print(">>> WÄHLSCHEIBEN-MODUS: "); switch (dialMode) { case 1: Serial.println("HILFE"); break; case 2: Serial.println("FREIER CHAT"); break; case 3: Serial.println("WETTER"); break; case 4: Serial.println("DATUM / UHRZEIT"); break; case 5: Serial.println("WIKIPEDIA"); break; } } else { Serial.print(">>> WÄHLSCHEIBE: Ziffer "); Serial.print(digit); Serial.println(" ist noch nicht belegt."); return; } pendingDialAnnouncement = true; speechEndedWaiting = false; Serial.print(">>> Modus gesetzt: "); Serial.print(dialMode); Serial.println(" / Ansage + Modusregel wird vorbereitet"); stopPlayback(); if (realtimeConnected && sessionReady) { if (responseInProgress && !responseCancelPending) { Serial.println(">>> WÄHLMODUS WECHSELT - laufende Antwort wird abgebrochen"); webSocket.sendTXT("{\"type\":\"response.cancel\"}"); responseCancelPending = true; } else if (!responseInProgress) { // pendingDialAnnouncement bleibt TRUE, damit requestResponse() // die neue Modusansage tatsächlich ausspricht. requestResponse("Wählscheibe"); } } } void requestResponse(const char* reason) { if (!realtimeConnected || !sessionReady || !phoneActive) return; if (responseInProgress) { Serial.println(">>> response.create übersprungen - Antwort läuft bereits"); return; } responseInProgress = true; String instructions = dialModeInstructions(); // Bei einer neuen Wählscheibenauswahl soll die KI zunächst // den passenden Begrüßungs-/Hinweistext sprechen. if (pendingDialAnnouncement) { instructions += " Sprich jetzt die folgende kurze Ansage: \""; instructions += dialModeGreeting(); instructions += "\"."; if (dialMode == 4) { instructions += " Danach rufe SOFORT die Funktion get_datetime auf und lies dem Benutzer das aktuelle Datum und die aktuelle Uhrzeit vor. Warte nicht auf eine weitere Frage."; } else { instructions += " Danach warte auf die nächste Äußerung des Benutzers."; } } String msg = "{\"type\":\"response.create\",\"response\":{\"instructions\":\""; msg += jsonEscape(instructions); msg += "\"}}"; Serial.print(">>> RESPONSE.CREATE (" ); Serial.print(reason); Serial.print(") - Modus "); Serial.println(dialMode); webSocket.sendTXT(msg); pendingDialAnnouncement = false; } void sendFunctionResult(const String& callId, const String& result) { if (!realtimeConnected || !phoneActive) return; String msg = R"JSON( { "type": "conversation.item.create", "item": { "type": "function_call_output", "call_id": "CALL_ID", "output": "RESULT" } } )JSON"; msg.replace("CALL_ID", jsonEscape(callId)); msg.replace("RESULT", jsonEscape(result)); webSocket.sendTXT(msg); // Die Realtime-Dokumentation sieht nach dem Function-Call-Output // eine neue, explizite response.create-Anforderung vor. delay(20); requestResponse("Function-Call-Ergebnis"); } void executeFunction( const String& functionName, const String& arguments, const String& callId ) { Serial.println(); Serial.println(">>> FUNKTION WIRD AUSGEFÜHRT"); Serial.print("Name: "); Serial.println(functionName); Serial.print("Argumente: "); Serial.println(arguments); String result; if (functionName == "get_datetime") { result = getDateTime(); } else if (functionName == "wikipedia_search") { String query = extractJsonString(arguments, "query"); if (query.length() == 0) result = "{\"error\":\"Kein Wikipedia-Suchbegriff angegeben.\"}"; else result = wikipediaSearch(query); } else if (functionName == "get_weather") { String location = extractJsonString(arguments, "location"); if (location.length() == 0) result = "{\"error\":\"Kein Ort angegeben.\"}"; else result = getWeather(location); } else { result = "{\"error\":\"Unbekannte Funktion.\"}"; } Serial.println(">>> FUNKTIONSERGEBNIS:"); Serial.println(result); sendFunctionResult(callId, result); } // ============================================================ // WEBSOCKET EVENT HANDLER // ============================================================ void webSocketEvent( WStype_t type, uint8_t* payload, size_t length ) { switch (type) { case WStype_DISCONNECTED: Serial.println(">>> WEBSOCKET GETRENNT"); realtimeConnected = false; sessionReady = false; responseInProgress = false; responseCancelPending = false; speechEndedWaiting = false; stopPlayback(); break; case WStype_CONNECTED: Serial.println(">>> WEBSOCKET VERBUNDEN"); if (digitalRead(PIN_HOOK) == HIGH) { Serial.println(">>> Hörer bereits aufgelegt - Verbindung wird beendet"); webSocket.disconnect(); break; } realtimeConnected = true; sessionReady = false; sendSessionUpdate(); break; case WStype_TEXT: { String message((char*)payload, length); // -------------------------------------------------------- // AUDIO DELTA // -------------------------------------------------------- if (hasEventType(message, "response.output_audio.delta")) { int deltaPos = message.indexOf("\"delta\""); if (deltaPos < 0) break; int colon = message.indexOf(':', deltaPos); if (colon < 0) break; int quoteStart = message.indexOf('"', colon + 1); if (quoteStart < 0) break; int quoteEnd = -1; bool escaped = false; for (int i = quoteStart + 1; i < (int)message.length(); ++i) { char c = message[i]; if (escaped) { escaped = false; continue; } if (c == '\\') { escaped = true; continue; } if (c == '"') { quoteEnd = i; break; } } if (quoteEnd < 0) break; String delta = message.substring( quoteStart + 1, quoteEnd ); int slot = -1; if (xQueueReceive(outputFreeQueue, &slot, 0) != pdTRUE) { droppedAudioBlocks++; Serial.println("!!! KEIN FREIER OUTPUT-PUFFER"); break; } size_t decoded = base64Decode( delta, outputSlots[slot].data, OUTPUT_PCM_CAPACITY ); if (decoded == 0 && delta.length() > 0) { outputSlots[slot].length = 0; xQueueSend(outputFreeQueue, &slot, 0); droppedAudioBlocks++; Serial.println(">>> Base64-Dekodierung fehlgeschlagen"); break; } outputSlots[slot].length = decoded; if (xQueueSend(outputReadyQueue, &slot, 0) != pdTRUE) { outputSlots[slot].length = 0; xQueueSend(outputFreeQueue, &slot, 0); droppedAudioBlocks++; Serial.println(">>> OUTPUT-QUEUE VOLL"); break; } receivedAudioBlocks++; break; } // -------------------------------------------------------- // SPRACHE BEGINNT -> KI-AUSGABE abbrechen // -------------------------------------------------------- if (hasEventType(message, "input_audio_buffer.speech_started")) { Serial.println(">>> USER SPRICHT"); stopPlayback(); // Bei WebSocket-Audio muss eine laufende Modellantwort // clientseitig abgebrochen werden. Wir erzeugen danach // die neue Antwort erst nach dem speech_stopped-Ereignis. if (responseInProgress && !responseCancelPending) { Serial.println(">>> LAUFENDE KI-ANTWORT WIRD ABGEBROCHEN"); webSocket.sendTXT("{\"type\":\"response.cancel\"}"); responseCancelPending = true; } break; } // -------------------------------------------------------- // SPRACHE BEENDET // -------------------------------------------------------- if (hasEventType(message, "input_audio_buffer.speech_stopped")) { Serial.println(">>> USER SPRACHE BEENDET"); speechEndedWaiting = true; // VAD erkennt den Turn, erstellt die Response aber nicht mehr // automatisch. Dadurch gibt es nur genau einen response.create. if (!responseInProgress && !responseCancelPending) { speechEndedWaiting = false; requestResponse("Sprache beendet"); } break; } // -------------------------------------------------------- // AUDIO FERTIG // -------------------------------------------------------- if (hasEventType(message, "response.output_audio.done")) { Serial.println(">>> AUDIO STREAM FERTIG"); Serial.print(">>> Audio-Blöcke: "); Serial.println(receivedAudioBlocks); Serial.print(">>> Gedroppt: "); Serial.println(droppedAudioBlocks); break; } // -------------------------------------------------------- // RESPONSE FERTIG + TOOL CALL // -------------------------------------------------------- if (hasEventType(message, "response.done")) { Serial.println(">>> RESPONSE FERTIG"); responseInProgress = false; responseCancelPending = false; // ------------------------------------------------------ // FUNCTION CALL aus response.output[] erkennen // ------------------------------------------------------ int functionTypePos = message.indexOf("\"type\":\"function_call\""); if (functionTypePos < 0) functionTypePos = message.indexOf("\"type\": \"function_call\""); if (functionTypePos >= 0) { String functionName = extractJsonStringFrom( message, "name", functionTypePos ); String callId = extractJsonStringFrom( message, "call_id", functionTypePos ); String arguments = extractJsonStringFrom( message, "arguments", functionTypePos ); Serial.println(">>> FUNCTION CALL ERKANNT"); Serial.print(">>> Name: "); Serial.println(functionName); Serial.print(">>> Call-ID: "); Serial.println(callId); Serial.print(">>> Arguments: "); Serial.println(arguments); if (functionName.length() > 0 && callId.length() > 0) { executeFunction(functionName, arguments, callId); } else { Serial.println(">>> FEHLER: Function Call konnte nicht gelesen werden"); } } else { Serial.print(">>> Audio-Blöcke: "); Serial.println(receivedAudioBlocks); Serial.print(">>> Gedroppt: "); Serial.println(droppedAudioBlocks); // Hilfe ist als einmalige Menüansage gedacht. // Danach fällt das Telefon zurück in den freien Chat. if (dialMode == 1 && !pendingDialAnnouncement) { dialMode = 2; Serial.println(">>> HILFE beendet - freier Chat wieder aktiv"); } } // Falls während einer laufenden Antwort ein neuer // Wählscheiben-Modus gewählt wurde, jetzt dessen Ansage sprechen. if (pendingDialAnnouncement && !responseInProgress && !responseCancelPending) { pendingDialAnnouncement = false; requestResponse("Wählscheiben-Modus"); } else if (speechEndedWaiting && !responseInProgress && !responseCancelPending) { speechEndedWaiting = false; requestResponse("wartende Spracheingabe"); } break; } // -------------------------------------------------------- // RESPONSE ABGEBROCHEN // -------------------------------------------------------- if (hasEventType(message, "response.cancelled")) { Serial.println(">>> RESPONSE ABGEBROCHEN"); responseInProgress = false; responseCancelPending = false; if (speechEndedWaiting) { speechEndedWaiting = false; requestResponse("Sprache nach Unterbrechung beendet"); } break; } // -------------------------------------------------------- // SESSION ERFOLGREICH // -------------------------------------------------------- if (hasEventType(message, "session.updated")) { sessionReady = true; Serial.println(">>> Session-Update bestätigt"); // Wurde bereits während des Verbindungsaufbaus gewählt, // jetzt die passende Ansage nachholen. if (pendingDialAnnouncement && !responseInProgress && phoneActive) { pendingDialAnnouncement = false; requestResponse("Wählscheiben-Modus nach Verbindungsaufbau"); } break; } // -------------------------------------------------------- // SERVER FEHLER // -------------------------------------------------------- if (hasEventType(message, "error")) { Serial.println("!!! OPENAI SERVER FEHLER !!!"); Serial.println(message); // Nach einem API-Fehler darf der Status nicht dauerhaft // auf "Response läuft" stehen bleiben. if (message.indexOf("conversation_already_has_active_response") >= 0) { Serial.println(">>> HINWEIS: Doppeltes response.create wurde erkannt."); } responseInProgress = false; responseCancelPending = false; break; } // -------------------------------------------------------- // WICHTIGE LIFECYCLE-EVENTS // -------------------------------------------------------- if (hasEventType(message, "session.created")) { Serial.println(">>> Session erstellt"); break; } break; } case WStype_BIN: // Realtime Audio kommt bei unserem Aufbau als JSON/Base64. break; case WStype_PING: break; case WStype_PONG: break; default: break; } } // ============================================================ // MIKROFON -> REALTIME // ============================================================ void sendMicrophoneAudio() { if (!realtimeConnected || !sessionReady || !phoneActive) return; size_t bytesRead = 0; esp_err_t result = i2s_read( I2S_MIC, micRawBuffer, sizeof(micRawBuffer), &bytesRead, portMAX_DELAY ); if (result != ESP_OK || bytesRead == 0) return; size_t sampleCount = bytesRead / sizeof(int32_t); // Die funktionierende Skalierung des Projekts: // >> 16 statt >> 11, damit der INMP441 nicht clippt. for (size_t i = 0; i < sampleCount; ++i) { int32_t sample32 = micRawBuffer[i] >> 16; if (sample32 > 32767) sample32 = 32767; if (sample32 < -32768) sample32 = -32768; micPcmBuffer[i] = (int16_t)sample32; } size_t pcmBytes = sampleCount * sizeof(int16_t); String b64 = base64Encode( reinterpret_cast(micPcmBuffer), pcmBytes ); String message; message.reserve(b64.length() + 80); message = "{\"type\":\"input_audio_buffer.append\",\"audio\":\""; message += b64; message += "\"}"; webSocket.sendTXT(message); } // ============================================================ // WÄHLSCHEIBE // ============================================================ void handleDial() { int state = digitalRead(PIN_DIAL); unsigned long now = millis(); if (state != lastDialState) { if (now - dialDebounceMs >= DIAL_DEBOUNCE_MS) { dialDebounceMs = now; lastDialState = state; // NSI fällt auf LOW -> ein Puls. if (state == LOW) { if (!dialCounting) { dialCounting = true; dialPulseCount = 1; } else { dialPulseCount++; } lastDialPulseMs = now; } } } if ( dialCounting && now - lastDialPulseMs > DIAL_END_MS ) { int digit = dialPulseCount; if (digit == 10) digit = 0; Serial.print(">>> WÄHLSCHEIBE: "); Serial.println(digit); dialCounting = false; dialPulseCount = 0; setDialMode(digit); } } // ============================================================ // TELEFON START / STOP // ============================================================ void startPhoneCall() { if (phoneActive) return; Serial.println(); Serial.println("HÖRER ABGEHOBEN"); Serial.println("KI-TELEFON WIRD GESTARTET"); phoneActive = true; sessionReady = false; realtimeConnected = false; responseInProgress = false; responseCancelPending = false; speechEndedWaiting = false; pendingDialAnnouncement = false; dialMode = 2; // Standard: freier Chat receivedAudioBlocks = 0; droppedAudioBlocks = 0; stopPlayback(); clearOutputQueue(); Serial.println("Realtime Verbindung wird aufgebaut..."); // Neue TLS/WebSocket-Verbindung. webSocket.beginSSL( "api.openai.com", 443, "/v1/realtime?model=gpt-realtime-2.1" ); String authHeader = String("Authorization: Bearer ") + OPENAI_API_KEY; webSocket.setExtraHeaders(authHeader.c_str()); webSocket.onEvent(webSocketEvent); webSocket.setReconnectInterval(5000); webSocket.enableHeartbeat(30000, 8000, 2); } void stopPhoneCall() { if (!phoneActive) return; Serial.println(); Serial.println("HÖRER AUFGELEGT"); Serial.println("KI-TELEFON WIRD BEENDET"); phoneActive = false; sessionReady = false; realtimeConnected = false; responseInProgress = false; responseCancelPending = false; speechEndedWaiting = false; stopPlayback(); clearOutputQueue(); i2s_zero_dma_buffer(I2S_AMP); // Keine weiteren automatischen WebSocket-Aktivitäten nach dem Auflegen. webSocket.disableHeartbeat(); webSocket.disconnect(); Serial.println(">>> Realtime-Verbindung geschlossen"); Serial.println(">>> Keine weitere Audioübertragung"); } // ============================================================ // WLAN // ============================================================ bool connectWiFi() { Serial.println(">>> WLAN wird verbunden..."); WiFi.mode(WIFI_STA); WiFi.begin(WIFI_SSID, WIFI_PASSWORD); unsigned long start = millis(); while (WiFi.status() != WL_CONNECTED && millis() - start < 20000) { delay(500); Serial.print('.'); } Serial.println(); if (WiFi.status() != WL_CONNECTED) { Serial.println(">>> WLAN-Verbindung fehlgeschlagen"); return false; } Serial.println(">>> WLAN verbunden"); Serial.print(">>> IP-Adresse: "); Serial.println(WiFi.localIP()); return true; } // ============================================================ // SETUP // ============================================================ void setup() { Serial.begin(115200); delay(1000); Serial.println(); Serial.println("================================================"); Serial.println(" FeTAp 611 KI-TELEFON - BAUPROJEKT V1.3"); Serial.println("================================================"); // ---------------------------------------------------------- // GPIO // ---------------------------------------------------------- pinMode(PIN_HOOK, INPUT_PULLUP); pinMode(PIN_DIAL, INPUT_PULLUP); lastHookState = HIGH; lastDialState = digitalRead(PIN_DIAL); // ---------------------------------------------------------- // PSRAM // ---------------------------------------------------------- Serial.print(">>> PSRAM: "); Serial.print(ESP.getPsramSize()); Serial.println(" Bytes"); // ---------------------------------------------------------- // I2S // ---------------------------------------------------------- initI2S(); initAudioQueues(); xTaskCreatePinnedToCore( audioPlaybackTask, "AudioPlayback", 8192, nullptr, 2, &playbackTaskHandle, 0 ); // ---------------------------------------------------------- // WLAN + NTP // ---------------------------------------------------------- connectWiFi(); if (WiFi.status() == WL_CONNECTED) { initClock(); } Serial.println(">>> System bereit"); Serial.println(">>> Hörer abheben zum Starten"); } // ============================================================ // LOOP // ============================================================ void loop() { // ---------------------------------------------------------- // Telefonhörer // ---------------------------------------------------------- int hookState = digitalRead(PIN_HOOK); // LOW = abgehoben if (hookState == LOW && lastHookState == HIGH) { startPhoneCall(); } // HIGH = aufgelegt if (hookState == HIGH && lastHookState == LOW) { stopPhoneCall(); } lastHookState = hookState; // ---------------------------------------------------------- // Wählscheibe // ---------------------------------------------------------- if (phoneActive) { handleDial(); } // ---------------------------------------------------------- // WebSocket verarbeiten // // WICHTIG: Nur während eines aktiven Telefonats aufrufen. // Die WebSockets-Bibliothek versucht sonst nach // webSocket.disconnect() automatisch wieder zu verbinden. // ---------------------------------------------------------- if (phoneActive) { webSocket.loop(); } // ---------------------------------------------------------- // Mikrofon kontinuierlich senden. // Das ist wichtig, damit die KI auch während einer Antwort // eine neue Spracheingabe erkennen und die Antwort unterbrechen // kann. // ---------------------------------------------------------- if (phoneActive && realtimeConnected && sessionReady) { sendMicrophoneAudio(); } // Loop nicht unnötig komplett ausreizen. delay(1); }