חיבור Ethernet TCP עם Arduino
מנקודת מבט של תוכנה, יצירת חיבור Ethernet עם Arduino זה פשוט מאוד. כדי לעשות זאת, השתמש ב- ספריית Ethernet. ספרייה זו מיועדת עבור א מגן Ethernet שמבוססת על המשולב W5100, אך ישנם לוחות או מודולים שונים אחרים ו/או המשתמשים בלוחות משולבים אחרים, כגון ENC28J60. כדי לפשט את השימוש בו ולהגביר את התאימות, ספריות אחרות משתמשות (כמעט) באותו API כי ספריית Ethernet, תצטרך רק להחליף את הספרייה החלופית במקורית או לכלול אותה (כאשר השם שונה) במקומה גם אם נעשה שימוש באותן פונקציות (או דומות מאוד) בקוד. במקרה שלי, אני משתמש ב- ספריית UIPEthernet de נורברט טרושס בעקבות אותו תהליך שאני הולך לתאר בטקסט הזה.
1. הגדר את חיבור האתרנט
בין אם אתה מתכוון לאמץ את התפקיד של לקוח כמו שרת, קודם כל יש להגדיר את הקשר עם הפונקציה התחל () שניתן להעביר כפרמטר רק את כתובת MAC ומחכה לשרת DHCP ברשת הקצה א כתובת IP ושאר התצורה או שאפשר גם לציין (אופציונלי) פרמטרים נוספים עד להגדרת התצורה המלאה:
- DIRECTION MAC (שכבר הוזכר)
- כתובת IP של המגן או המודול
- כתובת ה- IP של השרת DNS (שרת אחד בלבד)
- כתובת ה-IP של ה כְּנִיסָה
- מסכת רשת
רצוי לציין את כל הפרמטרים, אלא אם הניכוי שלהם הוא הרגיל, כדי למנוע שהתצורה לא נכונה (למשל שהשער אינו הכתובת הראשונה של הרשת).
מהאמור לעיל נראה כי ברור שיש להשתמש בנתונים המייצגים כתובות IP לעתים קרובות למדי, וזו הסיבה שהספרייה כוללת את המחלקה כתובת ה - IP שממנו ניתן ליצור אובייקטי כתובת IP. הפרמטרים המגדירים אותו הם ארבעת הבייטים של כתובת IPV4
La כתובת MAC הוא מוגדר עבור ספרייה זו כמערך של 6 בתים. כתובת ה-MAC היא (אמורה להיות) מזהה ייחודי שבו הבייטים הראשונים מציינים את היצרן והדגם והאחרונים מציינים את המכשיר הספציפי. המשולב ENC28J60 אינו כולל כתובת MAC אלא אם כן תבחר לרכוש גם א כתובת MAC משולבת מ-Microchip (או בלוק שלם כן של כתובות ל IEEE אם ריצת המכשירים גדולה מספיק כדי שזה יהיה כדאי). כאשר אין לך כתובת MAC, אתה יכול להמציא אחת, ולדאוג שהיא לא תתנגש עם אחרים ברשת שבה נמצא המכשיר.
אם התצורה נעשית עם שרת DHCP במקום "ביד", הפונקציה localIP() כדאי לעיין בכתובת שהשרת הקצה למודול. כדי לחדש את הכתובת שהוקצתה (אם פג הזמן המתאים), ספריית Ethernet מספק את הפונקציה לְתַחְזֵק() אשר גם יודיע על ידי החזרת קוד התואם למצב החידוש:
- הניתוח לא השפיע
-
שגיאה בחידוש כתובת ה-IP
לא ניתן היה להאריך את השימוש בכתובת ה-IP שהוקצתה באותו שרת - כתובת ה-IP חודשה בהצלחה
-
חיבור מחדש של כתובת IP נכשל
לא ניתן היה להרחיב את השימוש בכתובת ה-IP שהוקצתה באף שרת - כתובת ה-IP הוקצתה מחדש בהצלחה
עם המידע שנראה עד כה, אתה יכול לכתוב דוגמה כיצד יתבצע חיבור Ethernet על ידי הגדרת כתובת ה-IP דרך שרת DHCP ברשת. הקוד לדוגמה הבא מנסה לחדש את כתובת ה-IP בכל פרק זמן מסוים ומדווח על התוצאה.
|
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(“]”);
}
|
הדוגמה להלן מקצה את כתובת ה-IP ואת שאר התצורה באופן ידני באמצעות אובייקטים כתובת ה - IP כדי להפוך אותו לנוח יותר לקריאה ו(במקרה של קוד מורכב יותר) למנוע שגיאות שעלולות להתרחש אם הכתובת נכתבה (שגויה) בכל פעם שהיא הייתה בשימוש.
|
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. התחל את החיבור במצב לקוח או שרת
בעת הפעלת חיבור במצב שרת, המערכת המיקרו-מבוקרת היא שמפותחת שמקשיבה לבקשות ממערכות אחרות. כדי להתחיל את החיבור כשרת, השתמש EthernetServer() והיציאה בה השרת יקשיב מסומנת כפרמטר. EthernetServer() הוא הבנאי של המחלקה שרת, התומך בכל פעולות ה-Ethernet כשרת. למרות שהדבר האורתודוקסי ביותר הוא לבצע קריאה לבנאי EthernetServer(), זה לא נדיר למצוא כמה דוגמאות המשתמשות ישירות במחלקה שרת או ספריות חלופיות לחיבור Ethernet שבוחרות להשתמש באותה מערכת מופע.
החיבור כלקוח הוא זה שמגיש בקשות למערכת השרתים שמחכה להן ועונה להן בהתאם. כדי ליזום חיבור כלקוח, השתמש EthernetClient() מהו הקונסטרוקטור של המחלקה לקוח מקור כל פעולות ה-Ethernet כלקוח.
בניגוד למה שקורה עם מצב שרת, אשר מניחים לעבוד מרגע יצירת המחלקה (למרות שהוא יגיב ללקוחות רק אם הוא באמת כן), עליך לוודא שחיבור הלקוח מוכן לפני השימוש בו. ניתן לשאול את אובייקט הלקוח שנוצר בעת הפעלת החיבור כדי לראות אם הוא זמין. לדוגמה, ניתן לכלול פעולות שאילתה במבנה if(EthernetClient) לבצע אותם רק כאשר חיבור הלקוח זמין.
|
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. ליצור קשר כלקוח
כאמור, ברגע שנוצר החיבור, הלקוח הוא זה שנוטל את היוזמה לבצע את השאילתות. השרת ימתין ליוזמה זו ויגיב בהתאם. לכן, הלקוח הוא שמתחבר לשרת, לשם כך אנו משתמשים להתחבר () מציין את השרת כפרמטרים (כתובת ה-IP או ה כתובת האתר) פורטו במי שמקשיב.
בהתבסס על תוצאת הפעולה, הפונקציה תחזיר את הערכים
- () החיבור נוצר בהצלחה
- ביסוס הקשר
- () הזמן הקצוב חלף מבלי שנוצר חיבור
- () השרת לא נמצא או שהוא אינו מגיב כהלכה
- () החיבור הופסק לפני שנוצר במלואו
- () תגובת השרת שגויה
לפני שמתחילים לבצע שאילתות, יש צורך לוודא שהחיבור פועל עם הפונקציה מְחוּבָּר() שיחזור אם זה כבר זמין או אחרת.
הדוגמה למטה ממחישה את החיבור כלקוח, בודק כל 10 שניות כדי לראות אם יש חיבור לשרת (זה לא נועד להיות שום דבר פרודוקטיבי, רק כדי להראות את התחביר של הפונקציות) משהו שדרך אגב, שרת אינטרנט ייצור לא יאהב מאוד.
|
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. שלח נתונים
כמו שיעורים ידועים יותר, כגון סדרתי, ועם שימוש דומה, השיעורים לקוח y שרת יש את הפונקציות
-
o
שולח מידע באמצעות אובייקט הלקוח או השרת שממנו הוא מופעל. הפרמטר "נתונים" הוא יחיד בייט o char בעוד "חיץ" הוא מערך של בייט o char מתוכם נשלחת כמות השווה ל"אורך" פונקציה זו היא זו המשמשת לפעולות בינאריות, לעומת השתיים הבאות שמורות בדרך כלל לשליחת טקסט.
-
שולח כלקוח או שרת (בהתאם למחלקה ממנה נעשה שימוש) את המידע המתאים ל"נתונים" כטקסט. אם המידע אינו מבוטא כטקסט (לדוגמה, זהו מספר שלם) ניתן להשתמש בפרמטר האופציונלי "base" לבחירת ההמרה, שיכול להיות אחד מהקבועים BIN, OCT, DEC או HEX המציינים, בהתאמה. בסיסים התואמים לבינארי (בסיס 2), אוקטלי (בסיס 8), עשרוני (בסיס 10) והקסדצימלי (בסיס 16)
-
הפעולה זהה לקודמתה למעט שליחת, לאחר המידע המצוין במפורש על ידי פרמטר "נתונים", החזרת עגלה (קוד 13 שניתן לייצג כ-\r) וסוף שורה (קוד 10, שיכול להיות מיוצג על ידי \n) קודים אלה מופנים לעתים קרובות, בהתאמה, על ידי ראשי התיבות CR (Carriage Return) ו LF (הזנת קו)
שלוש הפונקציות הקודמות מחזירות את מספר הבתים שנשלחו, וכך גם הפונקציות המקבילות של המחלקה סדרתי; כאמור לעיל, הפעולה ניתנת להשוואה.
5. קבלת נתונים
כמו במקרה של פעולות שליחת נתונים, פעולות הקבלה דומות לאלו של הפעולות הנפוצות סדרתי. גם פרוטוקול הקבלה דומה: בדוק אם יש (מספיק) נתונים זמינים (זמין) ובמקרה כזה קרא אותם
-
מחזירה את מספר הבתים הזמינים לקריאה. פונקציה זו קיימת בשני המחלקות לקוח כמו שרת; במקרה הראשון, הוא מדווח על מספר הבתים שהשרת שלח בתגובה לבקשה ושזמין ללקוח לקרוא (לקרוא), ובמקרה השני הלקוח (האובייקט) שביצע פעולה או שקר אם אין.
-
הוא משמש לקריאת המידע שהתקבל. תכונה זו זמינה רק בכיתה לקוח. אם האפליקציה המפותחת ממלאת את תפקיד השרת, כדי לקרוא את המידע שהגיע, יש להפעיל אובייקט לקוח עם תגובת הפונקציה זמין () נדון בסעיף הקודם.
הדוגמה הבאה היא "שרת caps" שמאזין בפורט 2000 ומגיב לבקשות עם כל מה שנשלח בכל כובע כשאפשר. זה יכול להיבדק, למשל, עם מרק או פשוט עם זה בהחלט לא מאוד פרקטי, המטרה שלו היא רק להראות איך להשיג את הנתונים שנשלחים אליו על ידי לקוח מהשרת.
|
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. סיים את החיבור
אמנם מקובל שיישום שרת פועל ללא הגבלת זמן, אך חיבורי לקוח נוצרים, יוצרים חיבורים ומסתיימים, מה שמאפשר לשחזר משאבים ולהשתמש בהם בחיבורים אחרים או מוקדש לשימושים אחרים של התוכנית. הפונקציה תפסיק() של הכיתה לקוח הוא משמש כדי לסיים חיבור לקוח ולשחרר כל משאבים שהוא משתמש בו.
עבור השרת, העובדה שהלקוח מפסיק את החיבור כאשר אובייקט המידע של השאילתה נשלח או התקבל מאפשרת לו גם לפנות משאבים להקצאתם לחיבורים אחרים או למטרות שונות. בקיצור, למרות שזה נראה מינורי, רצוי לסיים את החיבור עם סיום הפעילות של הלקוח.
מנהג טוב נוסף בעת סיום חיבור לקוח הוא לרוקן את שהכיתה משתמשת בהם. לשם כך, הפונקציה זמינה סומק() יש לקרוא לאחר סיום חיבור הלקוח עם תפסיק()
דוגמה לשאילתת HTTP GET
כדי להבהיר טוב יותר את כל האמור לעיל, דוגמה מלאה יותר של בקשות כלולה להלן. TCP באמצעות בקשות GET באמצעות פרוטוקול HTTP. בדוגמה, הערכים המתקבלים על ידי חיישנים אנלוגיים המחוברים ללוח Arduino נשלחים לשרת אינטרנט המאחסן אותם במסד נתונים.
|
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;
}
}
}
|
לפרסם תגובה