Koneksyon ng Ethernet TCP sa Arduino
Mula sa isang software point of view, pagtatatag ng isang koneksyon Ethernet sa Arduino Ito ay napaka-simple. Upang gawin ito, gamitin ang Ethernet library. Ang aklatan na ito ay dinisenyo para sa isang Ethernet Shield na nakabatay sa pinagsama-samang W5100, ngunit may iba pang iba't ibang board o module at/o gumagamit ng iba pang pinagsama-samang mga board, gaya ng ENC28J60. Upang pasimplehin ang paggamit nito at pataasin ang pagiging tugma, ang ibang mga aklatan ay gumagamit (halos) pareho API na Ethernet library, kakailanganin mo lamang palitan ang alternatibong library ng orihinal o isama ito (kapag iba ang pangalan) sa lugar nito kahit na ang parehong (o halos magkatulad) na mga function ay ginagamit sa code. Sa aking kaso, ginagamit ko ang UIPEthernet library de Norbert Truchsess sumusunod sa parehong proseso na ilalarawan ko sa tekstong ito.
1. Tukuyin ang koneksyon sa Ethernet
Kung kukuha ka man ng papel ng parokyano tulad ng isa server, una sa lahat kailangan mong tukuyin ang koneksyon sa function simulan () na maaaring maipasa bilang isang parameter lamang ang MAC address at maghintay para sa isang server DHCP sa network magtalaga ng a IP adress at ang natitirang configuration o posible ring magpahiwatig (opsyonal) ng higit pang mga parameter hanggang sa matukoy ang kumpletong configuration:
- Dirección MAC (na nabanggit na)
- IP address ng kalasag o modyul
- Address ng server ng IP DNS (isang server lang)
- IP address ng Gateway
- Net mask
Maipapayo na ipahiwatig ang lahat ng mga parameter, maliban kung ang kanilang pagbabawas ay ang karaniwan, upang maiwasan na ang pagsasaayos ay hindi tama (halimbawa, na ang gateway ay hindi ang unang address ng network).
Mula sa itaas, tila malinaw na ang data na kumakatawan sa mga IP address ay dapat gamitin nang madalas, kaya naman ang silid-aklatan ay kinabibilangan ng klase IP address mula sa kung saan i-instantiate ang mga bagay sa IP address. Ang mga parameter na tumutukoy dito ay ang apat na byte ng isang address IPV4
La MAC address Ito ay tinukoy para sa library na ito bilang isang 6-byte array. Ang MAC address ay (dapat ay) isang natatanging identifier kung saan ang mga unang byte ay nagpapahiwatig ng tagagawa at modelo at ang mga huling ay nagpapahiwatig ng partikular na device. Ang pinagsama-samang ENC28J60 ay hindi kasama ang isang MAC address maliban kung pipiliin mong bumili din ng a Pinagsamang MAC address mula sa Microchip (o isang buong bloke OUI ng mga address sa IEEE kung ang pagpapatakbo ng mga aparato ay sapat na malaki upang gawin itong sulit). Kapag wala kang MAC address, maaari kang mag-imbento ng isa, pag-iingat na hindi ito sumasalungat sa iba sa network kung saan matatagpuan ang device.
Kung ang pagsasaayos ay tapos na sa isang DHCP server sa halip na "sa pamamagitan ng kamay", ang function localIP() Kapaki-pakinabang na kumonsulta sa address na itinalaga ng server sa module. Upang i-renew ang itinalagang address (kung ang kaukulang oras ay nag-expire na) ang Ethernet library nagbibigay ng function panatilihin() na magpapaalam din sa pamamagitan ng pagbabalik ng code na tumutugma sa katayuan ng pag-renew:
- Walang epekto ang operasyon
-
Error sa pag-renew ng IP address
Ang paggamit ng nakatalagang IP address sa parehong server ay hindi ma-extend - Matagumpay na na-renew ang IP address
-
Nabigo ang rebind ng IP address
Ang paggamit ng itinalagang IP address ay hindi maaaring palawigin sa anumang server - Matagumpay na naitalaga ang IP address
Sa impormasyong nakikita sa ngayon, maaari kang sumulat ng isang halimbawa kung paano sisimulan ang isang koneksyon sa Ethernet sa pamamagitan ng pag-configure ng IP address sa pamamagitan ng isang DHCP server sa network. Sinusubukan ng sumusunod na halimbawang code na i-renew ang IP address sa bawat tiyak na tagal ng panahon at iuulat ang resulta.
|
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(“]”);
}
|
Ang halimbawa sa ibaba ay nagtatalaga ng IP address at ang iba pang configuration nang manu-mano gamit ang mga bagay IP address upang gawing mas komportableng basahin at (sa kaso ng mas kumplikadong code) upang maiwasan ang mga error na maaaring mangyari kung ang address ay (maling) naisulat sa tuwing ito ay ginamit.
|
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. Simulan ang koneksyon sa client o server mode
Kapag nagpasimula ng isang koneksyon sa server mode, ito ay ang microcontrolled system na binuo na nakikinig sa mga kahilingan mula sa iba pang mga system. Upang simulan ang koneksyon bilang isang server, gamitin EthernetServer() at ang port kung saan makikinig ang server ay ipinahiwatig bilang isang parameter. EthernetServer() ay ang tagabuo ng klase server, na sumusuporta sa lahat ng pagpapatakbo ng Ethernet bilang isang server. Kahit na ang pinaka-orthodox na bagay ay ang tumawag sa constructor EthernetServer(), karaniwan nang makakita ng ilang halimbawa na direktang gumagamit ng klase server o mga alternatibong aklatan para sa koneksyon sa Ethernet na pipiliing gamitin ang instantiation system na iyon.
Ang koneksyon bilang isang kliyente ay ang isa na gumagawa ng mga kahilingan sa sistema ng server, na naghihintay para sa kanila at sumasagot sa kanila nang naaayon. Upang simulan ang isang koneksyon bilang isang kliyente, gamitin EthernetClient() ano ang constructor ng klase Kliente pinagmulan ng lahat ng pagpapatakbo ng Ethernet bilang isang kliyente.
Hindi tulad ng kung ano ang nangyayari sa server mode, na ipinapalagay na gagana mula sa sandaling ang klase ay instantiated (bagaman ito ay tutugon lamang sa mga kliyente kung ito talaga), dapat mong i-verify na ang koneksyon ng kliyente ay handa na bago gamitin ito. Ang object ng kliyente na nilikha kapag sinimulan ang koneksyon ay maaaring itanong upang makita kung ito ay magagamit. Halimbawa, ang mga pagpapatakbo ng query ay maaaring isama sa isang istraktura kung(EthernetClient) upang isagawa lamang ang mga ito kapag ang koneksyon ng kliyente ay magagamit.
|
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. Magtatag ng isang koneksyon bilang isang kliyente
Gaya ng nasabi na, kapag nalikha na ang koneksyon, ang kliyente na ang magkukusa na gumawa ng mga query. Maghihintay ang server para sa inisyatiba at tutugon nang naaayon. Ito ay, samakatuwid, ang kliyente na kumokonekta sa server, upang gawin ito ay ginagamit namin ikonekta () na nagpapahiwatig ng server bilang mga parameter (ang IP address o ang URL) at ang port sa nakikinig.
Batay sa resulta ng operasyon, ibabalik ng function ang mga halaga
- () Matagumpay na naitatag ang koneksyon
- Pagtatatag ng koneksyon
- () Lumipas ang timeout nang hindi naitatag ang koneksyon
- () Ang server ay hindi natagpuan o hindi tumutugon nang tama
- () Ang koneksyon ay ibinaba bago ganap na naitatag
- () Mali ang tugon ng server
Bago magsimulang gumawa ng mga query, kinakailangang i-verify na gumagana ang koneksyon sa function konektado() babalik yan kung ito ay magagamit na o kung hindi man.
Ang halimbawa sa ibaba ay naglalarawan ng koneksyon bilang isang kliyente, sinusuri bawat 10 segundo kung mayroong koneksyon sa server (hindi ito nilayon na maging produktibo, para lang ipakita ang syntax ng mga pag-andar) isang bagay na, sa pamamagitan ng paraan, isang produksyon hindi masyadong gusto ng web server.
|
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. Magpadala ng data
Tulad ng ibang mas kilalang klase, gaya ng Kuwentong de serye, at may maihahambing na paggamit, ang mga klase Kliente y server may mga function
-
o
Nagpapadala ng impormasyon gamit ang client o server object kung saan ito hinihingi. Ang parameter na "data" ay iisa byte o tangke habang ang "buffer" ay isang array ng byte o tangke kung saan ipinapadala ang halagang katumbas ng "haba." Ang function na ito ay ang ginagamit para sa mga binary na operasyon, kumpara sa susunod na dalawa na karaniwang nakalaan para sa pagpapadala ng text.
-
Ipinapadala bilang isang kliyente o server (depende sa klase kung saan ito ginamit) ng impormasyong nauugnay sa "data" bilang teksto. Kung ang impormasyon ay hindi ipinahayag bilang text (halimbawa ito ay isang integer) ang opsyonal na parameter na "base" ay maaaring gamitin upang piliin ang conversion, na maaaring isa sa mga constant BIN, OCT, DEC o HEX na nagpapahiwatig, ayon sa pagkakabanggit. ang mga base na naaayon sa binary (base 2), octal (base 8), decimal (base 10) at hexadecimal (base 16)
-
Ang operasyon ay kapareho ng nauna maliban sa pagpapadala, pagkatapos ng impormasyong hayagang ipinahiwatig ng parameter na "data", isang carriage return (code 13 na maaaring kinakatawan bilang \r) at isang dulo ng linya (code 10, na maaaring maging kinakatawan ng \n) Ang mga code na ito ay madalas na tinutukoy, ayon sa pagkakabanggit, ng acronym CR (Carriage Return) at LF (Line Feed)
Ibinabalik ng tatlong nakaraang function ang bilang ng mga byte na naipadala, pati na rin ang mga katumbas na function ng klase Kuwentong de serye; Tulad ng sinabi sa itaas, ang operasyon ay maihahambing.
5. Tumanggap ng data
Tulad ng sa kaso ng mga operasyon sa pagpapadala ng data, ang pagtanggap ng mga operasyon ay maihahambing sa mga malawakang ginagamit Kuwentong de serye. Ang pagtanggap ng protocol ay katulad din: suriin kung mayroong (sapat) na data na magagamit (magagamit) at sa kasong iyon basahin ang mga ito
-
Ibinabalik ang bilang ng mga byte na magagamit para basahin. Ang function na ito ay naroroon sa parehong mga klase Kliente bilang server; Sa unang kaso, iniuulat nito ang bilang ng mga byte na ipinadala ng server bilang tugon sa isang kahilingan at magagamit para mabasa ng kliyente (basahin), at sa pangalawang kaso ang kliyente (object) na nagsagawa ng operasyon o false kung wala.
-
Ito ay ginagamit upang basahin ang impormasyon na natanggap. Available lang ang feature na ito sa klase Kliente. Kung ang application na binuo ay tumutupad sa papel ng server, upang basahin ang impormasyon na dumating, ang isang client object ay dapat na instantiated na may tugon ng function. magagamit () tinalakay sa nakaraang seksyon.
Ang sumusunod na halimbawa ay isang "caps server" na nakikinig sa port 2000 at tumutugon sa mga kahilingan gamit ang anumang ipinadala sa lahat ng caps kapag posible. Maaari itong masuri, halimbawa, sa PuTTY o simpleng kasama Ito ay tiyak na hindi masyadong praktikal, ang layunin nito ay ipakita lamang kung paano makuha ang data na ipinadala dito ng isang kliyente mula sa server.
|
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. Tapusin ang koneksyon
Bagama't karaniwan para sa isang application ng server na tumakbo nang walang hanggan, ang mga koneksyon ng kliyente ay itinatag, gumawa ng mga koneksyon at wakasan, na nagpapahintulot sa mga mapagkukunan na mabawi at magamit sa iba pang mga koneksyon o nakatuon sa iba pang paggamit ng programa. Ang function huminto () ng klase Kliente Ito ay ginagamit upang wakasan ang isang koneksyon ng kliyente at palayain ang anumang mga mapagkukunan na ginagamit nito.
Para sa server, ang katotohanang tinapos ng kliyente ang koneksyon kapag naipadala o natanggap ang object ng impormasyon ng query ay nagbibigay-daan din dito na magbakante ng mga mapagkukunan upang ilaan ang mga ito sa iba pang mga koneksyon o iba't ibang layunin. Sa madaling salita, kahit na tila maliit, ipinapayong wakasan ang koneksyon kapag natapos na ang mga operasyon ng kliyente.
Ang isa pang magandang kasanayan kapag tinatapos ang isang koneksyon ng kliyente ay ang alisan ng laman ang na ginagamit ng klase. Upang gawin ito, magagamit ang function flush () dapat tawagan pagkatapos na wakasan ang koneksyon ng kliyente sa huminto ()
Halimbawa ng query sa HTTP GET
Upang mas mahusay na linawin ang lahat ng nasa itaas, isang mas kumpletong halimbawa ng mga kahilingan ang kasama sa ibaba. TCP gamit ang mga kahilingan sa GET gamit ang HTTP protocol. Sa halimbawa, ang mga halaga na nakuha ng mga analog sensor na konektado sa isang Arduino board ay ipinapadala sa isang web server na nag-iimbak ng mga ito sa isang database.
|
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;
}
}
}
|
Post Komento