La douzième porte

Aujourd'hui, il y a de nouveau un microcontrôleur derrière la porte, avec lequel vous pouvez non seulement lire différents capteurs et actionneurs de commande, mais aussi vous connecter à un réseau local sans fil (WLAN). Il s'agit d'un autre tableau d'affichage avec la ESP8266.

Ce tableau de répartition possède, outre le processeur avec une mémoire flash de 4 Mo, un convertisseur USB-série CP2102, ce qui permet de programmer facilement le module. La plupart des broches d'E/S sont sorties. Il existe également un régulateur de tension, qui fournit la tension d'alimentation de 3,3 V pour le ESP8266 à partir de la tension d'alimentation USB ou de la tension au niveau du connecteur Vin. Voici une note importante. Comme le ESP8266 fonctionne avec 3,3 V, aucune tension supérieure à 3,3 V ne peut être appliquée à ses entrées ! Un autre avantage de cette planche est qu'elle est plus petite d'une dimension de grille et qu'elle tient donc sur une simple breadboard.

Un flux RSS est un aperçu des actualités au format XML proposé par différents serveurs d'information sur Internet. Dans l'exemple de programme, le serveur de l'ARD est utilisé. Comme les nouvelles sont reçues au format XML, il est facile de n'afficher que certaines parties de l'ensemble des informations. Avec 16 caractères par ligne, l'espace est très réduit, nous ne montrons donc que le titre de chaque message. Voici, par exemple, le début d'un tel flux :

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet href="/fr/resources/xsl/rdf_xsl.jsp" type="text/xsl"?>
<rss version="2.0">
<!--
* XML-format for teasering tagesschau.de-headlines. Version: 2.0
* Release-Date:2002/02/04, last updated 2006/06/28
*
* Die Nutzung dieser Inhalte ist ausschliesslich nic⸮ht-kommerziellen Internet-
* Angeboten erlaubt, die Nutzung kann jederzeit von tagesschau.de untersagt
* werden. tagesschau.de übernimmt keinen Support, zudem wird keine Verfügbarkeit
* dieser XML-Datei gewährleistet. Die Inhalte dürfen nicht archiviert werden.
//-->
<channel>
<title>tagesschau.de - Die Nachrichten der ARD</title>
<link>https://www.tagesschau.de</link>
<description>tagesschau.de</description>
<language>de</language>
<copyright>tagesschau.de, Norddeutscher Rundfunk</copyright>
<docs>http://blogs.law.harvard.edu/tech/rss</docs>
<ttl>30</ttl>
<item>
<title>Corona-Katastrophenfall: Bayern will Maßnahmen verschärfen</title>
<link>https://www.tagesschau.de/inland/corona-bayern-119.html</link>
<description>Die Neuinfektionen mit dem Corona-Virus bleiben............</description>
<guid>https://www.tagesschau.de/inland/corona-bayern-119.html</guid>
<category>Inland</category>
</item>
<item>
<title>……………………………..


Comme le montre la photo de couverture, nous voulons utiliser l'un des contrôleurs avec un écran LCD, comme présenté dans le calendrier de l'avent le 4. 12., pour construire un lecteur de flux RSS qui affiche également la date et l'heure. Avec le lecteur, il est possible d'afficher les actualités d'un flux d'informations sous forme de symbole. La date et l'heure sont récupérées à partir d'un serveur de temps NTP.

La variable principale (prononcée "tegg" =label, tag, label) <rss> dans cette variable est la variable <channel>, qui contient les messages individuels avec la variable <item>. Nous sommes intéressés par la marque de titre des articles, le chemin XML doit donc être /rss/channel/item/title.

Tout d'abord, il faut un peu de soudure. En premier lieu, la carte du microcontrôleur doit être munie d'en-têtes de broches. Ensuite, l'adaptateur I2C doit être soudé à l'écran. Je recommande de monter l'adaptateur I2C sur la partie inférieure, car il ne gênera pas le montage dans un boîtier.

Le câblage est assez simple : GND et Vcc de l'écran que nous connectons à GND et Vin du contrôleur. La ligne d'horloge SCL se trouve à D1 et la ligne de données SDA à D2.

