TP 1

Présentation du sujet

Il s'agit de simuler le déroulement d'un processus industriel dont voici le schéma.:

Sur le convoyeur vont circuler des pièces qui seront transformées par les différents automates:

L'automate 1 est informé de la présence d'une pièce par l'opérateur. Il prend la pièce et lui fait subir une première modification. Lorsque la modification est effectuée, il pose sa pièce sur le convoyeur, et informe l'automate 2 qu'une pièce est disponible pour lui sur le convoyeur.
L'automate 2, grâce à l'information communiquée par l'automate 1, prend la pièce, lui fait subir sa seconde transformation , la redépose sur le convoyeur et informe l'automate 3.
L'automate 3, grâce à l'information communiquée par l'automate 2, prend la pièce, lui fait subir sa troisième transformation et informe l'opérateur à la fin de l'opération.

A chaque arrivée et départ de pièce sur un automate, ce dernier enverra un message au poste de supervision. Le poste de supervision stockera ces messages sur disque pour un éventuel traitement ultérieur (statistiques, ...)

Informations techniques

Les automates pourraient être dans la réalité des automates programmables ou des machines spécifiques. Il faut cependant qu'ils soient reliés à un réseau local avec le poste de supervision. Nous supposerons que le protocole réseau est TCP/IP.

Simulation Informatique

Chaque automate, ainsi que le poste de supervision, sera simulé par un processus sur une machine UNIX. Pour des questions de disponibilité des machines, tous les processus fonctionneront sur la même machine, cependant avec les techniques que nous allons mettre en œuvre, les différents processus pourraient s'exécuter sur des machines différentes (à condition que ces machines soient reliées par un réseau utilisant TCP/IP).

Glossaire

Ce glossaire se veut simple, il a simplement pour but de définir rapidement les quelques termes qui apparaissent dans ce document. Ces termes, seront revus et détaillés durant les cours.

Network (Réseau)

Ensemble de machines interconnectées de manière à échanger des informations. On distingue plusieurs types de réseaux en fonctions de leur taille, de leur importance géographique (LAN, WAN, MAN,...). En fonction du contexte, le terme réseau pourra désigner le câblage ou, le câblage et le(s) protocole(s) utilisé(s) pour l'interconnexion.

LAN:

(Local Area Network) réseau local . Un LAN est un réseau situé généralement dans la même entité géographique (entreprise, campus,...). Des LAN peuvent être interconnectés pour former des réseaux plus grands (WAN, MAN,...). On dit alors que le LAN est un sous-réseau du réseau auquel il est connecté.

WAN

(Wide Area Network) réseau grande distance. Un WAN est un réseau qui se mesure sur une grande échelle géographique. Certaines sociétés, généralement internationales (IBM, UNISYS, AT&T, AIR France, ...) disposent souvent de tels réseaux à l'échelle planétaire. Internet est un réseau de type WAN.

MAN

(Metropolitan Area Network) Ce type de réseaux est récent et garde les avantages des LAN sur de plus longues distances de l'ordre de la ville.

OSI

(Open Systems Interconnection) modèle de référence pour l'interconnexion des systèmes ouverts. Le modèle OSI est un modèle à sept couches, proposé par l'ISO, qui permet de représenter toutes les choses qu'un réseau doit gérer.

ISO

(International Standardization Organisation) Organisation internationale de normalisation

TCP/IP

(Transfert Control Protocol /Internet Protocol)TCP/IP est un nom de famille de protocoles. TCP et IP sont deux protocoles de cette famille, mais ne sont pas les seuls (UDP, ICMP, IGP,...). Lorsque l'on parle de "TCP/IP" on parle de la famille des protocoles TCP/IP en général, et pas des protocoles TCP et IP en particulier.

Matériels actifs

Ensemble d'appareils dont le but est d'intervenir sur un réseau afin de le connecté à un autre ou d'en améliorer sa qualité.

Adressage

Technique qui permet d'identifier une machine particulière sur un réseau.

Routage

Méthode et protocoles qui permettent de trouver un chemin pour échanger des informations entre machines sur un réseau.

Client/Serveur

Méthode de programmation qui permet de structurer des applications qui échangent des informations entre plusieurs machines et/ou processus.

Protocole

