ESP32 - Hue-Stream

[TheHoschi (Gast)]

Hallo zusammen,
ich stehe vor einem Problem, bei dem ihr mir hoffentlich helfen könnt.
Ich möchte mit meinem ESP32 auf meine HUE-Bridge zugreifen und die 
Server-Antwort (Stream) in ein StaticJsonDocument schreiben.
Die Serververbindung funktioniert einwandfrei und der Stream wird 
gelesen (Ausgabe via USE_SERIAL.write(buff, c);).
Jedoch ist mein StaticJsonDocument leer. Ich vermute, dass ich im Script 
irgendwo einen Denkfehler hab. Habt ihr eine Idee?
Bin für jeden Hinweis dankbar :)

Hier der Quellcode:


#include <Arduino.h>

#include <WiFi.h>
#include <WiFiMulti.h>
#include <ArduinoJson.h>
#include <StreamUtils.h>
#include <HTTPClient.h>

#define USE_SERIAL Serial

WiFiMulti wifiMulti;

void setup() {

    USE_SERIAL.begin(115200);

    USE_SERIAL.println();
    USE_SERIAL.println();
    USE_SERIAL.println();

    for(uint8_t t = 4; t > 0; t--) {
        USE_SERIAL.printf("[SETUP] WAIT %d...\n", t);
        USE_SERIAL.flush();
        delay(1000);
    }

    wifiMulti.addAP("xxxxx", "xxxxxx");

}

void loop() {
    // wait for WiFi connection
    if((wifiMulti.run() == WL_CONNECTED)) {

        HTTPClient http;

        USE_SERIAL.print("[HTTP] begin...\n");

        // configure server and url
        http.begin("https://192.168.2.13/eventstream/clip/v2";);
        http.addHeader("hue-application-key", 
"vDywcavzJUvn62reNN01yvZ4oz8ctGkBFUkiVFgO");
        http.addHeader("Accept", "vtext/event-stream");

        USE_SERIAL.print("[HTTPS] GET...\n");
        // start connection and send HTTP header
        int httpCode = http.GET();
        if(httpCode > 0) {
            // HTTP header has been send and Server response header has 
been handled
            USE_SERIAL.printf("[HTTP] GET... code: %d\n", httpCode);

            // file found at server
            if(httpCode == HTTP_CODE_OK) {

                // get lenght of document (is -1 when Server sends no 
Content-Length header)
                int len = http.getSize();

                // create buffer for read
                uint8_t buff[128] = { 0 };

                // get tcp stream
                WiFiClient * stream = http.getStreamPtr();

                StaticJsonDocument<384> doc;

                // read all data from server
                while(http.connected() && (len > 0 || len == -1)) {
                    // get available data size
                    size_t size = stream->available();

                    if(size) {

                        int c = stream->readBytes(buff, ((size > 
sizeof(buff)) ? sizeof(buff) : size));

                        USE_SERIAL.write(buff, c);

                        deserializeJson(doc, buff);

                        const char* creationtime = doc["creationtime"]; 
// "2022-02-23T10:42:26Z"

                        JsonObject data_0 = doc["data"][0];
                        const char* data_0_id = data_0["id"]; // 
"4317f73c-7d20-4a02-b3ee-70e1c8e108e2"
                        const char* data_0_id_v1 = data_0["id_v1"]; // 
"/groups/10"

                        bool data_0_on_on = data_0["on"]["on"]; // true

                        const char* data_0_type = data_0["type"]; // 
"grouped_light"

                        const char* id = doc["id"]; // 
"0dfe6163-346a-4d6f-88d7-53ca1e3b142a"
                        const char* type = doc["type"]; // "update"



                        if(len > 0) {
                            len -= c;
                        }
                    }
                    delay(1);
                }

                USE_SERIAL.println();
                USE_SERIAL.print("[HTTP] connection closed or file 
end.\n");

            }
        } else {
            USE_SERIAL.printf("[HTTP] GET... failed, error: %s\n", 
http.errorToString(httpCode).c_str());
        }

        http.end();
    }

    delay(10000);
}