Il est maintenant temps de commencer à programmer avec l'IDE Arduino. Si le support des cartes avec ESP8266 MCU n'est pas encore installé, nous devons le faire maintenant. Dans l’IDE Arduino, nous allons via le menu Fichier dans les Préférences ou simplement avec "Ctrl+ ;".

Dans le formulaire, nous cliquons sur le symbole à droite du champ de saisie sous "URLs supplémentaires de l'administrateur du forum". Ici, nous pouvons maintenant entrer l'URL de l'administrateur du forum ESP8266 :

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Après avoir sauvegardé les paramètres par défaut, nous appelons le gestionnaire du forum via le menu Outils->Conseil:->Gestionnaire du forum. En termes de recherche, nous tapons "esp8266". Nous obtenons l'entrée suivante, que nous installons.

Nous pouvons maintenant sélectionner un tableau dans le menu Outils->Bureau:->ESP8266 Tableaux. Nous utilisons NodeMCU 1.0....

Tout est maintenant prêt afin d'installer le plan pour le Newsreader.

#include <ESP8266WiFi.h> //WLAN Unterstützung
#include <TZ.h> //Zeitzonen Konstanten

#include <LiquidCrystal_I2C.h> //Bibliothek für das LCD Display
#include <TinyXML.h> //XML-Interpreter zum Lesen des RSS-Feed

//SSID und PSK vom lokalen WLAN
#define STASSID "*********************"
#define STAPSK "*********************"

//Zeitzone mit Sommer/Winterzeit Information
#define MYTZ TZ_Europe_Berlin

// Timeout zum Lesen des RSS-Feed in Sekunden
#define READ_TIMEOUT 10

//Verarbeitungsschritte
#define ST_CLEAR 0 //neue Daten vom Server holen
#define ST_START 1 //Meldung anzeigen
#define ST_MOVE 2 //Meldung durchschieben
#define ST_END 3 //Meldungsende anzeigen

#define MAXNEWS 10 //Maximale Anzahl der Meldungen
#define RSS_SERVER "www.tagesschau.de" //Nachrichtenserver
#define RSS_FEED "newsticker.rdf" //Name des Feeds


// LCD Adresse = 0x27, Anzahl Zeichen 16 Anzahl Zeilen 2
LiquidCrystal_I2C lcd(0x27,16,2);

//WLAN Client Instanz
WiFiClient client;

//XML Interpreter Instanz
TinyXML xml;

//Deutsche Sonderzeichen
uint8_t font [8][9] {
    {0x0c,0x12,0x12,0x0c,0x00,0x00,0x00,0x00}, // 0 °
    {0x11,0x04,0x0a,0x11,0x1f,0x11,0x11,0x00}, // 1 Ä
    {0x11,0x0e,0x11,0x11,0x11,0x11,0x0e,0x00}, // 2 Ö
    {0x11,0x00,0x11,0x11,0x11,0x11,0x0e,0x00}, // 3 Ü
    {0x0a,0x00,0x1e,0x01,0x0f,0x13,0x0d,0x00}, // 4 ä
    {0x0a,0x00,0x0e,0x11,0x11,0x11,0x0e,0x00}, // 5 ö
    {0x0a,0x00,0x12,0x12,0x12,0x12,0x0f,0x00}, // 6 ü
    {0x0c,0x12,0x12,0x14,0x12,0x12,0x14,0x00} // 7 ß
};


uint8_t buffer[4000]; //Buffer für XML-Interpreter
uint16_t msglen = 0; //Länge der aktuellen Nachricht
String msg; //aktuelle Nachricht
String news[MAXNEWS]; //Speicher für Nachrichten
uint8_t newsCnt = 0; //Anzahl der aktuellen Nachrichten im Speicher
uint8_t curNews = 0; //Index der gerade angezeigten Nachricht
uint8_t step = 0; //Aktueller Verarbeitungsschritt
uint16_t pos = 0; //Startposition zum Durchschieben

