Ce TP est la suite du tp: tppic

Objectifs :

1. Utiliser l'outils de développement d'application sur PC QTCreator.
2. Utiliser une librairie de gestion des sockets.
3. Appliquer les concepts de POO pour utiliser des librairies Objets.
4. Illustrer la communication via sockets entre applications sur une même machine (PC)
5. Illustrer la communication via sockets entre applications sur des machines différentes (PC et micro contrôleur PIC)

On souhaite maintenant faire dialoguer chaque carte PIC avec une application tournant sur le PC étudiant correspondant. Dans un premier temps, vous utiliserez sur le PC étudiant l'exécutable BroadcastReceiver fourni puis vous écrirez votre propre exécutable sur PC en utilisant l'outil de développement QTCreator. A la fin du TP, vous utiliserez également l'outil d'analyse réseau pour vérifier la communication.

Repérer sur le schéma de la page imprimée fournie au premier TP les éléments utilisés pour faire dialoguer la carte PIC avec le PC étudiant. Identifier les numéros de ports UDP utilisables. Proposer les modifications nécessaires au programme du PIC.

Le résultat de cette analyse est que vous devez utiliser les numéros de ports 2700 et 2701 pour échanger des informations depuis le PC.

Le schéma suivant récapitule l'ensemble des matériels et logiciels que nous allons utiliser dans cette série de TP. Les différents éléments seront expliqués au fur et à mesure. A chaque étape, vous devez être capable d'identifier les portions utilisées et leur rôle. Vous devrez remplir les cases jaunes sur la feuille distribuée lors du TP.

L'application que vous devez développer vous est fournie dans un premier temps afin que vous la voyez fonctionner et sachiez ce que vous devez faire. Une application fonctionnant sur le PC et simulant le PIC est également fournie pour faciliter le développement et permettre aux étudiants n'ayant pas terminé le programme sur le PIC de faire ce TP.

