Ethernet TCP spojenie s Arduino
Zo softvérového hľadiska nadviazanie spojenia Ethernet s Arduino Je to veľmi jednoduché. Ak to chcete urobiť, použite Ethernetová knižnica. Táto knižnica je určená pre a Ethernetový štít ktorý je založený na integr W5100, ale existujú aj iné rôzne dosky alebo moduly a/alebo ktoré používajú iné integrované, ako napr ENC28J60. Pre zjednodušenie jeho používania a zvýšenie kompatibility používajú ostatné knižnice (takmer) to isté API že Ethernetová knižnica, budete musieť iba nahradiť alternatívnu knižnicu pôvodnou alebo ju zahrnúť (keď je názov iný) na jej miesto, aj keď sú v kóde použité rovnaké (alebo veľmi podobné) funkcie. V mojom prípade používam UIPEthernet knižnica de Norbert Truchsess podľa rovnakého procesu, ktorý opíšem v tomto texte.
1. Definujte ethernetové pripojenie
Či sa chystáte prijať rolu zákazník ako napr Server, najprv musíte definovať spojenie s funkciou začať () ktorý môže byť odovzdaný ako parameter iba MAC adresa a čakať na server DHCP na sieti priradiť a IP adresa a zvyšok konfigurácie alebo je tiež možné uviesť (voliteľne) viac parametrov, kým nebude definovaná úplná konfigurácia:
- Dirección MAC (čo už bolo spomenuté)
- IP adresa štítu alebo modulu
- IP adresa servera DNS (iba jeden server)
- IP adresa Brána
- Maska siete
Odporúča sa uviesť všetky parametre, pokiaľ ich odpočet nie je obvyklý, aby sa predišlo nesprávnej konfigurácii (napríklad, že brána nie je prvou adresou siete).
Z vyššie uvedeného sa zdá, že je zrejmé, že údaje predstavujúce IP adresy je potrebné používať pomerne často, preto knižnica obsahuje triedu IP adresa z ktorých sa inštancia objektov IP adries. Parametre, ktoré ju definujú, sú štyri bajty adresy IPV4
La MAC adresa Pre túto knižnicu je definované ako 6-bajtové pole. MAC adresa je (má byť) jedinečný identifikátor, v ktorom prvé bajty označujú výrobcu a model a posledné bajty označujú konkrétne zariadenie. Integrovaný ENC28J60 nezahŕňa MAC adresu, pokiaľ sa nerozhodnete zakúpiť aj a Integrovaná MAC adresa od Microchip (alebo celý blok OUI adries na IEEE ak je počet zariadení dostatočne veľký na to, aby sa to oplatilo). Ak nemáte MAC adresu, môžete si ju vymyslieť a dbať na to, aby nebola v konflikte s ostatnými v sieti, kde sa zariadenie nachádza.
Ak sa konfigurácia vykonáva pomocou servera DHCP namiesto „ručne“, funkcia localIP() Je užitočné pozrieť sa na adresu, ktorú server pridelil modulu. Na obnovenie pridelenej adresy (ak uplynul príslušný čas) Ethernetová knižnica poskytuje funkciu udržiavať () ktorý bude informovať aj vrátením kódu, ktorý zodpovedá stavu obnovenia:
- Operácia nemala žiadny účinok
-
Chyba pri obnovovaní adresy IP
Použitie pridelenej adresy IP na rovnakom serveri nebolo možné predĺžiť - Adresa IP bola úspešne obnovená
-
Opätovné prepojenie adresy IP zlyhalo
Použitie pridelenej IP adresy nebolo možné rozšíriť na žiadnom serveri - Adresa IP bola úspešne pridelená
S informáciami, ktoré ste doteraz videli, môžete napísať príklad toho, ako by sa iniciovalo ethernetové pripojenie konfiguráciou adresy IP prostredníctvom servera DHCP v sieti. Nasledujúci príklad kódu sa pokúša obnoviť IP adresu každé určité časové obdobie a hlási výsledok.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
//#include <UIPEthernet.h> // Librería Ethernet que usaré después con el módulo ENC28J60
#include <Ethernet.h> // Librería Ethernet estándar
#define ESPERA_RENOVACION_IP 60000 // Un minuto
unsigned long reloj;
byte direccion_mac[]={0x12,0x34,0x56,0x78,0x9a,0xbc}; // Dirección MAC inventada
byte estado_DHCP;
void setup()
{
Serial.begin(9600);
Ethernet.begin(direccion_mac);
mostrar_direccion_ip();
reloj=millis()+ESPERA_RENOVACION_IP;
}
void loop()
{
if(millis()>reloj) // Tratar de renovar la IP cada ESPERA_RENOVACION_IP milisegundos
{
estado_DHCP=Ethernet.maintain();
switch(estado_DHCP)
{
case 0:
Serial.println(“Sin cambios”);
break;
case 1:
Serial.println(“Error al renovar la dirección IP”);
break;
case 2:
Serial.println(“Dirección IP renovada correctamente”);
break;
case 3:
Serial.println(“Error al reasignar la dirección IP”);
break;
case 4:
Serial.println(“Dirección IP reasignada correctamente”);
break;
default:
Serial.println(“Error desconocido”);
}
mostrar_direccion_ip();
reloj=millis()+ESPERA_RENOVACION_IP;
}
}
void mostrar_direccion_ip()
{
Serial.print(“Dirección IP actual [“);
Serial.print(Ethernet.localIP()); // Mostrará la dirección IP asignada por el servidor DHCP
Serial.println(“]”);
}
|
Nižšie uvedený príklad priraďuje IP adresu a zvyšok konfigurácie manuálne pomocou objektov IP adresa aby sa to dalo pohodlnejšie čítať a (v prípade zložitejšieho kódu) aby sa predišlo chybám, ktoré by mohli nastať, ak by bola adresa (chybne) zapísaná pri každom použití.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
#include <UIPEthernet.h> // Librería Ethernet usada con el módulo ENC28J60
// #include <Ethernet.h> // Librería Ethernet estándar
byte direccion_mac[]={0x12,0x34,0x56,0x78,0x9a,0xbc}; // Dirección MAC inventada
IPAddress direccion_ip_fija(192,168,1,69); // Dirección IP elegida para el módulo
IPAddress servidor_dns(87,216,170,85); // Servidor DNS OpenNIC (de Alejandro Bonet, http://opennic.alargador.org)
IPAddress puerta_enlace(192,168,1,14); // Dirección IP del router
IPAddress mascara_red(255,255,255,0); // Máscara de la red
void setup()
{
Serial.begin(9600);
while(!Serial){;} // He usado una placa Leonardo, me toca esperar a que el puerto serie esté operativo
Ethernet.begin(direccion_mac,direccion_ip_fija,servidor_dns,puerta_enlace,mascara_red);
Serial.print(“Dirección IP asignada [“);
Serial.print(Ethernet.localIP()); // Poco misterio, devolverá la dirección IP asignada manualmente
Serial.println(“]”);
}
void loop()
{
// Sólo es un ejemplo de configuración, no hace nada
}
|
2. Spustite pripojenie v režime klienta alebo servera
Pri inicializácii pripojenia v režime servera je to práve vyvíjaný mikroriadený systém, ktorý počúva požiadavky z iných systémov. Ak chcete spustiť pripojenie ako server, použite EthernetServer() a port, na ktorom bude server počúvať, je uvedený ako parameter. EthernetServer() je konštruktérom triedy server, ktorý podporuje všetky ethernetové operácie ako server. Aj keď najortodoxnejšia vec je zavolať konštruktérovi EthernetServer(), nie je nezvyčajné nájsť niekoľko príkladov, ktoré priamo používajú triedu server alebo alternatívne knižnice pre ethernetové pripojenie, ktoré sa rozhodnú použiť tento inštanciačný systém.
Pripojenie ako klient je to, ktoré vytvára požiadavky na serverový systém, ktorý na ne čaká a zodpovedajúcim spôsobom na ne odpovedá. Ak chcete inicializovať pripojenie ako klient, použite EthernetClient() čo je konštruktérom triedy Zákazník pôvod všetkých ethernetových operácií ako klient.
Na rozdiel od toho, čo sa stane s režimom servera, o ktorom sa predpokladá, že funguje od okamihu vytvorenia inštancie triedy (hoci bude reagovať na klientov iba vtedy, ak to tak naozaj je), musíte pred použitím overiť, či je pripojenie klienta pripravené. Klientsky objekt, ktorý sa vytvorí pri inicializácii pripojenia, sa môže dotazom zistiť, či je dostupný. Do štruktúry môžu byť zahrnuté napríklad operácie dotazov if(EthernetClient) vykonať ich iba vtedy, keď je dostupné pripojenie klienta.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
#include <UIPEthernet.h> // Librería Ethernet usada con el módulo ENC28J60
// #include <Ethernet.h> // Librería Ethernet estándar
byte direccion_mac[]={0x12,0x34,0x56,0x78,0x9a,0xbc}; // Dirección MAC inventada
IPAddress direccion_ip_fija(192,168,1,69); // Dirección IP elegida para el módulo
IPAddress servidor_dns(87,216,170,85); // Servidor OpenNIC (de Alejandro Bonet, http://opennic.alargador.org)
IPAddress puerta_enlace(192,168,1,14); // Dirección IP del router
IPAddress mascara_red(255,255,255,0); // Máscara de la red
EthernetServer servidor=EthernetServer(80); // Puerto 80 (típico de un servidor HTTP)
void setup()
{
Serial.begin(9600);
while(!Serial){;} // He usado una placa Leonardo, hay que esperar a que el puerto serie esté operativo
Ethernet.begin(direccion_mac,direccion_ip_fija,servidor_dns,puerta_enlace,mascara_red);
servidor.begin();
Serial.println(“Servidor HTTP iniciado”);
}
void loop()
{
// Sólo es un ejemplo de configuración, no hace nada productivo
}
|
3. Vytvorte spojenie ako klient
Ako už bolo povedané, akonáhle je spojenie vytvorené, je to klient, kto preberá iniciatívu zadávať dopyty. Server bude čakať na túto iniciatívu a podľa toho odpovie. Je to teda klient, ktorý sa pripája k serveru, na to používame pripojiť () označujúci server ako parametre (IP adresa alebo URL) a puerto v tom, kto počúva.
Na základe výsledku operácie funkcia vráti hodnoty
- () Spojenie bolo úspešne nadviazané
- Nadviazanie spojenia
- () Časový limit uplynul bez nadviazania spojenia
- () Server sa nenašiel alebo neodpovedá správne
- () Spojenie bolo prerušené pred úplným nadviazaním
- () Odpoveď servera je nesprávna
Pred začatím dopytovania je potrebné overiť, či je spojenie s funkciou funkčné pripojený() to sa vráti ak je už dostupný resp inak.
Príklad nižšie ilustruje pripojenie ako klient, ktorý každých 10 sekúnd kontroluje, či existuje pripojenie k serveru (nie je určené ako produktívne, len na zobrazenie syntaxe funkcií), čo je mimochodom, produkčný webový server by sa veľmi nepáčil.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
#include <UIPEthernet.h> // Librería Ethernet usada con el módulo ENC28J60
// #include <Ethernet.h> // Librería Ethernet estándar
#define INTERVALO_CONSULTA 10000 // Se comprueba cada 10 segundos si hay conexión
#define LED_CONEXION 13 // Pin del LED que parpadea cuando hay conexión
#define TIEMPO_PARPADEO 300 // Milisegundos entre encendido/apagado del LED que indica conexión
byte direccion_mac[]={0x12,0x34,0x56,0x78,0x9a,0xbc}; // Dirección MAC inventada
IPAddress direccion_ip_fija(192,168,1,69); // Dirección IP elegida para el módulo
IPAddress servidor_dns(87,216,170,85); // Servidor OpenNIC (de Alejandro Bonet, http://opennic.alargador.org)
IPAddress puerta_enlace(192,168,1,14); // Dirección IP del router
IPAddress mascara_red(255,255,255,0); // Máscara de la red
IPAddress ip_servidor_web(192,168,1,21); // Dirección IP del servidor web (en la intranet)
//char url_servidor_web[]=”sleepmanager.onironauta.es”; // URL poético para un gestor de sueño (en Internet)
EthernetClient cliente=EthernetClient();
byte estado_conexion;
boolean anteriormente_conectado;
boolean estado_led_conexion;
unsigned long cronometro_parpadeo;
unsigned long cronometro_consulta;
void conectar_ethernet()
{
estado_conexion=cliente.connect(ip_servidor_web,80); // Conexión desde la intranet
//estado_conexion=cliente.connect(url_servidor_web,80); // Conexión desde Internet
delay(100); // Un pequeño retraso para permitir que se active la conexión
anteriormente_conectado=false;
switch(estado_conexion)
{
case 1:
Serial.println(“Conexión con el servidor SleepManager establecida correctamente”);
anteriormente_conectado=true;
break;
case –1:
Serial.println(“Ha pasado el tiempo de espera sin que se establezca la conexión”);
break;
case –2:
Serial.println(“No se ha encontrado el servidor o no responde correctamente”);
break;
case –3:
Serial.println(“La conexión se ha interrumpido antes de establecerse completamente”);
break;
case –4:
Serial.println(“La respuesta del servidor es incorrecta”);
break;
}
}
void setup()
{
pinMode(LED_CONEXION,OUTPUT);
Serial.begin(9600);
while(!Serial){;} // Esperar al puerto serie de la placa Leonardo
Serial.println(“Conectando con el servidor SleepManager…”);
Ethernet.begin(direccion_mac,direccion_ip_fija,servidor_dns,puerta_enlace,mascara_red);
conectar_ethernet();
estado_led_conexion=false;
cronometro_parpadeo=0;
cronometro_consulta=millis()+INTERVALO_CONSULTA;
}
void loop()
{
if(anteriormente_conectado&&millis()>cronometro_parpadeo)
{
estado_led_conexion=!estado_led_conexion;
digitalWrite(LED_CONEXION,estado_led_conexion);
cronometro_parpadeo=millis()+TIEMPO_PARPADEO;
}
if(millis()>cronometro_consulta)
{
if(!cliente.connected())
{
conectar_ethernet();
}
cronometro_consulta=millis()+INTERVALO_CONSULTA;
}
}
|
4. Odošlite údaje
Podobne ako iné známejšie triedy, ako napr Sériovýa pri porovnateľnom použití aj triedy Zákazník y server mať funkcie
-
o
Odošle informácie pomocou objektu klienta alebo servera, z ktorého sú vyvolané. Parameter "data" je jediný byte o spáliť zatiaľ čo "buffer" je pole byte o spáliť z ktorých sa odošle množstvo rovnajúce sa „dĺžke". Táto funkcia sa používa na binárne operácie v porovnaní s ďalšími dvoma, ktoré sú zvyčajne vyhradené na odosielanie textu.
-
Odošle ako klient alebo server (v závislosti od triedy, z ktorej sa používa) informácie zodpovedajúce „údajom“ ako text. Ak informácia nie je vyjadrená ako text (napríklad je to celé číslo), možno použiť voliteľný parameter „základ“ na výber prevodu, ktorým môže byť jedna z konštánt BIN, OCT, DEC alebo HEX, ktoré označujú, resp. základy zodpovedajúce binárnemu (základ 2), osmičkovému (základ 8), desiatkovej (základ 10) a šestnástkovej sústave (základ 16)
-
Operácia je totožná s predchádzajúcou s výnimkou odoslania, po informácii výslovne označenej parametrom "data", návrat vozíka (kód 13, ktorý môže byť reprezentovaný ako \r) a koniec riadku (kód 10, ktorý môže byť reprezentované \n) Tieto kódy sú často označované skratkou CR (Carriage Return) a LF (riadkový posuv)
Tri predchádzajúce funkcie vrátia počet bajtov, ktoré boli odoslané, rovnako ako ekvivalentné funkcie triedy Sériový; Ako bolo uvedené vyššie, prevádzka je porovnateľná.
5. Príjem dát
Rovnako ako v prípade operácií odosielania údajov sú operácie prijímania porovnateľné s operáciami široko používanými Sériový. Prijímací protokol je tiež podobný: skontrolujte, či je k dispozícii (dostatok) údajov (dostupný) a v takom prípade si ich prečítajte
-
Vráti počet bajtov, ktoré sú k dispozícii na čítanie. Táto funkcia je prítomná v oboch triedach Zákazník ako server; V prvom prípade hlási počet bajtov, ktoré server odoslal ako odpoveď na požiadavku a ktoré má klient k dispozícii na čítanie (čítať), a v druhom prípade klient (objekt), ktorý vykonal operáciu alebo je falošný, ak žiadna neexistuje.
-
Používa sa na čítanie informácií, ktoré boli prijaté. Táto funkcia je dostupná iba v triede Zákazník. Ak vyvíjaná aplikácia plní úlohu servera, na čítanie informácií, ktoré prišli, je potrebné vytvoriť inštanciu objektu klienta s odpoveďou funkcie. k dispozícii () diskutované v predchádzajúcej časti.
Nasledujúci príklad je „server caps“, ktorý počúva na porte 2000 a odpovedá na požiadavky tým, čo bolo odoslané všetkými veľkými písmenami, ak je to možné. Dá sa otestovať napr PuTTY alebo jednoducho s Určite to nie je veľmi praktické, jeho účelom je len ukázať, ako získať dáta, ktoré mu klient posiela zo servera.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
#include <UIPEthernet.h> // Librería Ethernet usada con el módulo ENC28J60
//#include <Ethernet.h> // Librería Ethernet estándar
byte direccion_mac[]={0x12,0x34,0x56,0x78,0x9a,0xbc}; // Dirección MAC inventada
IPAddress direccion_ip_fija(192,168,1,69); // Dirección IP elegida para el módulo
IPAddress servidor_dns(87,216,170,85); // Servidor OpenNIC (de Alejandro Bonet, http://opennic.alargador.org)
IPAddress puerta_enlace(192,168,1,14); // Dirección IP del router
IPAddress mascara_red(255,255,255,0); // Máscara de la red
EthernetServer servidor=EthernetServer(2000);
EthernetClient cliente;
char texto_recibido; // Sólo para que se más fácil leer el programa usando varias líneas de código
void setup()
{
Serial.begin(9600);
while(!Serial){;} // Esperar al puerto serie de la placa Leonardo esté operativo
Ethernet.begin(direccion_mac,direccion_ip_fija,servidor_dns,puerta_enlace,mascara_red);
Serial.println(“Iniciando el servidor de mayúsculas”);
servidor.begin();
}
void loop()
{
cliente=servidor.available();
// Si hay disponible alguna petición de un cliente leerla y devolverla en mayúsculas
if(cliente)
{
texto_recibido=cliente.read();
if(texto_recibido>96&&texto_recibido<123) // Si se recibe una letra minúscula…
{
texto_recibido-=32; // …convertirla a mayúsculas
}
// Si se tiene la seguridad de recibir texto se puede usar print en lugar de write
servidor.write(texto_recibido); // Responder con lo recibido pasado a mayúsculas si procede
}
}
|
6. Ukončite pripojenie
Aj keď je obvyklé, že serverová aplikácia beží neobmedzene dlho, klientske pripojenia sa vytvárajú, vytvárajú pripojenia a ukončujú sa, čo umožňuje obnovenie zdrojov a ich použitie v iných pripojeniach alebo vyhradené na iné použitie programu. Funkcia stop () triedy Zákazník Používa sa na ukončenie pripojenia klienta a uvoľnenie všetkých zdrojov, ktoré používa.
Skutočnosť, že klient ukončí spojenie, keď bol informačný objekt dopytu odoslaný alebo prijatý, serveru tiež umožňuje uvoľniť zdroje na ich pridelenie iným spojeniam alebo iným účelom. Skrátka, aj keď sa to zdá byť zanedbateľné, je vhodné ukončiť spojenie, keď sa skončia operácie klienta.
Ďalšou dobrou praxou pri ukončovaní pripojenia klienta je vyprázdnenie ktoré trieda používa. Na tento účel je k dispozícii funkcia spláchnuť() by mal byť volaný po ukončení klientskeho spojenia s stop ()
Príklad dotazu HTTP GET
Na lepšie objasnenie všetkých vyššie uvedených skutočností je nižšie uvedený úplnejší príklad žiadostí. TCP pomocou požiadaviek GET pomocou HTTP protokol. V príklade sú hodnoty získané analógovými senzormi pripojenými k doske Arduino odoslané na webový server, ktorý ich uloží do databázy.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
|
#include <UIPEthernet.h> // Librería Ethernet usada con el módulo ENC28J60
// #include <Ethernet.h> // Librería Ethernet estándar
#define INTERVALO_CONSULTA 60000 // Enviar datos cada minuto
#define INTERVALO_RECONEXION 10000 // Reintentar la conexión 10 segundos más tarde si no ha sido posible hacerlo cuado correspondía
#define CANTIDAD_SENSORES 6 // Número de sensores analógicos empezando en A0
byte direccion_mac[]={0x12,0x34,0x56,0x78,0x9a,0xbc}; // Dirección MAC inventada
IPAddress direccion_ip_fija(192,168,1,69); // Dirección IP elegida para el módulo
IPAddress servidor_dns(87,216,170,85); // Servidor OpenNIC (de Alejandro Bonet, http://opennic.alargador.org)
IPAddress puerta_enlace(192,168,1,14); // Dirección IP del router
IPAddress mascara_red(255,255,255,0); // Máscara de la red
//IPAddress ip_servidor_web(192,168,1,21); // Dirección IP del servidor web (en la intranet)
char url_servidor_web[]=“sleepmanager.onironauta.es”; // URL poético para un gestor de sueño (en Internet)
EthernetClient cliente;
byte estado_conexion;
String texto_consulta;
unsigned long cronometro_consulta;
byte contador;
void setup()
{
Serial.begin(9600);
while(!Serial){;} // Esperar al puerto serie de la placa Leonardo
Serial.println(“Conectando con el servidor SleepManager…”);
Ethernet.begin(direccion_mac,direccion_ip_fija,servidor_dns,puerta_enlace,mascara_red);
cronometro_consulta=millis()+INTERVALO_CONSULTA;
}
void loop()
{
if(millis()>cronometro_consulta)
{
//estado_conexion=cliente.connect(ip_servidor_web,80); // Conexión desde la intranet
estado_conexion=cliente.connect(url_servidor_web,80); // Conexión desde Internet
while(estado_conexion==0) // esperar a que se establezca la conexión o se produzca un error
{
switch(estado_conexion)
{
case 1:
Serial.println(“Conexión con el servidor SleepManager establecida correctamente”);
break;
case –1:
Serial.println(“Ha pasado el tiempo de espera sin que se establezca la conexión”);
break;
case –2:
Serial.println(“No se ha encontrado el servidor o no responde correctamente”);
break;
case –3:
Serial.println(“La conexión se ha interrumpido antes de establecerse completamente”);
break;
case –4:
Serial.println(“La respuesta del servidor es incorrecta”);
break;
}
}
if(cliente.connected()) // Si ha sido posible conectar realizar la consulta
{
cronometro_consulta=millis()+INTERVALO_CONSULTA;
texto_consulta=“GET /pruebas/guardar_sensores_analogicos.php?origen=SleepManager”;
for(contador=0;contador<CANTIDAD_SENSORES;contador++)
{
texto_consulta=“&sensor_”+String(contador+1,DEC)+“=”+String(analogRead(contador),DEC);
delay(1); // Como tarda 100 μs en obtener el valor analógico, con 1 ms seguro le da tiempo
}
texto_consulta+=” HTTP/1.1\r\nHost: “+String(url_servidor_web)+“\r\nUser-Agent: sleep_inspector\r\n\r\n”;
cliente.print(texto_consulta);
cliente.flush();
cliente.stop();
}
else // Si no ha sido posible conectar reintentarlo más tarde pero no tanto como si hubiera sido posible hacerlo
{
cronometro_consulta=millis()+INTERVALO_RECONEXION;
}
}
}
|
Pridať komentár