Ethernet TCP-anslutning med Arduino
Ur mjukvarusynpunkt, upprätta en anslutning ethernet med Arduino Det är väldigt enkelt. För att göra detta, använd Ethernet-bibliotek. Detta bibliotek är designat för en Ethernet Shield som bygger på det integrerade W5100, men det finns andra olika kort eller moduler och/eller som använder andra integrerade, till exempel ENC28J60. För att förenkla användningen och öka kompatibiliteten använder andra bibliotek (nästan) samma sak API att Ethernet-bibliotek, du behöver bara ersätta det alternativa biblioteket med det ursprungliga eller inkludera det (när namnet är annorlunda) i dess ställe även om samma (eller mycket liknande) funktioner används i koden. I mitt fall använder jag UIPEthernet-bibliotek de Norbert Truchsess efter samma process som jag kommer att beskriva i den här texten.
1. Definiera Ethernet-anslutningen
Oavsett om du ska anta rollen som kund som den av server, först och främst måste du definiera kopplingen till funktionen Börja () som endast kan skickas som en parameter MAC-adress och vänta på en server DHCP- på nätverket tilldela en IP-adress och resten av konfigurationen eller så är det också möjligt att ange (valfritt) fler parametrar tills den fullständiga konfigurationen är definierad:
- Dirección MAC (vilket redan har nämnts)
- IP-adress av skölden eller modulen
- Server IP-adress DNS (endast en server)
- IP-adressen till Inkörsport
- nätmask
Det är tillrådligt att ange alla parametrar, såvida deras avdrag inte är den vanliga, för att undvika att konfigurationen inte är korrekt (till exempel att gatewayen inte är den första adressen till nätverket).
Av ovanstående tycks det vara tydligt att data som representerar IP-adresser måste användas ganska ofta, varför biblioteket inkluderar klassen IP-adress varifrån IP-adressobjekt kan instansieras. Parametrarna som definierar det är de fyra byten av en adress IPV4
La MAC-adress Det är definierat för detta bibliotek som en 6-byte array. MAC-adressen är (förmodas vara) en unik identifierare där de första byten indikerar tillverkare och modell och de sista indikerar den specifika enheten. Den integrerade ENC28J60 inkluderar inte en MAC-adress om du inte väljer att också köpa en Integrerad MAC-adress från Microchip (eller ett helt block ja av adresser till IEEE om antalet enheter är tillräckligt stort för att göra det värt besväret). När du inte har en MAC-adress kan du uppfinna en och se till att den inte kommer i konflikt med andra på nätverket där enheten är placerad.
Om konfigurationen görs med en DHCP-server istället för "för hand", funktionen localIP() Det är användbart att konsultera adressen som servern har tilldelat modulen. För att förnya den tilldelade adressen (om motsvarande tid har löpt ut) Ethernet-bibliotek tillhandahåller funktionen upprätthålla() som också kommer att informera genom att returnera en kod som motsvarar statusen för förnyelsen:
- Operationen har inte haft någon effekt
-
Fel vid förnyelse av IP-adress
Användningen av den tilldelade IP-adressen på samma server kunde inte utökas - IP-adressen har förnyats
-
Ombindningen av IP-adressen misslyckades
Användningen av den tilldelade IP-adressen kunde inte utökas på någon server - IP-adressen har omtilldelats
Med den information som vi sett hittills kan du skriva ett exempel på hur en Ethernet-anslutning skulle initieras genom att konfigurera IP-adressen via en DHCP-server i nätverket. Följande exempelkod försöker förnya IP-adressen varje viss tidsperiod och rapporterar resultatet.
|
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(“]”);
}
|
Exemplet nedan tilldelar IP-adressen och resten av konfigurationen manuellt med hjälp av objekt IP-adress för att göra det bekvämare att läsa och (vid mer komplex kod) för att undvika fel som kan uppstå om adressen (fel)skrivs varje gång den användes.
|
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. Starta anslutningen i klient- eller serverläge
Vid initiering av en anslutning i serverläge är det det mikrokontrollerade systemet som utvecklas som lyssnar på förfrågningar från andra system. För att starta anslutningen som en server, använd EthernetServer() och porten som servern kommer att lyssna på anges som en parameter. EthernetServer() är klassens konstruktör server, som stöder alla Ethernet-operationer som en server. Även om det mest ortodoxa är att ringa konstruktören EthernetServer(), är det inte ovanligt att hitta några exempel som direkt använder klassen server eller alternativa bibliotek för Ethernet-anslutning som väljer att använda det instansieringssystemet.
Anslutningen som klient är den som gör förfrågningar till serversystemet, som väntar på dem och svarar på dem därefter. För att initiera en anslutning som klient, använd EthernetClient() vad är konstruktören av klassen Klient ursprunget för alla Ethernet-operationer som klient.
Till skillnad från vad som händer med serverläge, som antas fungera från det ögonblick klassen instansieras (även om den bara svarar på klienter om den verkligen är det), måste du verifiera att klientanslutningen är klar innan du använder den. Klientobjektet som skapas när anslutningen initieras kan frågas för att se om det är tillgängligt. Till exempel kan frågeoperationer inkluderas i en struktur if(EthernetClient) att köra dem endast när klientanslutningen är tillgänglig.
|
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. Upprätta en koppling som klient
Som sagt, när anslutningen väl har skapats är det kunden som tar initiativet till att göra förfrågningarna. Servern kommer att vänta på det initiativet och kommer att svara därefter. Det är därför klienten som ansluter till servern som vi använder för att göra det ansluta() anger servern som parametrar (IP-adressen eller URL) och port hos den som lyssnar.
Baserat på resultatet av operationen kommer funktionen att returnera värdena
- () Anslutningen har upprättats
- Att upprätta kopplingen
- () Timeout har passerat utan att anslutning har upprättats
- () Servern hittades inte eller svarar inte korrekt
- () Anslutningen avbröts innan den upprättades helt
- () Serverns svar är felaktigt
Innan du börjar göra frågor är det nödvändigt att verifiera att anslutningen fungerar med funktionen ansluten() som kommer tillbaka om den redan är tillgänglig eller annat.
Exemplet nedan illustrerar anslutningen som en klient, kontrollerar var 10:e sekund för att se om det finns en anslutning till servern (det är inte tänkt att vara något produktivt, bara för att visa syntaxen för funktionerna) något som förresten, en produktionswebbserver skulle inte gilla så mycket.
|
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. Skicka data
Som andra mer kända klasser, som t.ex Serial, och med jämförbar användning, klasserna Klient y server har funktionerna
-
o
Skickar information med hjälp av klient- eller serverobjektet från vilket det anropas. Parametern "data" är en singel bitgrupp o röding medan "buffert" är en uppsättning av bitgrupp o röding varav ett belopp lika med "längd" skickas. Denna funktion är den som används för binära operationer, jämfört med de kommande två som vanligtvis är reserverade för att skicka text.
-
Skickar som en klient eller server (beroende på vilken klass den används från) informationen som motsvarar "data" som text. Om informationen inte uttrycks som text (det är till exempel ett heltal) kan den valfria parametern "bas" användas för att välja konverteringen, som kan vara en av konstanterna BIN, OCT, DEC eller HEX som anger respektive. baser som motsvarar binär (bas 2), oktal (bas 8), decimal (bas 10) och hexadecimal (bas 16)
-
Operationen är identisk med den föregående förutom att skicka, efter informationen som uttryckligen anges av parametern "data", en vagnretur (kod 13 som kan representeras som \r) och en radslut (kod 10, som kan vara representeras av \n) Dessa koder refereras ofta till med respektive akronym CR (Carriage Return) och LF (linjematning)
De tre föregående funktionerna returnerar antalet byte som har skickats, liksom motsvarande funktioner i klassen Serial; Som sagt ovan är operationen jämförbar.
5. Ta emot data
Liksom i fallet med datasändningsoperationer är mottagningsoperationerna jämförbara med dem som används i stor utsträckning Serial. Mottagningsprotokollet är också liknande: kontrollera om det finns (tillräckligt med) data tillgänglig (tillgänglig) och i så fall läs dem
-
Returnerar antalet byte som är tillgängliga att läsa. Denna funktion finns i båda klasserna Klient som server; I det första fallet rapporterar den antalet byte som servern har skickat som svar på en begäran och som är tillgängliga för klienten att läsa (läsa), och i det andra fallet klienten (objektet) som har utfört en operation eller falsk om det inte finns någon.
-
Den används för att läsa informationen som har mottagits. Den här funktionen är endast tillgänglig i klassen Klient. Om applikationen som utvecklas uppfyller rollen som server måste ett klientobjekt instansieras med funktionssvaret för att kunna läsa den information som har kommit tillgängligt () diskuterades i föregående avsnitt.
Följande exempel är en "caps-server" som lyssnar på port 2000 och svarar på förfrågningar med allt som skickats i alla storlekar när det är möjligt. Den kan testas till exempel med PuTTY eller helt enkelt med Det är verkligen inte särskilt praktiskt, dess syfte är bara att visa hur man skaffar data som skickas till den av en klient från servern.
|
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. Avsluta anslutningen
Även om det är vanligt att en serverapplikation körs på obestämd tid, upprättas klientanslutningar, upprättar anslutningar och avslutas, vilket gör att resurser kan återställas och användas i andra anslutningar eller dedikeras till annan användning av programmet. Funktionen sluta() av klassen Klient Den används för att avsluta en klientanslutning och frigöra alla resurser som den använder.
För servern gör det faktum att klienten avslutar anslutningen när informationsobjektet för frågan har skickats eller tagits emot också att den frigör resurser för att allokera dem till andra anslutningar eller andra ändamål. Kort sagt, även om det verkar mindre, är det lämpligt att avsluta anslutningen när klientens verksamhet avslutas.
En annan bra praxis när du avslutar en klientanslutning är att tömma som klassen använder. För att göra detta är funktionen tillgänglig spola() ska anropas efter avslutad klientförbindelse med sluta()
Exempel på HTTP GET-fråga
För att bättre förtydliga allt ovan finns ett mer komplett exempel på förfrågningar nedan. TCP använda GET-förfrågningar med hjälp av HTTP-protokoll. I exemplet skickas värdena som erhålls av analoga sensorer anslutna till ett Arduino-kort till en webbserver som lagrar dem i en databas.
|
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 kommentar