Ensemble de règles qui régissent un échange d'informations. Un réseau pour son bon fonctionnement, suppose que les machines qui vont échanger des informations ont des règles communes sur la manière de dialoguer. Un réseau est généralement régi par plusieurs protocoles (protocoles de hauts niveaux, protocoles de bas niveaux ,...).

Tp2

Présentation

Dans ce TP nous allons nous familiariser avec le matériel étudier les différentes primitives que nous allons utilisées dans la simulation.

Environnement de travail

L'environnement est constitué de Terminaux X sur le réseau local (Ethernet 10B2 voir cours). Sur ce réseau local on trouve une machine SUN: Sparc 20 fonctionnant sous Unix.
Un terminal X est un terminal intelligent qui communique avec la machine en utilisant le protocole X Window. Ce terminal est intelligent car il dispose de mémoire et d'un processeur. L'utilisation du processeur du terminal soulage celui (ou ceux) de la machine.
La machine Unix est souvent appelée Serveur.
Le terminal dans la terminologie X Window est appelé serveur d'affichage (il attend des ordres venant de la machine). Les clients de ce serveur sont les applications que l'on exécute sur la machine. La machine joue donc également le rôle de serveur d'application ou de fichiers.

But du TP

Etudier la syntaxe des différentes primitives nécessaires à l'écriture d'un client et d'un serveur TCP/IP.

Primitives utilisées

gethostbyname
getservbyname
socket
bind
listen
accept
connect

Ossature des programmes

Serveur

Voici la marche à suivre pour un serveur

Demander un socket
Demander au système de rediriger les données qui pourraient arrivées sur le port vers notre programmes.
Attendre une connexion.
Accepter (ou refuser) la connexion.
Répondre

Client

Voici la marche à suivre pour un client

Demander un socket
Se connecter au serveur
Communiquer.

Travail demandé

A l'aide du manuel, repérer les "include" nécessaire au fonctionnement des différentes primitives.
Etudier les paramètres des différentes primitives.
Réaliser l'écriture d'un serveur qui affiche une chaîne de caractères émise par le client.
Réaliser l'écriture d'un client qui envoie une chaîne de caractères au serveur.

Corrigés

Serveur

/*************************************************/
/* BP le 22/02/1997                              */
/* Programme qui recoit un message sur un socket */
/* Ossature d'un serveur ...                     */
/*************************************************/
/* Fichiers a inclures .... */
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>

/* Constantes */
	/* Message envoye au serveur */
#define TAILLEMAX 100 /* Pour chaine de caracteres */


/* Prototypages */
int main(int argc, char ** argv);

int main(int argc, char ** argv)
{
int Fd; /* Descripteur de fichier (socket) */
int FdAccept; /* Descripteur de fichier (socket) */
struct sockaddr_in Sockaddr; /* Descriptif d'un socket */
struct hostent * Machine; /* Machine ou reside le serveur */
struct servent * Service; /* Service (ou port) ou le serveur est attache */
char Message[TAILLEMAX +1];
int Lenght;

/* Verifier l'appel */
if (argc != 2)
	{
	fprintf(stderr,"Syntaxe : %s Port...\n",argv[0]);
	exit (-10);
	}

/* le serveur est sur la machine ou on lance le programme */
Machine = gethostbyname("localhost");
if (Machine == NULL)
	{
	perror("Serveur : gethostbyname");
	exit(-1);
	}
/* initialisation de la structure */
memset(&Sockaddr,0,sizeof(struct sockaddr_in));
/* on travaille sur TCP/IP */
Sockaddr.sin_family = PF_INET;
memcpy(&(Sockaddr.sin_addr),Machine->h_addr,Machine->h_length);

/* on ecoute sur quel port ???? */
Service = getservbyname(argv[1],"tcp");
if (Service == NULL)
	{
	perror("Serveur : getservbyname");
	exit(-2);
	}
Sockaddr.sin_port = Service->s_port;

/* On peut avoir le socket */
/* PF_INET => socket tcp/ip */
/* SOCK_STREAM => tcp comme protocol */
/* 0 => protocole par defaut sur tcp */
Fd = socket(PF_INET,SOCK_STREAM,0);
if (Fd == -1)
	{
	perror("Serveur : socket");
	exit(-3);
	}

/* reserver le port sur lequel on veut ecouter */
if (bind(Fd,(struct sockaddr *) & Sockaddr,sizeof(struct sockaddr_in)) == -1)
	{
	perror("Serveur : bind");
	exit (-4);
	}

/* on attend au maximum une connection a la fois */
if (listen(Fd,1) == -1)
	{
	perror("Serveur : listen");
	exit (-5);
	}
Ignorer
/* on accepte la connexion */
Lenght = sizeof(struct sockaddr_in);
if ((FdAccept = accept(Fd,(struct sockaddr *) &Sockaddr, &Lenght)) == -1)
	{
	perror("Serveur : accept");
	exit (-6);
	}

/* on tente la lecture du message */
read(FdAccept,Message,TAILLEMAX);
printf("On a recu : %s \n",Message);
close(FdAccept);
close(Fd);
exit(0);
}

