Ethernet TCP ryšys su Arduino
Programinės įrangos požiūriu, ryšio užmezgimas "Ethernet" su Arduino Tai labai paprasta. Norėdami tai padaryti, naudokite Ethernet biblioteka. Ši biblioteka skirta a Ethernet skydas kuri remiasi integruotu W5100, tačiau yra ir kitų skirtingų plokščių ar modulių ir (arba) naudojančių kitas integruotas, pvz., ENC28J60. Siekdamos supaprastinti jo naudojimą ir padidinti suderinamumą, kitos bibliotekos naudoja (beveik) tą patį API kad Ethernet biblioteka, turėsite tik pakeisti alternatyvią biblioteką originalia arba įtraukti ją (kai pavadinimas skiriasi) į vietą, net jei kode naudojamos tos pačios (arba labai panašios) funkcijos. Mano atveju aš naudoju UIPEthernet biblioteka de Norbertas Truchsessas vadovaudamasis tuo pačiu procesu, kurį aprašysiu šiame tekste.
1. Apibrėžkite Ethernet ryšį
Nesvarbu, ar ketinate prisiimti vaidmenį klientas toks kaip serverio, pirmiausia turite apibrėžti ryšį su funkcija pradėti () kuris gali būti perduodamas kaip parametras tik MAC adresas ir laukti serverio DHCP tinkle priskirkite a IP adresas ir likusią konfigūraciją arba taip pat galima nurodyti (pasirinktinai) daugiau parametrų, kol bus apibrėžta visa konfigūracija:
- Dirección MAC (kas jau buvo minėta)
- IP adresas skydo arba modulio
- Serverio IP adresas DNS (tik vienas serveris)
- IP adresas Vartai
- Tinklinė kaukė
Patartina nurodyti visus parametrus, nebent jų išskaičiavimas yra įprastas, kad būtų išvengta neteisingos konfigūracijos (pvz., vartai nėra pirmasis tinklo adresas).
Iš to, kas išdėstyta aukščiau, atrodo aišku, kad duomenys, vaizduojantys IP adresus, turi būti naudojami gana dažnai, todėl bibliotekoje yra klasė IP adresas iš kurių imami IP adresų objektai. Jį apibrėžiantys parametrai yra keturi adreso baitai IPV4
La MAC adresas Šiai bibliotekai jis apibrėžiamas kaip 6 baitų masyvas. MAC adresas yra (turėtų būti) unikalus identifikatorius, kurio pirmieji baitai nurodo gamintoją ir modelį, o paskutiniai – konkretų įrenginį. Integruotas ENC28J60 neapima MAC adreso, nebent taip pat nuspręsite įsigyti a Integruotas MAC adresas iš Microchip (arba visą bloką OUI adresų IEEE jei įrenginių skaičius yra pakankamai didelis, kad būtų verta). Kai neturite MAC adreso, galite jį sugalvoti, pasirūpindami, kad jis neprieštarautų kitiems tinkle, kuriame yra įrenginys.
Jei konfigūracija atliekama naudojant DHCP serverį, o ne „ranka“, funkcija vietinis IP () Naudinga pasidomėti adresu, kurį serveris priskyrė moduliui. Norėdami atnaujinti priskirtą adresą (jei pasibaigė atitinkamas laikas) Ethernet biblioteka suteikia funkciją išlaikyti () kuri taip pat informuos grąžindama kodą, atitinkantį atnaujinimo būseną:
- Operacija neturėjo jokio poveikio
-
Klaida atnaujinant IP adresą
Nepavyko pratęsti priskirto IP adreso naudojimo tame pačiame serveryje - IP adresas sėkmingai atnaujintas
-
IP adreso perrišimas nepavyko
Priskirto IP adreso naudojimo nepavyko pratęsti jokiame serveryje - IP adresas sėkmingai perskirtas
Turėdami iki šiol matytą informaciją, galite parašyti pavyzdį, kaip būtų inicijuojamas Ethernet ryšys sukonfigūravus IP adresą per DHCP serverį tinkle. Šis pavyzdinis kodas bando atnaujinti IP adresą kas tam tikrą laikotarpį ir praneša apie rezultatą.
|
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(“]”);
}
|
Toliau pateiktame pavyzdyje IP adresas ir likusi konfigūracija priskiriama rankiniu būdu naudojant objektus IP adresas kad būtų patogiau skaityti ir (jeigu kodas sudėtingesnis) išvengtumėte klaidų, kurios galėtų atsirasti, jei adresas būtų (ne)parašytas kiekvieną kartą jį naudojant.
|
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. Pradėkite ryšį kliento arba serverio režimu
Inicijuojant ryšį serverio režimu, būtent kuriama mikrovaldoma sistema išklauso kitų sistemų užklausas. Norėdami pradėti ryšį kaip serveris, naudokite eterneto serveris () o prievadas, kuriuo serveris klausys, nurodomas kaip parametras. eterneto serveris () yra klasės konstruktorius serverio, kuris palaiko visas Ethernet operacijas kaip serveris. Nors ortodoksiausia – paskambinti konstruktoriui eterneto serveris (), neretai galima rasti pavyzdžių, kurie tiesiogiai naudoja klasę serverio arba alternatyvias bibliotekas Ethernet ryšiui, kurios pasirenka naudoti tą egzempliorių sistemą.
Ryšys kaip klientas yra tas, kuris pateikia užklausas serverio sistemai, kuri jų laukia ir atitinkamai atsako. Norėdami užmegzti ryšį kaip klientas, naudokite EthernetClient() kas yra klasės konstruktorius klientas visų Ethernet operacijų kaip kliento kilmė.
Skirtingai nuo serverio režimo, kuris, kaip manoma, veikia nuo klasės egzistavimo momento (nors jis reaguos į klientus tik tuo atveju, jei taip yra), prieš naudodami turite patikrinti, ar kliento ryšys yra paruoštas. Kliento objektas, sukurtas inicijuojant ryšį, gali būti užklaustas, ar jis pasiekiamas. Pavyzdžiui, užklausos operacijos gali būti įtrauktos į struktūrą if (EthernetClient) juos vykdyti tik tada, kai yra pasiekiamas kliento ryšys.
|
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. Užmegzkite ryšį kaip klientą
Kaip jau minėta, užmezgus ryšį klientas imasi iniciatyvos pateikti užklausas. Serveris lauks tos iniciatyvos ir atitinkamai atsakys. Todėl prie serverio prisijungia klientas, kurį naudojame tam Prisijungti() nurodant serverį kaip parametrus (IP adresą arba URL adresas) ir uostas tame, kuris klauso.
Remdamasi operacijos rezultatu, funkcija grąžins reikšmes
- () Ryšys sėkmingai užmegztas
- Ryšio užmezgimas
- () Praėjo laikas, kai ryšys neužmezgamas
- () Serveris nerastas arba netinkamai reaguoja
- () Ryšys buvo nutrauktas prieš visiškai užmezgant
- () Serverio atsakymas neteisingas
Prieš pradedant teikti užklausas, būtina patikrinti, ar ryšys veikia su funkcija prijungtas () kad grįš jei jau yra arba kitaip.
Toliau pateiktame pavyzdyje iliustruojamas ryšys kaip klientas, kas 10 sekundžių tikrinantis, ar yra ryšys su serveriu (jis nėra skirtas kaip produktyvus, tik norint parodyti funkcijų sintaksę) kažkas, beje, gamybiniam interneto serveriui labai nepatiktų.
|
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. Siųsti duomenis
Kaip ir kitos geriau žinomos klasės, pvz Serijinis, o su panašiu naudojimu – klasės klientas y serverio turi funkcijas
-
o
Siunčia informaciją naudodamas kliento arba serverio objektą, iš kurio ji iškviečiama. Parametras „duomenys“ yra vienas baitas o bakas o „buferis“ yra masyvas baitas o bakas iš kurių siunčiama suma, lygi "ilgiui". Ši funkcija naudojama dvejetainėms operacijoms, palyginti su kitomis dviem, kurios paprastai yra skirtos tekstui siųsti.
-
Siunčia kaip klientas arba serveris (priklausomai nuo klasės, iš kurios jis naudojamas) informaciją, atitinkančią „duomenis“ kaip tekstą. Jei informacija neišreiškiama tekstu (pavyzdžiui, tai yra sveikasis skaičius), pasirenkamas parametras "base" gali būti naudojamas konvertavimui pasirinkti, kuris gali būti viena iš konstantų BIN, OCT, DEC arba HEX, kurios atitinkamai nurodo. bazės, atitinkančios dvejetainę (2 bazė), aštuntainę (8 bazė), dešimtainę (10 bazė) ir šešioliktainę (16 bazė)
-
Operacija yra identiška ankstesnei, išskyrus tai, kad po „duomenų“ parametru aiškiai nurodytos informacijos siunčiamas vežimo grįžimas (kodas 13, kuris gali būti vaizduojamas kaip \r) ir eilutės pabaiga (kodas 10, kuri gali būti žymimas \n) Šie kodai dažnai vadinami atitinkamai akronimu CR (Carriage Return) ir LF (Line Feed)
Trys ankstesnės funkcijos grąžina išsiųstų baitų skaičių, kaip ir lygiavertės klasės funkcijos Serijinis; Kaip minėta aukščiau, operacija yra panaši.
5. Gauti duomenis
Kaip ir duomenų siuntimo operacijų atveju, gavimo operacijas galima palyginti su plačiai naudojamomis operacijomis Serijinis. Gavimo protokolas taip pat panašus: patikrinkite, ar yra (pakankamai) duomenų (prieinamas) ir tokiu atveju juos perskaitykite
-
Grąžina baitų, kuriuos galima nuskaityti, skaičių. Ši funkcija yra abiejose klasėse klientas kaip serverio; Pirmuoju atveju ji praneša baitų, kuriuos serveris išsiuntė atsakydamas į užklausą ir kurį klientas gali perskaityti, skaičių (skaityti), o antruoju atveju klientas (objektas), kuris atliko operaciją arba false, jei jos nėra.
-
Jis naudojamas gautai informacijai skaityti. Ši funkcija pasiekiama tik klasėje klientas. Jei kuriama programa atlieka serverio vaidmenį, norint nuskaityti gautą informaciją, kliento objektas turi būti pavaizduotas su funkcijos atsaku. galima () aptarta ankstesniame skyriuje.
Šis pavyzdys yra „didžiųjų raidžių serveris“, kuris klausosi 2000 prievado ir atsako į užklausas, jei įmanoma, tuo, kas buvo išsiųsta didžiosiomis raidėmis. Jį galima išbandyti, pavyzdžiui, su PuTTY arba tiesiog su Jis tikrai nėra labai praktiškas, jo tikslas tik parodyti, kaip iš serverio gauti kliento jam siunčiamus duomenis.
|
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. Nutraukite ryšį
Nors įprasta, kad serverio programa veikia neribotą laiką, kliento ryšiai užmezgami, užmezgami ryšiai ir nutraukiami, todėl ištekliai gali būti atkurti ir naudojami kituose ryšiuose arba skirti kitiems programos tikslams. Funkcija sustabdyti() klasės klientas Jis naudojamas nutraukti kliento ryšį ir atlaisvinti visus jo naudojamus išteklius.
Tai, kad klientas nutraukia ryšį, kai buvo išsiųstas arba gaunamas užklausos informacijos objektas, serveriui taip pat leidžia atlaisvinti išteklius, kad juos būtų galima skirti kitiems ryšiams ar kitiems tikslams. Trumpai tariant, nors tai atrodo nereikšminga, patartina nutraukti ryšį, kai baigiasi kliento operacijos.
Kita gera praktika nutraukiant ryšį su klientu yra ištuštinti kad klasė naudojasi. Norėdami tai padaryti, funkcija yra prieinama nuleisti () turėtų būti iškviestas nutraukus kliento ryšį su sustabdyti()
HTTP GET užklausos pavyzdys
Siekiant geriau paaiškinti visa tai, kas išdėstyta pirmiau, toliau pateikiamas išsamesnis užklausų pavyzdys. TCP naudojant GET užklausas naudojant HTTP protokolas. Pavyzdyje vertės, gautos analoginių jutiklių, prijungtų prie Arduino plokštės, siunčiamos į žiniatinklio serverį, kuris jas saugo duomenų bazėje.
|
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;
}
}
}
|
Rašyti komentarą