CHAPITRE

TROIS

RÉFÉRENCE

3.1 Interruptions

Les interruptions peuvent être utilisées sur l'ESP8266, mais elles doivent être utilisées avec précaution et présentent plusieurs limitations :

• Les fonctions de rappel d'interruption doivent être dans IRAM, car le flash peut être au milieu d'autres opérations lorsqu'elles se produisent. Pour ce faire,
ajoutez l'attribut IRAM_ATTR à la définition de la fonction. Si cet attribut n'est pas présent, l'esquisse plantera lorsqu'elle tentera d'attacher une
interruption avec un message d'erreur.

IRAM_ATTR void gpio_change_handler(void *data) {...

• Les interruptions ne doivent pas appeler delay() ou yield(), ni appeler des routines qui utilisent en interne delay() ou yield().
soit.

• Les tâches de longue durée (> 1 ms) dans les interruptions provoqueront une instabilité ou des plantages. Le WiFi et d'autres parties du cœur peuvent
devenir instables si les interruptions sont bloquées par une interruption de longue durée. Si vous avez beaucoup à faire, vous pouvez définir un indicateur
global volatile permettant à votre boucle principale () de vérifier chaque passage ou utiliser une fonction planifiée (qui sera appelée en dehors du contexte
d'interruption lorsqu'elle est sûre) pour effectuer un travail de longue durée. .

• Les opérations de l'API Heap peuvent être dangereuses et doivent être évitées lors des interruptions. Les appels à malloc doivent être minimisés car ils
peuvent nécessiter une longue durée d'exécution si la mémoire est fragmentée. Les appels à réallouer et à libérer ne doivent JAMAIS être appelés.
L'utilisation de routines ou d'objets qui s'appellent free ou se réaffectent est également interdite pour la même raison. Cela signifie que String, std::string,
std::vector et les autres classes qui utilisent une mémoire contiguë pouvant être redimensionnée doivent être utilisées avec une extrême prudence (en
s'assurant que les chaînes ne sont pas modifiées, que les éléments vectoriels ne sont pas ajoutés, etc.). Le problème sous-jacent, une adresse
d'allocation pourrait être activement utilisée au moment d'une interruption. Au retour, l'adresse activement utilisée peut être invalide après qu'un ISR
utilise la réallocation ou la libération pour la même allocation.

• Les opérateurs new et delete C++ ne doivent JAMAIS être utilisés dans un ISR. Leur chemin d'appel n'est pas dans IRAM. L'utilisation de routines ou
d'objets utilisant l'opérateur new ou delete est également interdite.

3.2 E/S numériques

Les numéros de broches dans Arduino correspondent directement aux numéros de broches GPIO ESP8266. Les fonctions pinMode, digitalRead et digitalWrite
fonctionnent comme d'habitude, donc pour lire GPIO2, appelez digitalRead(2).

Les broches numériques 0 à 15 peuvent être INPUT, OUTPUT ou INPUT_PULLUP. La broche 16 peut être INPUT, OUTPUT ou INPUT_PULLDOWN_16.
Au démarrage, les broches sont configurées comme INPUT.

Les broches peuvent également remplir d'autres fonctions, comme Serial, I2C, SPI. Ces fonctions sont normalement activées par la bibliothèque correspondante.
Le diagramme ci-dessous montre le mappage des broches du module ESP-12 populaire.

Les broches numériques 6 à 11 ne sont pas illustrées sur ce schéma car elles sont utilisées pour connecter la puce de mémoire flash sur la plupart des modules.
Essayer d'utiliser ces broches comme E/S entraînera probablement le blocage du programme.

13
Documentation de base Arduino ESP8266, version 3.1.2-21-ga348833

Fig. 1 : Fonctions des broches

Notez que certaines cartes et modules (ESP-12ED, NodeMCU 1.0) cassent également les broches 9 et 11. Celles-ci peuvent être utilisées comme E/
S si la puce flash fonctionne en mode DIO (par opposition à QIO, qui est celui par défaut).

Les interruptions de broche sont prises en charge via les fonctions attachInterrupt et detachInterrupt. Les interruptions peuvent être attachées à
n'importe quelle broche GPIO, à l'exception du GPIO16. Les types d'interruption Arduino standard sont pris en charge : CHANGEMENT, RISING,
FALLING. Les ISR doivent avoir IRAM_ATTR avant la définition de la fonction.

3.3 Entrée analogique

REMARQUE : L'appel trop fréquent d'analogRead() entraîne l'arrêt du fonctionnement du WiFi. Lorsque le WiFi est en cours de fonctionnement, le
résultat analogRead() peut être mis en cache pendant au moins 5 ms entre les appels effectifs.

L'ESP8266 dispose d'un seul canal ADC disponible pour les utilisateurs. Il peut être utilisé soit pour lire la tension sur la broche ADC, soit pour lire la
tension d'alimentation du module (VCC).

Pour lire la tension externe appliquée à la broche ADC, utilisez analogRead (A0). La plage de tension d'entrée de l'ESP8266 nu est de 0 à 1,0 V, mais
certaines cartes peuvent implémenter des diviseurs de tension. Par mesure de sécurité, <1,0 V peut être testé. Si, par exemple, 0,5 V fournit des
valeurs autour de ~ 512, alors la tension maximale est très probablement de 1,0 V et 3,3 V peut endommager l'ESP8266. Cependant, des valeurs
autour de ~150 indiquent que la tension maximale est probablement de 3,3 V.

Pour lire la tension VCC, utilisez ESP.getVcc() et la broche ADC doit rester déconnectée. De plus, la ligne suivante doit être ajoutée au croquis :

ADC_MODE(ADC_VCC);

Cette ligne doit apparaître en dehors de toute fonction, par exemple juste après les lignes #include de votre esquisse.

14 Chapitre 3. Référence
 Documentation de base Arduino ESP8266, version 3.1.2-21-ga348833

3.4 Sortie analogique

analogWrite(pin, value) active le logiciel PWM sur la broche donnée. PWM peut être utilisé sur les broches 0 à 16. Appelez analogWrite(pin, 0) pour
désactiver PWM sur la broche.

la valeur peut être comprise entre 0 et 255 (ce qui est la valeur par défaut d'Arduino). La plage PWM peut être modifiée en appelant
analogWriteRange(new_range) ou analogWriteResolution(bits). new_range peut être de 15. . . 65535 ou les bits peuvent provenir de 4. . . 16.

La fonction analogWriteMode(pin, value, openDrain) permet de définir le mode pin sur OUTPUT_OPEN_DRAIN au lieu de OUTPUT.

REMARQUE : La plage analogWrite par défaut était de 1 023 dans les versions antérieures à la version 3.0, mais cela entraînait une incompatibilité
avec les bibliothèques externes qui dépendaient de la valeur par défaut du cœur Arduino de 256. Les applications existantes qui s'appuient sur la
valeur 1 023 antérieure peuvent ajouter un appel à analogWriteRange(1023) pour leur routine setup() pour revenir à leur ancien comportement. Les
applications qui appelaient déjà analogWriteRange ne nécessitent aucune modification.

La fréquence PWM est de 1 kHz par défaut. Appelez analogWriteFreq(new_ Frequency) pour changer la fréquence. Les valeurs valides vont de 100
Hz à 40 000 Hz.

L'ESP n'a pas de PWM matériel, la mise en œuvre se fait donc par logiciel. Avec une sortie PWM à 40KHz, le CPU est déjà plutôt chargé. Plus les
sorties PWM sont utilisées et plus leur fréquence est élevée, plus vous vous rapprochez des limites du processeur et moins il y a de cycles de
processeur disponibles pour l'exécution d'esquisses.

3.5 Timing et delays

millis() et micros() renvoient respectivement le nombre de millisecondes et de microsecondes écoulées après la réinitialisation.

delay(ms) met l'esquisse en pause pendant un nombre donné de millisecondes et permet l'exécution des tâches WiFi et TCP/IP. delayMicroseconds(us)
fait une pause pendant un nombre donné de microsecondes.

N'oubliez pas qu'en plus du croquis, de nombreux codes doivent être exécutés sur la puce lorsque le WiFi est connecté. Les bibliothèques WiFi et
TCP/IP ont la possibilité de gérer tous les événements en attente à chaque fois que la fonction loop() se termine, OU lorsque le délai est appelé. Si
vous avez une boucle quelque part dans votre esquisse qui prend beaucoup de temps (> 50 ms) sans appeler de délai, vous pouvez envisager
d'ajouter une fonction d'appel à délai pour assurer le bon fonctionnement de la pile WiFi.

Il existe également une fonction yield() qui équivaut à delay(0). La fonction delayMicroseconds, en revanche, ne cède pas le pas à d'autres
tâches, il n'est donc pas recommandé de l'utiliser pour des retards supérieurs à 20 millisecondes.

3.6 Série

L'objet Serial fonctionne à peu près de la même manière que sur un Arduino classique. Outre le FIFO matériel (128 octets pour TX et RX), Serial
dispose d'un tampon RX personnalisable supplémentaire de 256 octets. La taille de ce fichier logiciel peut être modifiée par l'utilisateur. Il est suggéré
d'utiliser une taille plus grande à des vitesses de réception plus élevées.

La méthode ::setRxBufferSize(size_t size) modifie la taille du tampon RX selon les besoins. Cela doit être appelé avant ::begin(). L'argument size
doit être au moins suffisamment grand pour contenir toutes les données reçues avant la lecture.

Pour un fonctionnement en transmission uniquement, le tampon RX de 256 octets peut être désactivé pour économiser de la RAM en passant le
mode SE-RIAL_TX_ONLY à Serial.begin(). Les autres modes sont SERIAL_RX_ONLY et SERIAL_FULL (par défaut).

La réception est déclenchée par des interruptions, mais la transmission est soumise à des interrogations et à des attentes occupées. Le comportement
de blocage est le suivant : L'appel ::write() ne bloque pas si le nombre d'octets correspond à l'espace actuellement disponible dans le FIFO TX.
L'appel se bloque si le TX FIFO est plein et attend qu'il y ait de la place avant d'y écrire plus d'octets, jusqu'à ce que tous les octets soient écrits. En
d'autres termes, lorsque l'appel revient, tous les octets ont été écrits dans le FIFO TX, mais cela ne signifie pas que tous les octets ont été envoyés.

3.4. Sortie analogique 15

Documentation de base Arduino ESP8266, version 3.1.2-21-ga348833

via la ligne série. L'appel ::read() ne bloque pas, même s'il n'y a aucun octet disponible pour la lecture. L'appel ::readBytes() bloque jusqu'à ce que
le nombre d'octets lus soit conforme au nombre d'octets requis par l'argument transmis. L'appel ::flush() bloque en attendant que le FIFO TX soit
vide avant de revenir. Il est recommandé d'appeler ceci pour s'assurer que tous les octets ont été envoyés avant d'effectuer des modifications de
configuration sur le port série (par exemple, changer le débit en bauds) ou d'effectuer une réinitialisation de la carte.

Serial utilise UART0, qui est mappé aux broches GPIO1 (TX) et GPIO3 (RX). Serial peut être remappé en GPIO15 (TX) et GPIO13 (RX) en appelant
Serial.swap() après Serial.begin. L'appel à nouveau de swap mappe UART0 sur GPIO1 et GPIO3.

Serial1 utilise UART1, la broche TX est GPIO2. UART1 ne peut pas être utilisé pour recevoir des données car normalement sa broche RX est
occupée pour la connexion de la puce flash. Pour utiliser Serial1, appelez Serial1.begin(baudrate).

Si Serial1 n'est pas utilisé et Serial n'est pas échangé, TX pour UART0 peut être mappé sur GPIO2 à la place en appelant Serial.set_tx(2) après
Serial.begin ou directement avec Serial.begin (baud, config, mode, 2).

Par défaut, la sortie de diagnostic des bibliothèques WiFi est désactivée lorsque vous appelez Serial.begin. Pour réactiver la sortie de débogage,
appelez Serial.setDebugOutput(true). Pour rediriger la sortie de débogage vers Serial1, appelez Serial1. setDebugOutput(vrai).

Vous devez également utiliser Serial.setDebugOutput(true) pour activer la sortie de la fonction printf().

Les objets Serial et Serial1 prennent en charge 5, 6, 7, 8 bits de données, la parité impaire (O), paire (E) et sans (N), ainsi que 1 ou 2 bits d'arrêt.
Pour définir le mode souhaité, appelez Serial.begin(baudrate, SERIAL_8N1), Serial.begin(baudrate, SERIAL_6E2), etc. Le mode de configuration
par défaut est SERIAL_8N1. Les possibilités sont SERIAL_[5678][NEO][12]. Exemple : SERIAL_8N1 signifie 8 bits Pas de parité 1 bit d'arrêt.

Une nouvelle méthode a été implémentée sur Serial et Serial1 pour obtenir le paramètre de débit en bauds actuel. Pour obtenir le débit en bauds
actuel, appelez Serial.baudRate(), Serial1.baudRate(). Renvoie un entier de la vitesse actuelle. Par exemple

// Définit le débit en bauds sur 57600

Serial.begin(57600);

// Récupère le débit en bauds actuel int

br = Serial.baudRate();

// Affichera "La série est de 57 600 bps"

Serial.printf("La série est %d bps", br);

Les objets Serial et Serial1 sont tous deux des instances de la classe HardwareSerial.
Ceci est également fait pour la bibliothèque série logicielle officielle ESP8266 , voir cette demande d'extraction.

Notez que cette implémentation concerne uniquement les cartes basées sur ESP8266 et ne fonctionnera pas avec d'autres cartes Arduino.

Pour détecter un débit en bauds inconnu de données entrant en série, utilisez Serial.detectBaudrate (time_t timeoutMillis).
Cette méthode tente de détecter le débit en bauds pendant un maximum de timeoutMillis ms. Il renvoie zéro si aucun débit en bauds n'a été détecté,
ou le débit en bauds détecté dans le cas contraire. La fonction detectBaudrate() peut être appelée avant l'appel de Serial.begin(), car elle n'a pas
besoin du bouton de réception ni des paramètres SerialConfig.

L'uart ne peut pas détecter d'autres paramètres comme le nombre de bits de démarrage ou d'arrêt, le nombre de bits de données ou la parité.

La détection elle-même ne modifie pas le débit en bauds ; après la détection, il doit être réglé comme d'habitude en utilisant Serial. commencer
(débit en bauds détecté).

La détection est très rapide, elle ne prend que quelques octets entrants.

SerialDetectBaudrate.ino est un exemple complet d'utilisation.

16 Chapitre 3. Référence
 Documentation de base Arduino ESP8266, version 3.1.2-21-ga348833

3.7 Programme
Les fonctionnalités de mémoire du programme fonctionnent à peu près de la même manière que sur un Arduino classique ; placer les données et les chaînes
en lecture seule dans la mémoire morte et libérer du tas pour votre application.

Dans les versions de base antérieures à 2.7, la différence importante est que sur l'ESP8266, les chaînes littérales ne sont pas
regroupées. Cela signifie que la même chaîne littérale définie à l'intérieur d'un F("") et/ou PSTR("") occupera de l'espace pour chaque
instance du code. Vous devrez donc gérer vous-même les chaînes en double.

À partir de la version 2.7, ce n'est plus vrai : les chaînes littérales en double dans la mémoire r/o sont désormais gérées.

Il existe une macro d'assistance supplémentaire pour faciliter la transmission des chaînes const PROGMEM aux méthodes qui
prennent un __FlashStringHelper appelé FPSTR(). Son utilisation facilitera le regroupement des chaînes. Ne pas regrouper les chaînes. . .

Réponse de chaîne1 ;
réponse1 += F("http:");
...
Réponse de chaîne2 ;
réponse2 += F("http:");

utiliser FPSTR deviendrait. . .

const char HTTP[] PROGMEM = "http:";

...
{
Réponse de chaîne1 ;
réponse1 += FPSTR(HTTP);
...
Réponse de chaîne2 ;
réponse2 += FPSTR(HTTP);
}

3.8C++

• À propos des exceptions C++, de l'opérateur nouveau et de l'option de menu Exceptions

La norme C++ indique ce qui suit à propos du comportement du nouvel opérateur en cas de pénurie de tas (mémoire
pleine) :

– doit lever une exception std::bad_alloc C++ lorsqu'elle est activée

– va abandonner() sinon

Il y a plusieurs raisons au premier point ci-dessus, parmi lesquelles :

– garantir que le retour du neuf n’est jamais un nullptr

– garantir la construction complète de l’objet de niveau supérieur ainsi que de tous les sous-objets membres

– garantir que tous les sous-objets partiellement construits seront détruits, et dans le bon ordre, si oom est activé.
contré à mi-chemin de la construction

Lorsque les exceptions C++ sont désactivées ou lors de l'utilisation de new(nothrow), les garanties ci-dessus ne peuvent pas être
respectées, donc le deuxième point (abort()) ci-dessus est la seule solution viable std::c++.

Historiquement, dans les environnements Arduino, new est surchargé pour renvoyer simplement l'équivalent malloc() qui à son
tour peut renvoyer nullptr.

3.7. Programme 17
Documentation de base Arduino ESP8266, version 3.1.2-21-ga348833

Ce comportement n'est pas standard en C++, et il y a une bonne raison à cela : il a des effets secondaires cachés et très néfastes.
Les constructeurs de classe et de membres sont toujours appelés, même lorsque la mémoire est pleine (this == nullptr). De plus,
l'allocation de mémoire pour l'objet supérieur pourrait réussir, mais l'allocation requise pour certains objets membres pourrait
échouer, laissant la construction dans un état indéfini. Ainsi, le comportement historique du nouveau Ardudino, face à une mémoire
insuffisante, entraînera tôt ou tard des plantages graves, parfois inexplicables, généralement dus à une corruption de la mémoire,
même lorsque la valeur renvoyée est vérifiée et gérée. Heureusement sur esp8266, essayer de mettre à jour la RAM près de
l'adresse 0 déclenchera immédiatement une exception matérielle, contrairement à d'autres uC comme avr sur lesquels cette
mémoire peut être accessible.

Depuis le noyau 2.6.0, il existe 3 options : l'héritage (par défaut) et deux cas clairs où de nouvelles rencontres arrivent :

– new renvoie nullptr, avec de possibles effets néfastes ou un crash immédiat lorsque les constructeurs (appelés quand même)
initialiser les membres (les exceptions sont désactivées dans ce cas)

– Les exceptions C++ sont désactivées : les nouveaux appels abort() et planteront « proprement », car il n'y a aucun moyen d'honorer
allocation de mémoire ou pour récupérer gracieusement.

– Les exceptions C++ sont activées : new lève une exception C++ std::bad_alloc, qui peut être interceptée et gérée avec
élégance. Cela garantit un comportement correct, y compris la gestion de tous les sous-objets, ce qui garantit la stabilité.

Historique : #6269 #6309 #6312

3.9 Flux
API Arduino

Stream est l'une des classes principales de l'API Arduino. Les systèmes filaires, série, réseau et de fichiers sont des flux à partir
desquels les données sont lues ou écrites.

Faire un transfert avec des flux est assez courant, comme par exemple le croquis historique WiFiSerial :

//vérifie les données des clients //

obtient les données du client telnet et les envoie à l'UART while (serverClient.available())
{
Serial.write(serverClient.read());
}

//vérifie les données UART if

(Serial.available()) {
size_t len = Serial.available(); uint8_t sbuf[len];
Serial.readBytes(sbuf,
len); // envoie les données UART à tous
les clients telnet connectés if (serverClient && serverClient.connected())
{ serverClient.write(sbuf, len);

}
}

On remarquera que dans le sens réseau vers série, les données sont transférées octet par octet tant que les données sont
disponibles. Dans l'autre sens, un tampon temporaire est créé sur la pile, rempli des données série disponibles, puis
transféré au réseau.

La méthode readBytes(buffer, length) inclut un délai d'attente pour garantir que tous les octets requis sont reçus. La
fonction write(buffer, length) (héritée de Print::) bloque également généralement jusqu'à ce que le tampon complet soit
transmis. Les deux fonctions renvoient le nombre d'octets transmis.

18 Chapitre 3. Référence
 Documentation de base Arduino ESP8266, version 3.1.2-21-ga348833

C'est ainsi que fonctionne la classe Stream et elle est couramment utilisée.

Les classes dérivées de Stream:: introduisent également généralement la méthode read(buffer, len), qui est similaire à
readBytes(buffer, len) sans délai d'attente : la valeur renvoyée peut être inférieure à la taille demandée, il faut donc faire
particulièrement attention à cela fonction, introduite dans la classe Arduino Client:: (cf. implémentation de référence AVR). Cette
fonction a également été introduite dans d'autres classes qui ne dérivent pas de Client::, par exemple HardwareSerial::.

Extensions de flux

Les extensions Stream sont conçues pour être compatibles avec l'API Arduino et proposent des méthodes supplémentaires pour rendre
les transferts plus efficaces et plus faciles à utiliser.

Le transfert série vers réseau ci-dessus peut être écrit comme ceci :

serverClient.sendAvailable (Série); // morceau par morceau

Serial.sendAvailable(serverClient); // morceau par morceau

Un service d'écho peut s'écrire comme ceci :

serverClient.sendAvailable(serverClient); // service d'écho TCP

Serial.sendAvailable (Série); // bouclage logiciel série

En plus de réduire le temps de codage, ces méthodes optimisent les transferts en évitant les copies inutiles lorsque cela est possible.

• API destinée aux utilisateurs : Stream::send()

Le but des flux est de transférer des données entre producteurs et consommateurs, comme l'exemple telnet/série ci-dessus.
Quatre méthodes sont proposées, toutes renvoient le nombre d'octets transmis :

– Stream::sendSize(dest, taille [, timeout])

Cette méthode attend le délai d'expiration donné ou par défaut pour transférer la taille des octets vers le flux de
destination.

– Stream::sendUntil(dest, delim [, timeout])

Cette méthode attend le délai d'expiration donné ou par défaut pour transférer les données jusqu'à ce que la limite de
caractères soit respectée. Remarque : Le délimiteur est lu mais non transféré (comme readBytesUntil)

– Stream :: sendAvailable (dest)

Cette méthode transfère toutes les données déjà disponibles vers la destination. Il n'y a pas de délai d'attente et la
valeur renvoyée est 0 lorsqu'il n'y a rien à transférer ou qu'il n'y a pas de place dans la destination.

– Stream :: sendAll (dest [, timeout])

Cette méthode attend le délai d'expiration donné ou par défaut pour transférer toutes les données disponibles. C'est
utile lorsque la source est capable de dire qu'aucune donnée ne sera plus disponible pour cet appel, ou lorsque la
destination peut dire qu'elle ne pourra plus recevoir.

Par exemple, une chaîne source ne grandira pas pendant le transfert, ou une connexion réseau particulière censée
envoyer une quantité fixe de données avant de se fermer. ::sendAll() recevra tous les octets.
Le délai d'attente est utile lorsque la destination a besoin de temps de traitement (par exemple, le tampon d'entrée réseau ou série est
plein = veuillez patienter un peu).

• Chaînes, aides aux chaînes flash

Deux cours supplémentaires sont proposés.

– StreamConstPtr :: est conçu pour contenir une mémoire constante (en RAM ou flash).

3.9. Ruisseaux 19
Documentation de base Arduino ESP8266, version 3.1.2-21-ga348833

Avec cette classe, un Stream:: peut être créé à partir de chaînes const char*, F("quelques mots en flash") ou
PROGMEM. Cette classe ne fait aucune copie, même avec des données en flash. Pour le contenu Flash, les transferts
octet par octet sont une conséquence lorsque « memcpy_P » ne peut pas être utilisé. D'autres contenus peuvent être
transférés immédiatement lorsque cela est possible.

StreamConstPtr css(F("mes longues données CSS")); // Les données CSS ne sont pas copiées dans
la RAM server.sendAll(css);

– S2Stream :: est conçu pour créer un Stream :: à partir d'un String :: sans copie.

Chaîne bonjourChaîne("bonjour");
S2Stream bonjour(bonjourString);
bonjour.reset(0); // empêche ::read() de consommer la chaîne

bonjour.sendAll(Série); // affiche "bonjour"

bonjour.sendAll(Serial); // n'affiche rien, le contenu a déjà été lu hello.reset(); // réinitialiser le
pointeur de contenu hello.sendAll(Serial); // affiche "bonjour"
bonjour.reset(3); bonjour.sendAll(Série); // affiche "lo"
// réinitialise le pointeur de contenu vers une position spécifique

bonjour.setConsume(); // ::read() consommera, c'est la valeur par défaut

Serial.println(helloString.length()); // affiche 5 hello.sendAll(Serial);
Serial.println(helloString.length()); // // affiche "bonjour"
affiche 0, la chaîne est consommée

StreamString : dérive de S2Stream

StreamString contentStream ;
client.sendSize(contentStream, SOME_SIZE); // reçoit au plus SOME_ ,!SIZE octets

// équivalent à:

Contenu de chaîne ;
S2Stream contentStream(contenu);
client.sendSize(contentStream, SOME_SIZE); // reçoit au plus SOME_ ,!SIZE octets // le contenu
contient les
données

• API de flux interne : peekBuffer

Voici la liste des méthodes et leurs significations. Ils sont actuellement implémentés dans HardwareSerial,
WiFiClient et WiFiClientSecure.

– virtual bool hasPeekBufferAPI() renvoie true lorsque l'API est présente dans la classe

– virtual size_t peekAvailable() renvoie le nombre d'octets accessibles

– virtual const char* peekBuffer() renvoie le pointeur vers ces octets

Cette API nécessite qu'aucun type de fonction "lecture" ne soit appelé après peekBuffer() et jusqu'à
ce que peekConsume() soit appelé.

– virtual void peekConsume (size_t consume) indique de supprimer ce nombre d'octets

– booléen virtuel inputCanTimeout ()

20 Chapitre 3. Référence
 Documentation de base Arduino ESP8266, version 3.1.2-21-ga348833

Un StringStream renverra false. Une connexion réseau fermée renvoie false. Cette fonction permet
à Stream::sendAll() de revenir plus tôt.

– sortie booléenne virtuelleCanTimeout ()

Une connexion réseau fermée renvoie false. Cette fonction permet à Stream::sendAll() de revenir
plus tôt.

– virtuel ssize_t streamRemaining()

Il renvoie -1 lorsque la taille restante du flux est inconnue, en fonction de l'implémentation (taille de la chaîne, taille
du fichier ..).

3.9. Ruisseaux 21
Machine Translated by Google

Documentation de base Arduino ESP8266, version 3.1.2-21-ga348833

22 Chapitre 3. Référence