Dans les dossiers récupérés se trouve un exécutable permettant de simuler la carte PIC. Il y a également le fichier de script .bat ou .sh qui permet de lancer simupic pour qu'elle utilise les bons numéros d'IP et de port (que vous avez du déterminer à l'exercice précédent) . Ce programme permet de simuler la carte PIC et de développer l'application sur PC sans avoir besoin de la carte PIC. Pour le test en local, vous pourrez utiliser l'adresse IP de la boucle locale (127.0.0.1).

Vous devez maintenant développer votre propre application QTbroadcastreceiver.

POUR OUVRIR LE PROJET avec QTCreator après l'avoir récupéré, vous devrez Copier/coller dans une console:

echo 'commence'
cd ~/QTbroadcastreceiveretudiantAU2ET3/QTbroadcastreceiveretudiant
qtcreator broadcastreceiver.pro  &
echo 'fini'

Le projet est constitué des fichiers sources d'une application graphique sous QT. Votre code sera saisi dans l'implémentation de la fenêtre principale, à l'intérieur du fichier Sources→receiver.cpp. . Les définitions des méthodes et objets de la fenêtre principale sont quant à elles faites dans le fichier receiver.h. Ce sont les deux seuls fichiers que vous aurez à modifier jusqu'à nouvel ordre. Pour information le projet contient également:

 .pro      fichier décrivant le projet QT, les règles de compilation, les librairies à utiliser etc...
main.cpp       fichier décrivant le programme principal, qui se contente de lancer la fenêtre principale.

NB: Nous utiliserons sur le PC étudiant un seul Objet UdpSocket pour l'émission et la réception.

Une fois le projet ouvert, l'utilisateur peut choisir entre plusieurs mode d'affichages, notamment “Editer” et “Debogage” à l'aide des boutons sur la gauche de la fenêtre.

La fenêtre Projets fait apparaître les fichiers du (des) projet(s) ouvert(s), triés selon leur type. Sur la droite, la fenêtre affiche le contenu d'un fichier sélectionné.

CTRL+Click souris gauche sur un mot du programme permet de se déplacer à la déclaration d'une variable, d'un objet, d'une fonction, d'un type ou autre. Cela sera très utile pour connaître par exemple les méthodes utilisables sur un objet d'une certaine classe.

CTRL+B permet de compiler l'application, la fenêtre Sortie de compilation permet alors d'observer les éventuelles erreurs, sur lesquelles vous pourrez cliquer pour aller à la ligne correspondante dans le code.

CTRL+R permet d’exécuter le programme. Le programme devra être fermé en cliquant sur le bouton croix de la fenêtre avant de le recompiler ou de l’exécuter à nouveau.

F5 permet d'exécuter le programme en mode DEBUG. L'utilisateur passe alors en mode Debug, ce qui ajoute à l'affichage une zone à droite dans laquelle l'utilisateur pourra observer les variables et leurs valeurs. L'utilisateur pourra placer ou retirer des points d'arrêt en cliquant à gauche du numéro de ligne d'un fichier. Il pourra exécuter en pas à pas sans rentrer dans les fonctions à l'aide de F10 ou bien en entrant dans les fonctions à l'aide de F11. Il pourra ajouter une variable particulière à la liste des variables affichées en Debug en selectionant le nom de la variable dans le fichier programme et en cliquant droit dessus puis clic gauche sur ajouter un évaluateur d'expression.

Afin que l'application à développer sur PC soit capable d'émettre les datagrammes pour piloter la carte PIC, il faut implémenter une méthode void Receiver::sendUDP(int i), (i code le numéro de la led à allumer, donc le bouton pressé de l'application sur le PC). Cette méthode devra faire les actions suivantes:

1. Définir une variable de type QHostAddress (par exemple destIP )
2. Appeler la méthode bool QHostAddress(const QString & addrIP) de l'objet destIP pour régler l'IP du dispositif avec lequel communiquer à l'aide d'une chaine de caractères addrIP.
3. Définir une variable de type quint16 pour coder le numéro du port UDP destination (par exemple destPort=4567;)
4. Définir un tableau de caractères (par exemple chaine[]) et générer la chaîne pour piloter les leds (par exemple avec la fonction sprintf comme pour le PIC)
5. Pour émettre la chaîne chaine sur la socket, appeler la méthode qint64 writeDatagram(const char * chaine, qint64 len, const QHostAddress host, quint16 port); de l'objet udpSocket. Pour le paramètre len utiliser la valeur (qint64)strlen(chaine)+1 (car on envoie le contenu de la chaine + le caractère \0 terminateur de chaine.

La méthode void Receiver::sendUDP(int i) est appelée lorsque l'utilisateur presse un des boutons, le paramètre i codant le numéro du bouton.

Tester que l'appui sur le bouton i commute bien la led i du simulateur.

Une fois les réponses validées, mettre à jour le suivi de version en saisissant dans une console:

echo 'commence'
cd ~/QTbroadcastreceiveretudiantAU2ET3/QTbroadcastreceiveretudiant
git commit -a -m'emission'
gitk & 
echo 'fini'

Contrairement à l'émission, qui survient à un moment maîtrisé par le programme (lors de l'appel de la méthode sendUDP), la réception doit pouvoir se faire à tout instant. Pour cela, un mécanisme proche d'une interruption matérielle est mis en place: lorsqu'un datagramme est reçu, une fonction est appelée pour le traiter. Comme avec les interruptions, il est nécessaire d'initialiser ce mécanisme et cela est fait dans la méthode constructeur de la fenêtre, qui est appelée lors de sa création.

Pour cela, ajouter dans la méthode constructeur de la fenêtre Receiver::Receiver(QWidget *parent) : Qdialog(parent) le réglage de l'IP du dispositif avec lequel communiquer et le port UDP en réception sur le PC.

QString m_destIP="1.1.1.2";  //à remplacer par l'IP
unsigned int m_portIn=1234;  //à remplacer par le port UDP à écouter

Ajouter à l'endroit indiqué après la création de udpSocket l'attache de udpSocket au port Udp:

udpSocket->bind(m_portIn, QUdpSocket::ShareAddress);

Et connecter le signal readyRead() au slot processPendingDatagrams() en utilisant:

connect(udpSocket, SIGNAL(readyRead()), this, SLOT(processPendingDatagrams()));

Ainsi la méthode processPendingDatagrams() sera automatiquement appelée à la réception d'un datagramme sur le numéro de port choisi.

Il vous faut maintenant implémenter la méthode void Receiver::processPendingDatagrams() pour traiter les datagrammes reçus:

1. Pour déterminer si il y a des datagrammes disponibles en réception, appeler la méthode bool hasPendingDatagrams(); de l'objet udpSocket.
2. Pour connaître le nombre d'octets que l'on peut lire sur la socket, appeler la méthode qint64 pendingDatagramSize() de l'objet udpSocket.
3. Pour lire le contenu du datagramme, appeler la méthode qint64 readDatagram(char *data, qint64 maxlen); de l'objet udpSocket (Comme pour le programme du PIC, on veillera à ne pas lire plus de données que ce que le tableau data peut contenir).
4. Utiliser la fonction sscanf pour décoder le datagramme reçu int sscanf(char *chaine, const char * format, …)
5. Régler les valeurs de variables codant l'état des boutons (b1,b2,b3)
6. Régler les afficheurs de la fenêtre (sw1,sw2,sw3) en appelant la méthode void setChecked(bool); de chacun des trois objets sw1 à 3 . Appeler également la méthode setText(char * chaine) de l'objet statusLabel pour afficher les caractères ASCII reçus.

Tester que l'appui sur le bouton i dans l'application simupic est bien répercuté sur votre application.

Une fois les réponses validées, mettre à jour le suivi de version en saisissant dans une console:

echo commence
cd ~/QTbroadcastreceiveretudiantAU2ET3/QTbroadcastreceiveretudiant
git commit -a -m'reception'
gitk & 
echo fini

Il est maintenant temps de tester votre application PC avec votre application PIC, pour cela:

1. Déterminer les adresses IP et MAC de l'adaptateur réseau Realteck du PC étudiant en lançant la commande “ip addr ls” dans une console.
2. Modifier le code du PIC en conséquence (adresse IP (et MAC si vous n'avez pas implémenté l'ARP sur le PIC) destinataire et les numéros de ports).
3. Modifier le code du programme PC en conséquence (adresse IP de la carte PIC et les numéros de ports).

Utilisez l'application Wireshark pour observer le traffic entre le PC et le PIC (détails d'utilisation sur la page wireshark):

1. Choisir l'interface à espionner (carte Realtek) dans la liste des interfaces.
2. Régler un filtre pour n'afficher que les trames d'intérêt, par exemple saisir udp dans la zone filter.
3. Localiser les trames échangées entre le pc et la carte PIC.
4. Repérer les champs correspondants aux différentes couches réseau.

Une fois les réponses validées, mettre à jour le suivi de version en saisissant dans une console:

echo commence
cd ~/QTbroadcastreceiveretudiantAU2ET3/QTbroadcastreceiveretudiant
git commit -a -m'avec carte pic'
gitk &
echo fini

1. Décommenter la création de commutTimerButton et de Timer ainsi que les implémentations de void Receiver::commutTimer() et de void Receiver::on_timer_Event()
2. Tester votre application avec Simupic