Connexion Ethernet TCP avec Arduino
D'un point de vue logiciel, établir une connexion Ethernet avec Arduino c'est très simple. Pour ce faire, utilisez le Bibliothèque Ethernet. Cette bibliothèque est conçue pour un Bouclier Ethernet qui est basé sur l'intégration W5100, mais il existe d'autres cartes ou modules différents et/ou qui en utilisent d'autres intégrés, comme le ENC28J60. Pour simplifier son utilisation et augmenter la compatibilité, d'autres bibliothèques utilisent (presque) la même chose API que Bibliothèque Ethernet, vous n'aurez qu'à remplacer la bibliothèque alternative par celle d'origine ou à l'inclure (lorsque le nom est différent) à sa place même si des fonctions identiques (ou très similaires) sont utilisées dans le code. Dans mon cas, j'utilise le Bibliothèque UIP Ethernet de Norbert Truchsess en suivant le même processus que je vais décrire dans ce texte.
1. Définir la connexion Ethernet
Si vous allez adopter le rôle de client tel que serveur, il faut tout d'abord définir la connexion avec la fonction commencer () qui ne peut être passé en paramètre que le Adresse MAC et j'attends un serveur DHCP sur le réseau, attribuez un Adresse IP et le reste de la configuration ou il est également possible d'indiquer (optionnellement) plus de paramètres jusqu'à ce que la configuration complète soit définie :
- Adresse MAC (ce qui a déjà été évoqué)
- Adresse IP du blindage ou du module
- Adresse IP du serveur DNS (un seul serveur)
- Adresse IP du passerelle
- Masque net
Il est conseillé d'indiquer tous les paramètres, sauf si leur déduction est habituelle, pour éviter que la configuration ne soit pas correcte (par exemple, que la passerelle ne soit pas la première adresse du réseau).
D'après ce qui précède, il semble clair que les données représentant les adresses IP doivent être utilisées assez souvent, c'est pourquoi la bibliothèque inclut la classe Adresse IP à partir duquel instancier les objets d’adresse IP. Les paramètres qui le définissent sont les quatre octets d'une adresse IPV4
La Adresse MAC Il est défini pour cette bibliothèque comme un tableau de 6 octets. L'adresse MAC est (censée être) un identifiant unique dans lequel les premiers octets indiquent le fabricant et le modèle et les derniers indiquent l'appareil spécifique. L'intégré ENC28J60 n'inclut pas d'adresse MAC, sauf si vous choisissez d'acheter également un Adresse MAC intégrée de Microchip (ou un bloc entier OUI d'adresses à IEEE si le nombre d'appareils est suffisamment important pour que cela en vaille la peine). Lorsque vous n'avez pas d'adresse MAC, vous pouvez en inventer une, en veillant à ce qu'elle n'entre pas en conflit avec d'autres sur le réseau où se trouve l'appareil.
Si la configuration est faite avec un serveur DHCP au lieu de "à la main", la fonction adresse IP locale() Il est utile de consulter l'adresse que le serveur a attribuée au module. Pour renouveler l'adresse attribuée (si le délai correspondant est expiré), le Bibliothèque Ethernet assure la fonction maintenir() qui informera également en renvoyant un code qui correspond à l'état du renouvellement :
- L'opération n'a eu aucun effet
-
Erreur lors du renouvellement de l'adresse IP
L'utilisation de l'adresse IP attribuée sur le même serveur n'a pas pu être étendue - Adresse IP renouvelée avec succès
-
Échec de la réassociation de l'adresse IP
L'utilisation de l'adresse IP attribuée n'a pu être étendue sur aucun serveur - Adresse IP réattribuée avec succès
Avec les informations vues jusqu'à présent, vous pouvez écrire un exemple de la façon dont une connexion Ethernet serait initiée en configurant l'adresse IP via un serveur DHCP sur le réseau. L'exemple de code suivant tente de renouveler l'adresse IP à intervalles réguliers et rapporte le résultat.
|
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(“]”);
}
|
L'exemple ci-dessous attribue l'adresse IP et le reste de la configuration manuellement à l'aide d'objets Adresse IP pour le rendre plus confortable à lire et (dans le cas d'un code plus complexe) pour éviter les erreurs qui pourraient survenir si l'adresse était (mal) écrite à chaque utilisation.
|
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. Démarrez la connexion en mode client ou serveur
Lors de l'initiation d'une connexion en mode serveur, c'est le système microcontrôlé en cours de développement qui écoute les requêtes des autres systèmes. Pour démarrer la connexion en tant que serveur, utilisez ServeurEthernet() et le port sur lequel le serveur va écouter est indiqué en paramètre. ServeurEthernet() est le constructeur de la classe Server, qui prend en charge toutes les opérations Ethernet en tant que serveur. Bien que le plus orthodoxe soit d'appeler le constructeur ServeurEthernet(), il n'est pas rare de trouver quelques exemples utilisant directement la classe Server ou des bibliothèques alternatives pour la connexion Ethernet qui choisissent d'utiliser ce système d'instanciation.
La connexion en tant que client est celle qui fait des requêtes au système serveur, qui les attend et y répond en conséquence. Pour établir une connexion en tant que client, utilisez ClientEthernet() quel est le constructeur de la classe Client origine de toutes les opérations Ethernet en tant que client.
Contrairement à ce qui se passe avec le mode serveur, qui est supposé fonctionner à partir du moment où la classe est instanciée (même si elle ne répondra aux clients que si c'est réellement le cas), vous devez vérifier que la connexion client est prête avant de l'utiliser. L'objet client créé lors de l'établissement de la connexion peut être interrogé pour voir s'il est disponible. Par exemple, les opérations de requête peuvent être incluses dans une structure si (EthernetClient) pour les exécuter uniquement lorsque la connexion client est disponible.
|
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. Établissez une connexion en tant que client
Comme cela a été dit, une fois la connexion créée, c'est le client qui prend l'initiative de faire les requêtes. Le serveur attendra cette initiative et répondra en conséquence. C'est donc le client qui se connecte au serveur, pour cela on utilise relier () indiquant le serveur en paramètres (l'adresse IP ou le URL) Et l' puerto chez celui qui écoute.
En fonction du résultat de l'opération, la fonction renverra les valeurs
- () Connexion établie avec succès
- Établir la connexion
- () Le délai d'attente est écoulé sans que la connexion soit établie
- () Le serveur n'a pas été trouvé ou ne répond pas correctement
- () La connexion a été interrompue avant d'être complètement établie
- () La réponse du serveur est incorrecte
Avant de commencer à faire des requêtes, il faut vérifier que la connexion est opérationnelle avec la fonction connecté() ça reviendra s'il est déjà disponible ou autrement.
L'exemple ci-dessous illustre la connexion en tant que client, vérifiant toutes les 10 secondes s'il y a une connexion au serveur (cela n'est pas destiné à être productif, juste pour montrer la syntaxe des fonctions), ce qui, d'ailleurs, un serveur Web de production n'aimerait pas grand-chose.
|
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. Envoyer des données
Comme d'autres classes plus connues, comme Port série, et avec une utilisation comparable, les classes Client y Server avoir les fonctions
-
o
Envoie des informations à l'aide de l'objet client ou serveur à partir duquel elles sont invoquées. Le paramètre "data" est un seul octet o carboniser tandis que "buffer" est un tableau de octet o carboniser dont un montant égal à "longueur" est envoyé. Cette fonction est celle utilisée pour les opérations binaires, par rapport aux deux suivantes qui sont habituellement réservées à l'envoi de texte.
-
Envoie en client ou serveur (selon la classe à partir de laquelle il est utilisé) les informations correspondant aux "données" sous forme de texte. Si l'information n'est pas exprimée sous forme de texte (par exemple s'il s'agit d'un nombre entier), le paramètre facultatif "base" peut être utilisé pour choisir la conversion, qui pourrait être l'une des constantes BIN, OCT, DEC ou HEX qui indiquent respectivement. bases correspondant aux binaires (base 2), octales (base 8), décimales (base 10) et hexadécimales (base 16)
-
Le fonctionnement est identique au précédent sauf l'envoi, après l'information expressément indiquée par le paramètre "data", d'un retour chariot (code 13 qui peut être représenté par \r) et d'une fin de ligne (code 10, qui peut être représenté par \n) Ces codes sont fréquemment désignés respectivement par l'acronyme CR (retour chariot) et LF (saut de ligne)
Les trois fonctions précédentes renvoient le nombre d'octets envoyés, tout comme les fonctions équivalentes de la classe Port série; Comme dit plus haut, le fonctionnement est comparable.
5. Recevoir des données
Comme dans le cas des opérations d'envoi de données, les opérations de réception sont comparables à celles des opérations largement utilisées. Port série. Le protocole de réception est également similaire : vérifiez s'il y a (suffisamment) de données disponibles (disponibles) et dans ce cas lisez-les
-
Renvoie le nombre d'octets disponibles pour la lecture. Cette fonction est présente dans les deux classes Client comme Server; Dans le premier cas, il indique le nombre d'octets que le serveur a envoyés en réponse à une requête et qui sont disponibles pour que le client puisse les lire (lire), et dans le second cas le client (objet) qui a effectué une opération ou false s'il n'y en a pas.
-
Il est utilisé pour lire les informations reçues. Cette fonctionnalité est uniquement disponible en classe Client. Si l'application en cours de développement remplit le rôle de serveur, pour lire les informations arrivées, il faut instancier un objet client avec la réponse de la fonction disponible () discuté dans la section précédente.
L'exemple suivant est un "serveur majuscules" qui écoute sur le port 2000 et répond aux requêtes avec tout ce qui a été envoyé en majuscules lorsque cela est possible. On peut le tester par exemple avec PuTTY ou simplement avec Ce n'est certes pas très pratique, son but est uniquement de montrer comment obtenir depuis le serveur les données que lui envoie un client.
|
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. Terminez la connexion
Bien qu'il soit habituel qu'une application serveur fonctionne indéfiniment, les connexions client sont établies, établissent des connexions et se terminent, permettant aux ressources d'être récupérées et utilisées dans d'autres connexions ou dédiées à d'autres utilisations du programme. La fonction Arrêtez() de la classe Client Il est utilisé pour mettre fin à une connexion client et libérer toutes les ressources qu'il utilise.
Pour le serveur, le fait que le client termine la connexion lorsque l'objet informationnel de la requête a été envoyé ou reçu lui permet également de libérer des ressources pour les allouer à d'autres connexions ou à des fins différentes. Bref, même si cela semble mineur, il est conseillé de mettre fin à la connexion à la fin des opérations du client.
Une autre bonne pratique lors de la fin d'une connexion client consiste à vider le que la classe utilise. Pour ce faire, la fonction est disponible flush () doit être appelé après avoir terminé la connexion client avec Arrêtez()
Exemple de requête HTTP GET
Pour mieux clarifier tout ce qui précède, un exemple plus complet de demandes est inclus ci-dessous. TCP en utilisant les requêtes GET en utilisant le Protocole HTTP. Dans l'exemple, les valeurs obtenues par des capteurs analogiques connectés à une carte Arduino sont envoyées à un serveur web qui les stocke dans une base de données.
|
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;
}
}
}
|
Poster un commentaire