Client

************************************************/
/* BP le 22/02/1997                            */
/* Programme qui emet un message sur un socket */
/* Ossature d'un client tcp                    */
/***********************************************/
/* Fichiers a inclures .... */
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>

/* Constantes */
	/* Message envoye au serveur */
#define MESSAGE " Message du client .... "

/* Prototypages */
int main(int argc, char ** argv);

int main(int argc, char ** argv)
{
int Fd; /* Descripteur de fichier (socket) */
struct sockaddr_in Sockaddr; /* Descriptif d'un socket */
struct hostent * Machine; /* Machine ou reside le serveur */
struct servent * Service; /* Service (ou port) ou le serveur est attache */

/* verifier le lancement */
if ( argc != 3)
	{
	fprintf(stderr," Syntaxe : %s : Machine Port...\n",argv[0]);
	exit(-10);
	}
/* addresse de la machine du serveur */
Machine = gethostbyname(argv[1]);
if (Machine == NULL)
	{
	perror("Client : gethostbyname");
	exit(-1);
	}
/* initialisation de la structure */
memset(&Sockaddr,0,sizeof(struct sockaddr_in));
/* on travaille sur TCP/IP */
Sockaddr.sin_family = PF_INET;
memcpy(&Sockaddr.sin_addr,Machine->h_addr,Machine->h_length);

 /* on ecoute sur quel port ???? */
Service = getservbyname(argv[2],"tcp");
if (Service == NULL)
	{
	perror("Client : getservbyname");
	exit(-2);
	}
Sockaddr.sin_port = Service->s_port;
/* On peut avoir le socket */
/* PF_INET => socket tcp/ip */
/* SOCK_STREAM => tcp comme protocol */
/* 0 => protocole par defaut sur tcp */
Fd = socket(PF_INET,SOCK_STREAM,0);
if (Fd == -1)
	{
	perror("Client : socket");
	exit(-3);
	}

/* on se connecte au serveur */
if ( connect(Fd,(struct sockaddr *) &Sockaddr,sizeof(struct sockaddr_in)) == -1)
	{
	perror("Client : connect");
	exit(-4);
	}

/* on tente la l'envoie d'un message */
write(Fd,MESSAGE,strlen(MESSAGE) +1 );
close(Fd);
exit(0);
}



TP3




But du TP

Mettre en place l'automate 1 et 2 et 3
Nous commencerons par écrire les automates 1 et 3



Description de l'automate1
Tant que vrai faire
début
	Attendre Opérateur
	Prendre Pièce
	Traiter Pièce
	Attendre automate 2
	Répondre automate 2
fin




Description de l'automate2
Tant que vrai faire
début
	Demander une pièce à automate 1
	Prendre Pièce
	Traiter Pièce
	Attendre automate 3
	Répondre automate 3
fin




Description de l'automate3
Tant que vrai faire
début
	Demander une pièce à automate 2
	Prendre Pièce
	Traiter Pièce
	Avertir Opérateur
	Attendre opérateur
fin

logiqueabdo

TP Résau

TP 1

Présentation du sujet

Informations techniques

Simulation Informatique

Glossaire

Network (Réseau)

LAN:

WAN

MAN

OSI

ISO

TCP/IP

Matériels actifs

Adressage

Routage

Client/Serveur

Protocole

Tp2

Présentation

Environnement de travail

But du TP

Primitives utilisées

Ossature des programmes

Serveur

Client

Travail demandé

Corrigés

Serveur

Client

TP3

But du TP

Description de l'automate1

Description de l'automate2

Description de l'automate3

Rechercher dans ce blog