Previous Contents Next

2   Connexion de l'objet au réseau

Le but de cet exercice est de réaliser un réseau local entre un PC et un Arduino.

2.1   Interface Ethernet virtuelle

Pour que votre prototype de réseau local soit facilement utilisable une interface Ethernet virtuelle va être créée sur le PC. Vos programmes peuvent créer ces interfaces en utilisant les fonctions C ci-dessous. 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <linux/if.h>
#include <linux/if_tun.h>

#define TAP_PRINCIPAL  "/dev/net/tun"
#define INTERFACE_VIRTUELLE "tap0"

int creationInterfaceVirtuelle(char *nom)
{
struct ifreq interface;
int fd,erreur;
/* Ouverture du peripherique principal */
if((fd=open(TAP_PRINCIPAL,O_RDWR))<0) return fd;
bzero(&interface,sizeof interface);
interface.ifr_flags=IFF_TAP|IFF_NO_PI|IFF_MULTI_QUEUE;
strncpy(interface.ifr_name,nom,IFNAMSIZ);
if((erreur=ioctl(fd,TUNSETIFF,(void *)&interface))<0)
  { close(fd); perror("creationInterfaceVirtuelle.ioctl"); exit(EXIT_FAILURE); }
return fd;
}

void fermetureInterfaceVirtuelle(int fd){ close(fd); }
Ecrivez un programme de test pour lire les paquets arrivant sur l'interface virtuelle à l'aide de la primitive read. Une fois les paquets lus, affichez les sur la sortie standard (octet par octet en hexa-décimal sur deux chiffres avec des espaces comme séparateurs). Lancez votre programme et dans un autre terminal utilisez la commande ifconfig pour affecter une adresse IPv4 à l'interface virtuelle tap0. Vérifiez que la configuration de tap0 provoque un affichage de paquets par votre programme de test.

2.2   Liaison série

. L'échange d'information se fera par liaison série. Pour gérer le port série vous pouvez utiliser le code donné ci-après. 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <strings.h>
#include <fcntl.h>
#include <termios.h>

#define PORT_SERIE "/dev/ttyUSB0"
#define VITESSE_SERIE B9600

static struct termios serie_sauve;

int ouvertureSerie(char *peripherique,int vitesse){
struct termios nouveau;
int fd=open(peripherique,O_RDWR|O_NOCTTY);
if(fd<0){perror(peripherique); exit(-1);}
tcgetattr(fd,&serie_sauve);
bzero(&nouveau,sizeof(nouveau));
nouveau.c_cflag=CLOCAL|CREAD|vitesse|CS8;
nouveau.c_iflag=0;
nouveau.c_oflag=0;
nouveau.c_lflag=0;
nouveau.c_cc[VTIME]=0;
nouveau.c_cc[VMIN]=1;
tcflush(fd,TCIFLUSH);
if(tcsetattr(fd,TCSANOW,&nouveau)<0)
  { close(fd); perror("serialInit.tcsetattr"); exit(EXIT_FAILURE); }
return fd;
}

void fermetureSerie(int fd){ tcsetattr(fd,TCSANOW,&serie_sauve); close(fd); }
Ecrivez deux programmes de test. Le premier ouvre le port série et écrit un message, en utilisant la primitive write, sur le port série toutes les 15 secondes. Le second programme lit sur le port série en utilisant la primitive read et affiche les caractères reçus sur la sortie standard. Lancez vos deux programmes de test sur deux machines connectés par un câble série croisé.

2.3   Programme "interface vers série"

Vous avez maintenant tout ce qu'il faut pour écrire le programme qui va transmettre vers le port série les paquets reçus sur l'interface virtuelle. Vous allez ainsi transmettre les paquets générés par la pile TCP/IP de votre machine de TP par une liaison série. Pour que le destinataire puisse savoir où commence et où finit le paquet vous allez utiliser le protocole SLIP. Ce protocole consiste à ajouter le caractère 0xc0 en fin de paquet. Si ce caractère est présent dans le paquet lui-même, il est remplacé par les deux caractères 0xdb et 0xdc. Si le caractère d'échappement 0xdb est présent dans le paquet il est remplacé par les deux caractères 0xdb et 0xdd.

2.4   Programme "série vers interface"

Ecrivez ensuite le programme qui lit une suite d'octets sur le port série pour les envoyer, en tant que paquet, sur l'interface virtuelle. Il vous suffit de lire les caractères jusqu'à tomber sur le caractère final 0xc0. Par ailleurs il faut que ce programme puisse envoyer des paquets sur l'interface virtuelle sans que des paquets provenant de l'interface virtuelle lui soient communiqués. Sinon ces paquets ne pourraient pas être lus par le programme "interface vers série". Une solution consiste à "détacher" l'interface virtuelle juste après son ouverture en utilisant le code ci-après. 
void detacheInterfaceVirtuelle(int fd){
struct ifreq ifr;
bzero(&ifr,sizeof ifr);
ifr.ifr_flags=IFF_DETACH_QUEUE;
if(ioctl(fd,TUNSETQUEUE,&ifr)<0)
  { close(fd); perror("detacheInterfaceVirtuelle.ioctl"); exit(EXIT_FAILURE); }
}

2.5   Test de votre réseau local

Connectez deux PC par un câble série croisé. Lancez vos deux programmes sur chaque PC. Configurez les interfaces tap0 des deux PC avec des adresses IPv4 différentes mais appartenant au même réseau IP. D'un PC tentez de vérifier la connexion en utilisant la commande ping sur l'adresse de l'autre PC. Quand cela fonctionne montez la vitesse de la liaison série à B115200 et tentez une connexion par ssh. Déconfigurez les interfaces eth0 avec l'utilitaire ifdown pour vérifier que le réseau utilisé est bien le votre.

Previous Contents Next