//Deutsche Umlaute (UTF8) fürs Display codieren
String extraChar(String text){
  String res = "";
  uint8_t i = 0;
  char c;
  while (i<text.length()) {
    c=text[i];
    if (c==195) { //UTF8 Deutsche Umlaute
      i++;
      switch (text[i]) {
        case 164: c=4; break; //ä
        case 182: c=5; break; //ö
        case 188: c=6; break; //ü
        case 159: c=7; break; //ß
        case 132: c=1; break; //Ä
        case 150: c=2; break; //Ö
        case 156: c=3; break; //Ü
        default: c=0;
      }
    } else if (c == 194) { //UTF8 Sonderzeichen
      i++;
      if (text[i] == 176) c=0xdf; else c=0;
    } else if (c > 128) { //normal characters unchanged
      c=255;
    }
    if (c>0) res.concat(c);
    i++;
    }
  return res;
}


//Diese Funktion wird vom XML-Interpreter aufgerufen, wenn ein XML-Tag gelesen wurde
//tagName enthält den vollständigen XML-Pfad des Tags, data den Inhalt des Tags
void XML_callback(uint8_t statusflags, char* tagName, uint16_t tagNameLen, char* data, uint16_t dataLen) {
  if (statusflags & STATUS_TAG_TEXT) {
    //Serial.println(tagName);
    //wenn wir einen Titel-Tag finden, und die maximale Anzahl der Meldungen noch
    //nicht erreicht ist, wird die Meldung gespeichert und der Zähler erhöht
    if (strcasecmp(tagName,"/rss/channel/item/title")==0) {
data[dataLen] = '\0';
      Serial.printf("%i %s\n",newsCnt,data);
      if (newsCnt < MAXNEWS) {
        news[newsCnt] = data;
        newsCnt++;
      }
    }
  }
}

//Neue Nachrichten vom RSS-Feed lesen
boolean getNews() {
  boolean res = false;
  boolean timedOut = false;
  char c;
  newsCnt = 0;
  //nur wenn wir eine Internetverbindung haben
  if(WiFi.status()== WL_CONNECTED){
    //zuerst mit dem HTTP-Server verbinden
    Serial.println("Mit Server verbinden");
    if(client.connect(RSS_SERVER, 80)) {
    Serial.println("OK\r\nRequesting data...");
    //Nun können wir die XML-Seite mit dem Feed holen
    client.print("GET /");
    client.print(RSS_FEED);
    client.print(" HTTP/1.1\r\nHost: ");
    client.print(RSS_SERVER);
    client.print("\r\nConnection: Close\r\n\r\n");
    client.flush();
    //den XML-Interpreter vorbereiten
    xml.reset();
    newsCnt = 0;
    uint32_t t = millis(); // Startzeit
    while(client.connected()) {
      if((c = client.read()) >= 0) {
        //Solange wir Zeichen vom Webserver erhalten, werden diese
        //zur Interpretation an den XML Interpreter weitergegeben
        xml.processChar(c);
        delay(1); //Verzögerung 1ms sonst kommt der XML Interpreter nicht nach
        t = millis(); // Reset timeout clock
      } else if((millis() - t) >= (READ_TIMEOUT * 1000)) {
        //Im Falle eines Timeouts wird die Interpretation abgebrochen
        Serial.println("---Timeout---");
        timedOut = true;
        break;
      }
    }
    if (timedOut) Serial.println("Timeout");
    if(!timedOut && (newsCnt > 0)) {
      //Falls Nachrichten empfangen wurden, wird die erste Nachricht angezeigt
      curNews = 0;
    }
  }
  client.stop();
} else {
  //war keine Internet Verbindung vorhanden
  //wird ein neuer Verbindungsversuch gestartet
  //und eine Fehlermeldung angezeigt
  news[0] = "Keine Internetverbindung!";
  newsCnt = 1;
  curNews = 0;
  }
}

