Ethernet TCP kapcsolat Arduino-val
Szoftveres szempontból kapcsolat létesítése Ethernet a Arduino Ez nagyon egyszerű. Ehhez használja a Ethernet könyvtár. Ezt a könyvtárat a Ethernet pajzs amely az integrált W5100, de vannak más különböző táblák vagy modulok és/vagy amelyek más integrált kártyákat használnak, mint pl ENC28J60. A használat egyszerűsítése és a kompatibilitás növelése érdekében más könyvtárak (majdnem) ugyanezt használják API hogy Ethernet könyvtár, akkor csak az alternatív könyvtárat kell helyettesítenie az eredetivel, vagy felvenni (ha más a név) a helyére, még akkor is, ha a kódban ugyanazok (vagy nagyon hasonló) függvények szerepelnek. Az én esetemben a UIPEthernet könyvtár de Truchsess Norbert ugyanazt a folyamatot követve, amelyet ebben a szövegben leírok.
1. Határozza meg az Ethernet kapcsolatot
Függetlenül attól, hogy felvállalja-e a szerepét vásárló mint az egyik szerver, először meg kell határozni a kapcsolatot a függvénnyel kezdődik () amely paraméterként csak az adható át MAC cím és várj egy szerverre DHCP a hálózaton rendelje hozzá a IP-cím és a konfiguráció többi része, vagy lehetőség van (opcionális) további paraméterek feltüntetésére is, amíg a teljes konfigurációt meg nem határozzák:
- Dirección MAC (amiről már volt szó)
- IP-cím a pajzs vagy a modul
- Szerver IP címe DNS (csak egy szerver)
- IP címe Gateway
- Hálómaszk
Célszerű az összes paramétert feltüntetni, hacsak nem a szokásos a levonásuk, nehogy a konfiguráció hibás legyen (például ne az átjáró a hálózat első címe).
A fentiekből úgy tűnik, hogy az IP-címeket reprezentáló adatokat elég gyakran kell használni, ezért a könyvtár tartalmazza az osztályt. IP-cím ahonnan az IP-cím objektumokat példányosítani kell. Az ezt meghatározó paraméterek egy cím négy bájtja IPV4
La MAC cím Ehhez a könyvtárhoz egy 6 bájtos tömbként van definiálva. A MAC cím egy egyedi azonosító, amelyben az első bájtok a gyártót és a modellt, az utolsó bájtok pedig az adott eszközt jelzik. Az integrált ENC28J60 nem tartalmaz MAC-címet, kivéve, ha úgy dönt, hogy megvásárolja a Integrált MAC cím a Microchiptől (vagy egy egész blokkot IGEN címek közül IEEE ha az eszközök futása elég nagy ahhoz, hogy megérje). Ha nincs MAC-címe, kitalálhat egyet, ügyelve arra, hogy ne ütközzen másokkal azon a hálózaton, ahol az eszköz található.
Ha a konfiguráció DHCP szerverrel történik a "kézzel" helyett, akkor a funkció localIP() Hasznos megnézni azt a címet, amelyet a szerver rendelt a modulhoz. A hozzárendelt cím megújításához (ha a megfelelő idő lejárt) a Ethernet könyvtár biztosítja a funkciót fenntartani () amely a megújítás állapotának megfelelő kód visszaküldésével is tájékoztatja:
- A műveletnek nem volt hatása
-
Hiba történt az IP-cím megújításakor
A hozzárendelt IP-cím használata ugyanazon a szerveren nem bővíthető - IP-cím sikeresen megújítva
-
Az IP-cím újrakötése nem sikerült
A hozzárendelt IP-cím használatát egyetlen szerveren sem lehetett kiterjeszteni - Az IP-cím újbóli hozzárendelése sikeresen megtörtént
Az eddig látott információk alapján írhat egy példát arra, hogy az IP-cím DHCP-kiszolgálón keresztül történő konfigurálásával Ethernet-kapcsolat kezdeményezhető. A következő példakód megpróbálja megújítani az IP-címet bizonyos időközönként, és jelentést készít az eredményről.
|
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(“]”);
}
|
Az alábbi példa az IP-címet és a konfiguráció többi részét manuálisan, objektumok segítségével rendeli hozzá IP-cím hogy kényelmesebb legyen az olvasás, és (összetettebb kód esetén) elkerüljük azokat a hibákat, amelyek akkor fordulhatnak elő, ha a címet minden egyes használatkor (rossz)írják.
|
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. Indítsa el a kapcsolatot kliens vagy szerver módban
Amikor szerver módban kezdeményezünk kapcsolatot, akkor a fejlesztés alatt álló mikrokontrollált rendszer figyeli meg a többi rendszertől érkező kéréseket. A kapcsolat kiszolgálóként történő indításához használja a EthernetServer() és paraméterként van megadva a port, amelyen a szerver figyelni fog. EthernetServer() az osztály konstruktora szerver, amely szerverként támogatja az összes Ethernet-műveletet. Bár a legortodoxabb az, hogy felhívjuk a kivitelezőt EthernetServer(), nem ritka néhány olyan példa, amely közvetlenül használja az osztályt szerver vagy alternatív könyvtárak Ethernet-kapcsolathoz, amelyek az adott példányosítási rendszert választják.
A kapcsolat kliensként az, amely kéréseket küld a szerver rendszernek, amely megvárja és megfelelően válaszol rájuk. Ha kliensként szeretne kapcsolatot kezdeményezni, használja a EthernetClient() mi az osztály konstruktora Vásárló minden Ethernet-művelet eredetét kliensként.
Ellentétben azzal, ami a szerver móddal történik, amelyről azt feltételezik, hogy az osztály példányosításának pillanatától működik (bár csak akkor válaszol az ügyfeleknek, ha valóban így van), használat előtt ellenőriznie kell, hogy az ügyfélkapcsolat készen áll-e. A kapcsolat indításakor létrehozott ügyfélobjektum lekérdezhető, hogy elérhető-e. Például lekérdezési műveletek beépíthetők egy struktúrába if(EthernetClient) hogy csak akkor hajtsák végre őket, ha elérhető az ügyfélkapcsolat.
|
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. Hozzon létre kapcsolatot ügyfélként
Ahogy már elhangzott, a kapcsolat létrehozása után az ügyfél kezdeményezi a lekérdezéseket. A szerver várni fogja a kezdeményezést, és ennek megfelelően válaszol. Ezért a kliens csatlakozik a szerverhez, ezt használjuk connect () paraméterként megadva a szervert (az IP-címet vagy a URL) és a port abban, aki hallgat.
A művelet eredménye alapján a függvény visszaadja az értékeket
- () A kapcsolat sikeresen létrejött
- A kapcsolat létrehozása
- () Az időkorlát letelt a kapcsolat létrehozása nélkül
- () A szerver nem található, vagy nem válaszol megfelelően
- () A kapcsolat megszakadt, mielőtt teljesen létrejött volna
- () A szerver válasza helytelen
A lekérdezések megkezdése előtt ellenőrizni kell, hogy a kapcsolat működik-e a funkcióval csatlakoztatva() hogy vissza fog térni ha már elérhető ill másképp.
Az alábbi példa a kapcsolatot szemlélteti kliensként, 10 másodpercenként ellenőrzi, hogy van-e kapcsolat a szerverrel (egyáltalán nem célja, hogy produktív legyen, csak a függvények szintaxisát mutassa), ami egyébként egy termelési webszervernek nem nagyon tetszene.
|
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. Adatok küldése
Mint más ismertebb osztályok, mint pl Sorozatszám, és hasonló használat mellett az osztályok Vásárló y szerver rendelkeznek a funkciókkal
-
o
Információkat küld annak a kliens- vagy szerverobjektumnak a használatával, amelyből meghívásra került. Az "adat" paraméter egyetlen byte o faszén míg a "puffer" egy tömb byte o faszén amelyből a „hosszúsággal” megegyező összeg kerül elküldésre. Ez a funkció a bináris műveletekhez használatos, összehasonlítva a következő kettővel, amelyeket általában szövegküldésre tartanak fenn.
-
Kliensként vagy szerverként (attól függően, hogy melyik osztályból használják) elküldi az "adatoknak" megfelelő információkat szövegként. Ha az információ nem szövegként van kifejezve (például egész szám), akkor az opcionális "base" paraméterrel választhatjuk ki a konverziót, amely lehet a BIN, OCT, DEC vagy HEX konstansok egyike, amelyek rendre jelzik. bázisok, amelyek megfelelnek a binárisnak (2. bázis), az oktálisnak (8. bázis), a decimálisnak (10. bázis) és a hexadecimálisnak (16. bázis)
-
A művelet megegyezik az előzővel, kivéve, hogy a "data" paraméterrel kifejezetten jelzett információ után egy kocsivisszaküldést (13-as kód, amely \r-ként ábrázolható) és egy sorvéget (10-es kód, amely lehet \n) Ezekre a kódokra gyakran utalunk a betűszóval CR (Carriage Return) és LF (soremelés)
Az előző három függvény az elküldött bájtok számát adja vissza, csakúgy, mint az osztály ekvivalens függvényei Sorozatszám; Mint fentebb említettük, a művelet összehasonlítható.
5. Adatok fogadása
Az adatküldési műveletekhez hasonlóan a fogadási műveletek is hasonlóak a széles körben használt műveletekhez Sorozatszám. A fogadási protokoll is hasonló: ellenőrizze, hogy van-e (elég) elérhető adat (elérhető), és ebben az esetben olvassa el őket
-
Az olvasható bájtok számát adja vissza. Ez a függvény mindkét osztályban megtalálható Vásárló mint szerver; Az első esetben azt jelenti, hogy a szerver hány bájtot küldött válaszul egy kérésre, és amely a kliens számára elérhető (olvas), a második esetben pedig a műveletet végrehajtó kliens (objektum), vagy false, ha nincs.
-
A kapott információk olvasására szolgál. Ez a funkció csak az osztályban érhető el Vásárló. Ha a fejlesztés alatt álló alkalmazás a szerver szerepét tölti be, akkor a beérkezett információk olvasásához egy kliens objektumot kell példányosítani a függvényválaszsal. elérhető () az előző részben tárgyaltuk.
A következő példa egy "nagybetűs kiszolgáló", amely a 2000-es porton figyel, és a kérésekre lehetőség szerint csupa nagybetűvel válaszol. Kipróbálható pl PuTTY vagy egyszerűen azzal Természetesen nem túl praktikus, csak az a célja, hogy megmutassa, hogyan lehet a szerverről megszerezni a kliens által neki küldött adatokat.
|
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. Fejezze be a kapcsolatot
Noha a kiszolgálóalkalmazások általában határozatlan ideig futnak, az ügyfélkapcsolatok létrejönnek, létrejönnek és megszakadnak, lehetővé téve az erőforrások helyreállítását és más kapcsolatokban való felhasználását, vagy a program más felhasználási céljára történő felhasználását. A funkció álljon meg () osztályának Vásárló Az ügyfélkapcsolat megszakítására és az általa használt erőforrások felszabadítására szolgál.
A szerver számára az a tény, hogy a kliens megszakítja a kapcsolatot, amikor a lekérdezés információs objektuma elküldésre vagy fogadásra került, egyúttal lehetővé teszi számára, hogy erőforrásokat szabadítson fel, hogy azokat más kapcsolatokhoz vagy más célokhoz rendelje hozzá. Röviden, bár csekélynek tűnik, tanácsos megszakítani a kapcsolatot, amikor az ügyfél műveletei befejeződnek.
Egy másik jó gyakorlat az ügyfélkapcsolat megszakításakor az, hogy ürítse ki a amit az osztály használ. Ehhez a funkció elérhető flush() Az ügyfélkapcsolat megszakítása után kell meghívni álljon meg ()
HTTP GET lekérdezési példa
A fentiek jobb tisztázása érdekében az alábbiakban egy teljesebb példát találunk a kérésekre. TCP a GET kérések segítségével a HTTP protokoll. A példában az Arduino kártyához csatlakoztatott analóg érzékelők által kapott értékek egy webszerverre kerülnek, amely adatbázisban tárolja azokat.
|
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;
}
}
}
|
Hozzászólás Comment