Połączenie Ethernet TCP z Arduino
Z punktu widzenia oprogramowania, nawiązanie połączenia Ethernet z Arduino To bardzo proste. Aby to zrobić, użyj Biblioteka Ethernetowa. Ta biblioteka jest przeznaczona dla Osłona Ethernet który opiera się na zintegrowanej W5100, ale istnieją inne różne płyty lub moduły i/lub które wykorzystują inne zintegrowane, takie jak ENC28J60. Aby uprościć jego użycie i zwiększyć kompatybilność, inne biblioteki używają (prawie) tego samego API że Biblioteka Ethernetowa, wystarczy zastąpić bibliotekę alternatywną oryginalną lub dołączyć ją (jeśli nazwa jest inna) w jej miejsce, nawet jeśli w kodzie zastosowano te same (lub bardzo podobne) funkcje. W moim przypadku używam tzw Biblioteka UIPEthernet de Norberta Truchsess postępując zgodnie z tym samym procesem, który opiszę w tym tekście.
1. Zdefiniuj połączenie Ethernet
Niezależnie od tego, czy zamierzasz przyjąć rolę klient jak ten Serwer, przede wszystkim musisz zdefiniować połączenie z funkcją zaczynać () który można przekazać jako parametr tylko Adres MAC i poczekaj na serwer DHCP w sieci przypisz a adres IP i resztę konfiguracji lub można także wskazać (opcjonalnie) więcej parametrów aż do zdefiniowania pełnej konfiguracji:
- Dirección MAC (o czym już wspomniano)
- Adres IP osłony lub modułu
- Adres IP serwera DNS (tylko jeden serwer)
- Adres IP Przejście
- Maska sieciowa
Wskazane jest wskazanie wszystkich parametrów, chyba że ich odliczenie jest zwykłe, aby uniknąć nieprawidłowej konfiguracji (np. bramka nie jest pierwszym adresem sieci).
Z powyższego wynika, że dane reprezentujące adresy IP muszą być wykorzystywane dość często, dlatego w bibliotece znajduje się klasa Adres IP z którego można utworzyć instancję obiektów adresów IP. Parametry, które to definiują, to cztery bajty adresu IPV4
La Adres MAC Jest ona zdefiniowana dla tej biblioteki jako tablica 6-bajtowa. Adres MAC jest (ma być) unikalnym identyfikatorem, w którym pierwsze bajty wskazują producenta i model, a ostatnie konkretne urządzenie. Zintegrowany ENC28J60 nie zawiera adresu MAC, chyba że zdecydujesz się na zakup również Zintegrowany adres MAC firmy Microchip (lub cały blok TAK adresów do IEEE jeśli liczba urządzeń jest na tyle duża, że jest to opłacalne). Jeśli nie masz adresu MAC, możesz go wymyślić, uważając, aby nie kolidował z innymi adresami w sieci, w której znajduje się urządzenie.
Jeśli konfiguracja odbywa się za pomocą serwera DHCP, a nie „ręcznie”, funkcja lokalny adres IP() Warto sprawdzić adres, który serwer przypisał modułowi. Aby odnowić przydzielony adres (jeśli upłynął odpowiedni czas), należy kliknąć Biblioteka Ethernetowa zapewnia tę funkcję utrzymywać() który poinformuje również, zwracając kod odpowiadający statusowi odnowienia:
- Operacja nie przyniosła żadnego efektu
-
Błąd podczas odnawiania adresu IP
Nie można było przedłużyć wykorzystania przypisanego adresu IP na tym samym serwerze - Adres IP został pomyślnie odnowiony
-
Ponowne przypisanie adresu IP nie powiodło się
Nie można było rozszerzyć wykorzystania przypisanego adresu IP na żadnym serwerze - Adres IP został pomyślnie przypisany
Na podstawie dotychczasowych informacji można napisać przykład inicjowania połączenia Ethernet poprzez skonfigurowanie adresu IP za pośrednictwem serwera DHCP w sieci. Poniższy przykładowy kod próbuje odnawiać adres IP co określony czas i raportuje wynik.
|
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(“]”);
}
|
Poniższy przykład przypisuje adres IP i resztę konfiguracji ręcznie za pomocą obiektów Adres IP aby uczynić go wygodniejszym do odczytania i (w przypadku bardziej złożonego kodu) aby uniknąć błędów, które mogłyby wystąpić w przypadku (błędnego) wpisania adresu przy każdym jego użyciu.
|
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. Uruchom połączenie w trybie klienta lub serwera
Podczas inicjowania połączenia w trybie serwera opracowywany jest mikrokontrolowany system, który nasłuchuje żądań z innych systemów. Aby rozpocząć połączenie jako serwer, użyj Serwer Ethernet() a port, na którym serwer będzie nasłuchiwał, jest wskazany jako parametr. Serwer Ethernet() jest konstruktorem klasy serwer, który obsługuje wszystkie operacje Ethernet jako serwer. Chociaż najbardziej ortodoksyjną rzeczą jest wykonanie połączenia z konstruktorem Serwer Ethernet(), nierzadko można znaleźć przykłady, które bezpośrednio korzystają z tej klasy serwer lub alternatywne biblioteki dla połączenia Ethernet, które korzystają z tego systemu instancji.
Połączenie jako klient to takie, które wysyła żądania do systemu serwera, który na nie czeka i odpowiednio na nie odpowiada. Aby nawiązać połączenie jako klient, użyj Klient Ethernet() jaki jest konstruktor klasy klientem początek wszystkich operacji Ethernet jako klient.
W przeciwieństwie do tego, co dzieje się w trybie serwera, który zakłada, że działa od momentu utworzenia instancji klasy (chociaż będzie odpowiadać klientom tylko wtedy, gdy rzeczywiście tak jest), przed użyciem należy sprawdzić, czy połączenie klienta jest gotowe. Do obiektu klienta tworzonego po zainicjowaniu połączenia można wysłać zapytanie, czy jest dostępny. Na przykład operacje zapytań mogą być zawarte w strukturze if(Klient Ethernet) aby wykonać je tylko wtedy, gdy połączenie klienta jest dostępne.
|
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. Nawiąż połączenie jako klient
Jak już powiedziano, po utworzeniu połączenia to klient przejmuje inicjatywę w zakresie wysyłania zapytań. Serwer będzie czekał na tę inicjatywę i odpowiednio zareaguje. To zatem klient łączy się z serwerem, w tym celu korzystamy połączyć() wskazanie serwera jako parametrów (adres IP lub URL) A port w tym, który słucha.
Na podstawie wyniku operacji funkcja zwróci wartości
- () Połączenie nawiązane pomyślnie
- Nawiązywanie połączenia
- () Upłynął limit czasu i nie nawiązano połączenia
- () Serwer nie został znaleziony lub nie odpowiada poprawnie
- () Połączenie zostało zerwane, zanim zostało w pełni nawiązane
- () Odpowiedź serwera jest nieprawidłowa
Przed przystąpieniem do zadawania zapytań należy sprawdzić, czy połączenie z funkcją działa połączony() to powróci jeśli jest już dostępny lub Inaczej.
Poniższy przykład ilustruje połączenie jako klient, sprawdzający co 10 sekund, czy istnieje połączenie z serwerem (nie ma to być nic produktywnego, tylko pokazanie składni funkcji) coś, co swoją drogą produkcyjny serwer WWW nie chciałby zbyt wiele.
|
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. Wyślij dane
Podobnie jak inne, bardziej znane klasy, takie jak Seryjnyi przy porównywalnym zastosowaniu, klasy klientem y serwer mieć funkcje
-
o
Wysyła informacje za pomocą obiektu klienta lub serwera, z którego są wywoływane. Parametr „data” jest pojedynczy bajt o zwęglać podczas gdy „bufor” jest tablicą bajt o zwęglać z czego wysyłana jest kwota równa „długości". Ta funkcja jest używana do operacji binarnych, w porównaniu do dwóch kolejnych, które są zwykle zarezerwowane do wysyłania tekstu.
-
Wysyła jako klient lub serwer (w zależności od klasy z której jest używany) informację odpowiadającą „danym” w postaci tekstowej. Jeśli informacja nie jest wyrażona w formie tekstowej (np. jest to liczba całkowita), opcjonalny parametr „base” może zostać użyty do wybrania konwersji, którą może być jedna ze stałych BIN, OCT, DEC lub HEX wskazujących odpowiednio. podstawy odpowiadające binarnemu (podstawa 2), ósemkowemu (podstawa 8), dziesiętnemu (podstawa 10) i szesnastkowemu (podstawa 16)
-
Operacja jest identyczna jak poprzednia, z wyjątkiem wysłania, po informacji wyraźnie wskazanej przez parametr „data”, powrotu karetki (kod 13, który można przedstawić jako \r) i końca linii (kod 10, który można reprezentowane przez \n) Kody te są często określane odpowiednio za pomocą akronimu CR (powrót przewozu) i LF (podawanie liniowe)
Trzy poprzednie funkcje zwracają liczbę wysłanych bajtów, podobnie jak równoważne funkcje tej klasy Seryjny; Jak powiedziano powyżej, działanie jest porównywalne.
5. Odbierz dane
Podobnie jak w przypadku operacji wysyłania danych, operacje odbioru są porównywalne z operacjami powszechnie stosowanymi Seryjny. Protokół odbioru jest również podobny: sprawdź, czy dostępnych jest (wystarczająca) ilość danych (dostępny) i w takim razie je przeczytaj
-
Zwraca liczbę bajtów dostępnych do odczytania. Funkcja ta występuje w obu klasach klientem jako serwer; W pierwszym przypadku raportuje liczbę bajtów, które serwer wysłał w odpowiedzi na żądanie i które są dostępne do odczytania przez klienta (czytać), a w drugim przypadku klient (obiekt), który wykonał operację lub false, jeśli jej nie ma.
-
Służy do odczytywania otrzymanych informacji. Ta funkcja jest dostępna tylko na zajęciach klientem. Jeżeli tworzona aplikacja pełni rolę serwera, aby odczytać otrzymaną informację należy utworzyć instancję obiektu klienta z odpowiedzią funkcji dostępny () omówione w poprzedniej sekcji.
Poniższy przykład to „serwer z dużymi literami”, który nasłuchuje na porcie 2000 i, jeśli to możliwe, odpowiada na żądania, przesyłając wszystko, co zostało wysłane, pisane wielkimi literami. Można to przetestować np PuTTY lub po prostu z Z pewnością nie jest to zbyt praktyczne, ma na celu jedynie pokazanie, w jaki sposób można uzyskać z serwera dane przesyłane do niego przez klienta.
|
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. Zakończ połączenie
Chociaż zwykle aplikacja serwerowa działa w nieskończoność, połączenia klienckie są nawiązywane, nawiązywane i kończone, co pozwala na odzyskanie zasobów i wykorzystanie ich w innych połączeniach lub przeznaczenie ich do innych zastosowań programu. Funkcja zatrzymać() klasy klientem Służy do zakończenia połączenia klienta i zwolnienia wykorzystywanych przez niego zasobów.
W przypadku serwera fakt, że klient kończy połączenie po wysłaniu lub odebraniu obiektu informacyjnego zapytania, umożliwia mu także zwolnienie zasobów w celu przydzielenia ich do innych połączeń lub innych celów. Krótko mówiąc, choć wydaje się to drobnostką, wskazane jest zakończenie połączenia po zakończeniu operacji klienta.
Inną dobrą praktyką podczas kończenia połączenia klienta jest opróżnienie pliku z którego korzysta klasa. Aby to zrobić, dostępna jest funkcja spłukać() powinien zostać wywołany po zakończeniu połączenia klienta z zatrzymać()
Przykład zapytania HTTP GET
Aby lepiej wyjaśnić powyższe, poniżej znajduje się pełniejszy przykład żądań. TCP za pomocą żądań GET za pomocą Protokół HTTP. W przykładzie wartości uzyskane przez czujniki analogowe podłączone do płytki Arduino przesyłane są do serwera WWW, który przechowuje je w bazie danych.
|
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;
}
}
}
|
Zamieść komentarz