//Anzeige aktualisieren
void updateDisplay() {
  //erste Zeile Zeit und Datum
  time_t now; //aktuelle Zeit
  struct tm * s_time; //Zeitstruktur aufgesplittet in Jahr, Monat, Tag, Stunden, Minuten und Sekunden
  char line_buffer[20]; //Buffer für Anzeigenzeile
  now = time(nullptr); //aktuelle Zeit lesen
  s_time = localtime(&now); //für die lokale Zeit in die Zeitstruktur umwandeln
  //Zeilenbuffer mit Uhrzeit und Datum füllen
  strftime(line_buffer,17,"%d.%m.%Y %H:%M",s_time);
  //Uhrzeit auf die serielle Schnittstelle ausgeben
  //Serial.println(line_buffer);
  //Uhrzeit am Display in Zeile 1 anzeigen
  lcd.setCursor(0,0);
  lcd.print(line_buffer);
  //zweite Zeile Nachrichten
  lcd.setCursor(0,1);
  switch (step) {
    case ST_CLEAR: step = ST_START; //Nächster Schritt
      if (curNews >= newsCnt) {
        lcd.print("Aktualisierung..");
        getNews(); //neue Nachrichten holen
        curNews = 0;
      } else {
        curNews++; //nächste Nachricht starten
        lcd.print(" ");
        if (curNews >= newsCnt) step = ST_END;
      }
      msg = extraChar(news[curNews]);
      msglen = msg.length();
      break;
  case ST_START:lcd.print(msg.substring(0,16));
    pos = 0; //Startposition einnehmen
    step = ST_MOVE;
    break;
  case ST_MOVE: pos++;
    lcd.print(msg.substring(pos,pos+16));
    //wenn die Nachricht fertig ist, nächste Nachricht
    if (pos > (msglen-17)) step=ST_END;
    break;
  case ST_END: step = ST_CLEAR;
    break;
  }
}

//Setup Funktion
void setup() {
  Serial.begin(115200); //Serielle Schnittstelle initialisieren
  //XML-Interpreter initialisieren
  xml.init((uint8_t *)buffer, sizeof(buffer), &XML_callback);
  //Display initialisieren und Beleuchtung ein
  lcd.init();
  lcd.backlight();
  //Deutsche Umlaute erzeugen
  for (uint8_t i = 0; i<8; i++) lcd.createChar(i, font[i]);
  //Display löschen und Startmeldung anzeigen
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("AZ-Delivery");
  lcd.setCursor(0,1);
  lcd.print("Einen Moment....");
  //Interne Uhr konfigurieren
  configTime(MYTZ, "pool.ntp.org");
  //WLAN initialisieren und mit dem WLAN verbinden
  WiFi.persistent(false);
  WiFi.mode(WIFI_STA);
  WiFi.begin(STASSID, STAPSK);
  uint8_t cnt = 0;
  //warten bis Verbindung hergestellt wurde
  while ((WiFi.status() != WL_CONNECTED) && (cnt<10)) {
    Serial.println(WiFi.status());
    cnt++;
    delay(500);
  }
  newsCnt = 0;
  step = ST_CLEAR;
}

//Hauptschleife
void loop() {
  //Zeit anzeigen
  updateDisplay();
  //Verzögerung fürs Durchschieben
  delay(500);
}


Télécharger le schéma / Download CODE

Presque tout ce dont nous avons besoin est inclus dans le paquet ESP8266. Seules les bibliothèques pour l'affichage LCD et pour l'évaluation des données XML manquent. Ils peuvent être installés via la gestion de la bibliothèque dans l'IDE Arduino.

Nous saisissons "I2C LCD" comme terme de recherche et trouvons, un peu plus loin dans la liste, la bibliothèque souhaitée.

Ensuite, nous saisissons "Tiny XML" comme terme de recherche et nous obtenons la bibliothèque que nous voulons.

Avant d'établir le croquis, nous devons saisir les références du WLAN à la place des astérisques.

Vous pouvez également choisir un autre serveur de nouvelles, un autre flux sur ce serveur et/ou un autre nombre d'articles. Ensuite, vous devez modifier les entrées #define correspondantes. Le nombre de messages ne doit pas être supérieur à 10.

Ne soyez pas surpris si vous obtenez l'avertissement suivant lors de la compilation.

ATTENTION : La bibliothèque LiquidCrystal_I2C prétend fonctionner sur une (des) architecture(s) avr et peut être incompatible avec votre carte actuelle fonctionnant sur une (des) architecture(s) esp8266.

Cet avertissement est dû à une entrée incorrecte dans les spécifications de la bibliothèque. La bibliothèque fonctionne bien avec les MCU ESP8266.

Une fois que tous les messages du serveur de nouvelles ont été affichés, les messages sont à nouveau récupérés sur le serveur. L'heure est mise à jour en permanence. Le passage de l'heure d'été à l'heure normale est automatique.

Amusez-vous bien avec la construction.