Moin,
ich bin blutiger Anfänger und habe für mein Verhältnis viel vor.
Ich umreiße das Thema mal eben:
Ich habe einen Volkszähler (Datenlogger mit Raumtemperaturen) am laufen.
Über eine API kann man per HTTP Request Daten da rausbekommen in Form eines JSON.
Diese möchte ich über WLAN auf einem ESP8266 einlesen und auf einem TFT Display darstellen.
Und die richtige Zeit und Daum sollen auf dem Display angezeigt werden.
Ich habe noch nie Arduino programmiert 
Also, Volkszähler läuft - check
HTTP Request und JSON funktioniert, im Browser getestet - check
Arduino IDE läuft - check
Programme aus ESP hochladen läuft - check
TFT Display an ESP angeschlossen - check
Datum und Zeit werden auf dem Display angezeigt - check
Nicht schlecht für jemanden, der noch nie was mit Linux und Arduino gemacht hat, oder?
Nun der nächste Schritt:
Auf dem ESP8266 per WLAN ein HTTP Request machen und das JSON einlesen.
Krieg ich noch nicht ganz hin.
Ich habe mir die Bibliothek ArduinoJson installiert und mir das Beispiel JsonHttpClient angesehen. Leider läuft das über Ethernet. Das muss ich nun auf WLAN umstricken.
Krieg ich aber leider nicht hin.
Wer könnte da mal helfen?
// Sample Arduino Json Web Client
// Downloads and parse http://jsonplaceholder.typicode.com/users/1
//
// Copyright Benoit Blanchon 2014-2017
// MIT License
//
// Arduino JSON library
// https://bblanchon.github.io/ArduinoJson/
// If you like this project, please add a star!
#include <ArduinoJson.h>
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <WiFiUdp.h>
//#include <Ethernet.h>
#include <SPI.h>
//EthernetClient client;
const char WiFiSSID[] = "Chriss 1234"; //### your Router SSID
const char WiFiPSK[] = "1234567890123456"; //### your Router Password
const char* server = "jsonplaceholder.typicode.com"; // server's address
const char* resource = "/users/1"; // http resource
const unsigned long BAUD_RATE = 9600; // serial connection speed
const unsigned long HTTP_TIMEOUT = 10000; // max respone time from server
const size_t MAX_CONTENT_SIZE = 512; // max size of the HTTP response
bool isConnected(long timeOutSec) {
timeOutSec = timeOutSec * 1000;
int z = 0;
while (WiFi.status() != WL_CONNECTED) {
delay(200);
Serial.print(".");
if (z == timeOutSec / 200) { return false; }
z++;
}
return true;
}
// The type of data that we want to extract from the page
struct UserData {
char name[32];
char company[32];
char type[32];
char color[32];
char title[32];
};
// ARDUINO entry point #1: runs once when you press reset or power the board
void setup() {
initSerial();
// initEthernet();
WiFi.mode(WIFI_STA);
WiFi.begin(WiFiSSID, WiFiPSK);
if (isConnected(30)) {
// wasConnected = true;
Serial.println(F("WLAN läuft"));
}
}
// ARDUINO entry point #2: runs over and over again forever
void loop() {
if (connect(server)) {
if (sendRequest(server, resource) && skipResponseHeaders()) {
UserData userData;
if (readReponseContent(&userData)) {
printUserData(&userData);
}
}
}
disconnect();
wait();
}
// Initialize Serial port
void initSerial() {
Serial.begin(BAUD_RATE);
while (!Serial) {
; // wait for serial port to initialize
}
Serial.println("Serial ready");
}
/*// Initialize Ethernet library
void initEthernet() {
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
if (!Ethernet.begin(mac)) {
Serial.println("Failed to configure Ethernet");
return;
}
Serial.println("Ethernet ready");
delay(1000);
}
*/
// Open connection to the HTTP server
bool connect(const char* hostName) {
Serial.print("Connect to ");
Serial.println(hostName);
bool ok = client.connect(hostName, 80);
Serial.println(ok ? "Connected" : "Connection Failed!");
return ok;
}
// Send the HTTP GET request to the server
bool sendRequest(const char* host, const char* resource) {
Serial.print("GET ");
Serial.println(resource);
client.print("GET ");
client.print(resource);
client.println(" HTTP/1.0");
client.print("Host: ");
client.println(host);
client.println("Connection: close");
client.println();
return true;
}
// Skip HTTP headers so that we are at the beginning of the response's body
bool skipResponseHeaders() {
// HTTP headers end with an empty line
char endOfHeaders[] = "\r\n\r\n";
client.setTimeout(HTTP_TIMEOUT);
bool ok = client.find(endOfHeaders);
if (!ok) {
Serial.println("No response or invalid response!");
}
return ok;
}
// Parse the JSON from the input string and extract the interesting values
// Here is the JSON we need to parse
// {
// "id": 1,
// "name": "Leanne Graham",
// "username": "Bret",
// "email": "Sincere@april.biz",
// "address": {
// "street": "Kulas Light",
// "suite": "Apt. 556",
// "city": "Gwenborough",
// "zipcode": "92998-3874",
// "geo": {
// "lat": "-37.3159",
// "lng": "81.1496"
// }
// },
// "phone": "1-770-736-8031 x56442",
// "website": "hildegard.org",
// "company": {
// "name": "Romaguera-Crona",
// "catchPhrase": "Multi-layered client-server neural-net",
// "bs": "harness real-time e-markets"
// }
// }
bool readReponseContent(struct UserData* userData) {
// Compute optimal size of the JSON buffer according to what we need to parse.
// See https://bblanchon.github.io/ArduinoJson/assistant/
const size_t BUFFER_SIZE =
JSON_OBJECT_SIZE(8) // the root object has 8 elements
+ JSON_OBJECT_SIZE(5) // the "address" object has 5 elements
+ JSON_OBJECT_SIZE(2) // the "geo" object has 2 elements
+ JSON_OBJECT_SIZE(3) // the "company" object has 3 elements
+ MAX_CONTENT_SIZE; // additional space for strings
// Allocate a temporary memory pool
DynamicJsonBuffer jsonBuffer(BUFFER_SIZE);
JsonObject& root = jsonBuffer.parseObject(client);
if (!root.success()) {
Serial.println("JSON parsing failed!");
return false;
}
// Here were copy the strings we're interested in
strcpy(userData->name, root["name"]);
strcpy(userData->company, root["company"]["name"]);
// It's not mandatory to make a copy, you could just use the pointers
// Since, they are pointing inside the "content" buffer, so you need to make
// sure it's still in memory when you read the string
return true;
}
// Print the data extracted from the JSON
void printUserData(const struct UserData* userData) {
Serial.print("Name = ");
Serial.println(userData->name);
Serial.print("Company = ");
Serial.println(userData->company);
}
// Close the connection with the HTTP server
void disconnect() {
Serial.println("Disconnect");
client.stop();
}
// Pause for a 1 minute
void wait() {
Serial.println("Wait 60 seconds");
delay(60000);
}
Danke und lieben Gruß,
Chris
