Réseau sans fil dans le cadre d'un bâtiment intelligent et...

Rémy Feltrin M2 PSPIUJF GrenobleAnnée universitaire: 2009-2010

Réseau sans fil dans le cadre d'un bâtiment intelligentet

Programme d'identification d'un procédé discret par USB

Tuteur enseignant : Jean Marc Thiriet Tuteur laboratoire: Stéphane Mocanu

Table des matièresRemerciement.......................................................................................................................................4Introduction..........................................................................................................................................5

Présentation du laboratoire..............................................................................................................5Objectif du stage et description du projet........................................................................................7

Simulation du procédé..........................................................................................................................8Introduction sur les protocoles...........................................................................................................10

Introduction sur les réseau.............................................................................................................10Topologie...................................................................................................................................10Types de réseau.........................................................................................................................11

Couches réseau...............................................................................................................................11Routage.....................................................................................................................................12

Introduction sur l'USB...................................................................................................................12Identification d'une chaine de Markov à l'aide d'une carte USB........................................................13

Présentation de la carte..................................................................................................................14Interface homme-machine.............................................................................................................14

Présentation du protocole Zigbee et de la couche 802.15.4..............................................................16802.15.4.........................................................................................................................................16Zigbee............................................................................................................................................17

Routage au niveau de la couche réseau.....................................................................................17Routage au niveau applicatif : ..................................................................................................17

Mise en place d'un réseau Zigbee.......................................................................................................18Présentation du Matériel................................................................................................................18Explication et modification du code de la couche physique et Zigbee..........................................19

Envoie des données par Matlab..........................................................................................................21Identification..................................................................................................................................22Asservissement..............................................................................................................................22

Conclusion..........................................................................................................................................23Bibliographie......................................................................................................................................24

Index des illustrationsIllustration 1: Organigramme du GIPSA-Lab......................................................................................6Illustration 2: Schéma du bâtiment intelligent vu de dessus................................................................7Illustration 3: Photo du bâtiment intelligent.........................................................................................7Illustration 4: Simulink du procédé......................................................................................................8Illustration 5: Simulink de la partie réseau du procédé........................................................................8Illustration 6: Simulink du contrôle......................................................................................................8Illustration 7: Simulink du procédé modélisé.......................................................................................9Illustration 8: Chaine de Markov de la porte 1.....................................................................................9Illustration 9: Topologie linéaire........................................................................................................10Illustration 10: Topologie en Bus.......................................................................................................10Illustration 11: Topologie en anneau..................................................................................................10Illustration 12: Topologie en arbre.....................................................................................................10Illustration 13: Topologie en étoile.....................................................................................................10Illustration 14: Topologie maillé.........................................................................................................11Illustration 15: Couches réseau...........................................................................................................11Illustration 16: Schéma de routage.....................................................................................................12Illustration 17: Chaine de Markov de l'état d'une porte......................................................................13Illustration 18: Carte USB..................................................................................................................14Illustration 19: Capture d'écran de l'interface.....................................................................................15Illustration 20: Thermistance et sa carte électronique........................................................................18Illustration 21: Valeur hexadécimal en fonction de la température des pièces...................................18Illustration 22: 5 cartes Zigbee avec 4 esclaves (rouge) et un maitre (Vert)......................................19Illustration 23: Trames envoyées par le réseau sans-fil......................................................................21Illustration 24: Bloc Simulink pour la communication USB (UART)...............................................22Illustration 25: Simulink du procédé en boucle fermé.......................................................................22

Remerciement

Je remercie mon tuteur M. Mocanu Stéphane qui m'a encadré et aider pendant ces 5 mois, ainsi que M.Witrant Emmanuel pour sa présence et son soutient tout au long de mon stage.

Je tiens aussi à remercier M Brossa Vinvent. pour la réalisation des cartes et maquettes.

Enfin j'associe à ces remerciement M.Thiriet Jean-Marc, responsable du département Automatique et M.Dion Jean-Michel, directeur, qui m'ont permis de réaliser ce stage dans de bonnes conditions au sein du laboratoire.

Introduction

Afin de terminé mes études de Master PSPI (Pilotage et Surveillance des Procédés Industriels), j'ai réalisé un stage de 5 mois au GIPSA-Lab.

Celui-ci porte sur la mise en place d'un système d'identification de chaine de Markov, et sur l'installation d'un réseau faible consommation pour contrôler un procédé de régulation de température.

Présentation du laboratoireLe GIPSA-lab (Grenoble Images Parole Signal Automatique) est implanté dans les locaux de l'INPG à Gieres.

Ce laboratoire de recherche est reconnu au niveau international pour ces recherches en automatique, signal et images, parole et cognition.

Il est constituer de trois départements :

• Automatique

• Images et signal

• Parole et cognition

Le département automatique où j'ais réalisé mon stage est composé de 3 équipes :

• Systèmes à événements discrets

• Systèmes linéaires et robustesse

• Systèmes non linéaires et complexité

• Systèmes biomécaniques

• Signal, automatique pour le diagnostic et la surveillance (équipe commune avec le DIS)

• Systèmes commandés en réseaux (équipe-projet commune avec l’INRIA Rhône-Alpes)

J'ai travaillé dans l'équipe systèmes à événements discrets en collaboration avec l'équipe systèmes linéaires et robustesse.

Les activités de recherche de l’équipe Systèmes à Evénements Discrets concerne l'étude des systèmes dynamiques événementiels en utilisant les modèles de base que sont les automates, les chaînes de Markov et les réseaux de Petri. La prise en compte explicite du temps apporte des solutions pour le calcul des performances, le pilotage ou la surveillance de ces systèmes.

Les axes de recherche de cette équipe sont :

• Réseaux de Petri et automates

• Modèles stochastiques

• Gestion et optimisation de la production de biens et de services

• Systèmes de santé

Illustration 1: Organigramme du GIPSA-Lab

Objectif du stage et description du projet

Le but de ce projet est de réguler la température d'un bâtiment à travers un réseau sans fil autonome, grâce à un espace commun réfrigérer par module Pelletier.Pour cela des espaces communs d'air frais et d'air chaud sont placés en bas et en haut du bâtiment. Afin de réguler la température, de l'air frais sera injécté venant du sous sol grâce à un ventilateur.Pour de simuler la chaleur humaine ou matérielle une lampe a été placé dans chaque pièce. Entre chaque pièce il y a une porte qui est actionnée de manière aléatoire. Ce système est donc non linéaire du fait de la présence de termes discrets. Les actionneurs et capteurs sont gérés par un seul et unique calculateur, le système est donc multi-variable, multi-entrées et multi-sorties.Afin de mesurer la température des capteurs sont placés dans chaque pièce ainsi que dans le sous-sol.L'apport d'air chaud dans le système n'a pas été étudié.

Illustration 2: Schéma du bâtiment intelligent vu de dessus

Illustration 3: Photo du bâtiment intelligent

Sur l'illustration 3, on peu voir l'espace d'air frai en bas avec les modules Pelletier, au dessus il y a les pièces qui sont sensées représenter l'habitat et ventilateurs qui sont placés dans le plancher .

Dans un premier temps j'ai mit en place un système d'identification des temps de commutation des portes grâce à un périphérique USB.

Ensuite le but de ce stage est de créer un protocole application qui puisse transmettre les ordres aux ventilateurs et recevoir les différentes températures.

Simulation du procédé

Ce procédé peut être décompose en trois éléments :

− Une partie réseau qui impose une fréquence de transfert, des risque de collision et de transmission à des dates aléatoires. Pour modéliser ceci un bloqueur d'ordre zéros (en violet) et une temporisation variable (en Vert et Orange (durée)) on été mis en place.

− Un contrôleur qui est de type H infinie qui enverra les commandes au ventilateurs en fonction de la température des pièces et autres paramètres. Il est composé de deux représentation d 'état en parallèle, une continue (orange) et une discrète (Bleu).

T_emit1

To

To

To

To

tauNet 4

tauNet 3

tauNet 2

tauNet 1

Delays

T_meas1

Illustration 5: Simulink de la partie réseau du procédé

dm_pl1

Zero-OrderHold

TrackingError

Hinf K

x' = Ax+Bu y = Cx+Du

Discrete State -Space

y(n)=Cx(n)+Du(n)x(n+1)=Ax(n)+Bu(n)

udTd

-C-

T1

Illustration 6: Simulink du contrôle

To Workspace

T Temp

Network

T_ m e a s T_ e m it [T][T] [T]

Flat

d m _Pl T

Control

T d m _p l

Illustration 4: Simulink du procédé

− Le modèle du système qui prend comme entrée la vitesse des ventilateurs et retourne la température des pièces. Celui-ci est composé d'une représentation d'état pour la partie continue (Rouge et Orange) et de deux chaines de Markov pour la partie discrète (Vert et Bleu). Celles-ci modélise les portes et lampes du systèmes (Vert).L'équation de la partie linéaire est : T=A1A2⋅diag u t x t B1×ut Bw×w t où u(t) représente l'entrée et w(t) les perturbations.

T1

Internal sources

P in [W ]

1s

[T]

[T]

F_d (t)

P in

d o o rs

T

d_ cs t

tim e C s t

yfcn

F_c (t)

u

x

w

A1

A2

B1

B w

Tfcn

Doors 0/1

d o o rs

d_cst

timeCst

Bw

B1

A2

A1

Tout

Tpl

dm_Pl1

Illustration 7: Simulink du procédé modélisé

Illustration 8: Chaine de Markov de la porte 1

Introduction sur les protocoles

Introduction sur les réseau

Topologie

Je présente les six types d'architectures (topologie) de réseau principales; pour la communication USB la topologie en bus était implantée dans l'ordinateur par construction. La topologie en étoile a été utilisée pour le réseau sans-fil.

− Topologie linéaire Avantage : Peu couteux en câblage

Inconvénient : Si un ordinateur plante le réseau est coupé, pas de redondance

− Topologie en bus Avantage : Peu couteux en câblage , assure un maintient du réseau si un ordinateur est coupé

Inconvénient : Nécessite un répartiteur (Maitre), pas de redondance

− Topologie en anneau Avantage : Peu couteux en câblage, assure une redondance matériel si un câble est coupé

Inconvénient : Nécessite un coordinateur et si deux paquets sont envoyés en même temps ils sont perdu

− Topologie en arbre Inconvénient : Si l'ordinateur « père » (celui en haut du réseau) plante, la moities du réseau est planté

− Topologie en étoile

Avantage : la panne d'un ordinateur en fin de ligne ne provoque pas de coupure.

Inconvénient : Si le concentrateur (celui qui reçoit toutes les connections) plante, le réseau est coupé, et cette méthode coute cher en longueur de câble

Illustration 10: Topologie en bus

Illustration 12: Topologie en barbre

Illustration 9: Topologie linéaire

(en série)

Illustration 13: Topologie en étoile

Illustration 11: Topologie en anneau

− Topologie maillé Avantage : Aucune coupure possible par plantage d'un ordinateur

Inconvénient : très cher en câble (souvent utilisé en connexion

sans-fil Ad-hoc (de paire à paire))

Types de réseau

On distingue deux types de réseaux, maitre-esclave et libre.

Dans le cadre d'un réseau maitre-esclave, l'hôte (maitre) interroge les périphériques (Esclaves), en dehors de ces interrogations, le réseau est non occupé.

Ceci a pour avantage de limiter le trafic et donc la consommation en énergie du réseau, mais si le maitre venais à planter, l'envoie et la réception de données sont coupés.

En type libre, chaque périphérique envoie un paquet quand il a besoin en cas de collision de paquets (plusieurs paquets en même temps sur le réseau), les ordinateurs devrons retransmettre au bout d'un certain temps (aléatoire en général).

Pont réseau

Un pont réseau est un appareil permettant de convertir un type de réseau en un autre type. Un convertisseur USB-RS232 peut donc être assimilé à un pont.

Couches réseau

On distingue 7 couches différentes qui se concatènent les unes dans les autres.La couche physique est la couche la plus basse elle contient donc toutes les informations et les données des autres couches. C'est celle-ci qui sera envoyée sur le réseau. Chaque couche rajoute des informations, et peut donc données de nouvelles adresses (Adresse physique, Adresse réseau,...). Ajouter des informations à chaque couche à pour effet de réduire le débit utile du réseau (débit de données à transmettre), il faut donc essayer de réduire au maximum le nombre de couches et d'informations.

Illustration 14: Topologie maillé

Comme nous le verrons plus tard, j'ai utilisé le protocole 802.15.4 pour les couches physique et le protocole Zigbee pour la couche réseau. Le but étant de programmé la couche application.

− Couche physique : Lien entre les données (bits) et les signaux électriques ou ondes radio envoyés.

− Couche Liaison (MAC): Configuration des connexions (vitesse de transmission, bit de stop, ...) et autres afin que les transferts s'effectuent correctement.

− Couche réseau : Routage des paquets c'est à dire le transfert de données de la source vers la cible en passant par d'autres machines.

− Couche transport : Remise en ordre des données si elles sont fragmentés et retransmission des paquets si ils on été perdus ou erronés (TCP).

− Couche session : Ouverture et fermeture de session (liée à la couche application)(début d'un transfert vidéo par exemple) et synchronisation des échanges.

− Couche présentation : Codage et décodage des données (ASCII par exemple)− Couche application : Accès de l'application au réseau

Routage

Le routage est l'acheminement d'un paquet d'une source vers une cible en passant par d'autre machines. Un routage nécessite de lire les paquets (adresses), et de connaître le réseau pour savoir vers quelle machine dirigé le paquet.

Illustration 15: Couches réseau

Introduction sur l'USB

Une liaison USB peut être interpréter comme une communication réseau en bus.

L'USB à été développé au alentour des années 1990, les avantages qu'il possède par rapport aux autres ports existants de cette époque sont la rapidité de transmission, la connectivité Plug and Play, le branchement à chaud et l'alimentation des périphériques par le port. Le débit maximum est de 12 Mbit/s.Les améliorations significatives sont l'USB2 (années 2000) débit théorique 480 Mbit/s et l'USB3 (2008) 4,8 Gbit/s.La version 2 possède une résistance sur l'entrée D- alors que l'USB1 à une résistance sur l'entrée D+. L'USB 3 est reconnu par le branchement de 4 autres contacts.

Un connecteur USB (sauf la version 3) est composé de quatre contacts qui sont l'alimentation, la masse et deux fils de données.

Un périphérique USB est un esclave il est donc interrogé par un maitre qui dans notre cas sera un ordinateur. Lors de la connexion du périphérique de manière général les deux contacts d'alimentation sont connectés avant ceux des données afin de laisser au micro-contrôleur le temps de démarrer. Ensuite le PC alloue une adresse 0 au périphérique afin de l'identifier et de configurer la connexion. Ensuite le maitre lui alloue une adresse définitive par laquelle il communiquera.Ce type de « réseau » à une topologie en étoile et le PC interroge les périphériques en fonction de leur type de transmission.

Ce protocole utilise trois types de transmission :− Bulk, qui utilise le maximum de bande passante disponible quand celle ci est libre il est

généralement utilisé pour les opérations sur les fichiers. Il y a une garantie d'acheminement des données.

− Interupt, Le périphérique envoie des données sous forme d'interruption à l'ordinateur (en réalité l'ordinateur interroge le périphérique ce n'est pas réellement une interruption). Celui-ci est utilisé pour les clavier et les souris par exemple. Celui-ci est fait pour des informations de petites tailles)

− Isochronous, transmission périodique d'information avec une bande passante garantie il est utilisé pour la vidéo par exemple. Transmission temps réel.

Illustration 16: Schéma de routage

− Commande, ce type est utilisé à la connexion des périphériques pour l'envoie de configuration. Ce sont des données sont de taille réduite mais il y a une garantie d'acheminement.

Identification d'une chaine de Markov à l'aide d'une carte USB

Le but de cette parti est de connaître le temps moyen d'ouverture et de fermetures des portes du système afin d'identifier le procédé.Des capteurs on été placés sur les portes, les informations seront récupérées par un micro-contrôleur qui transmettra l'état des portes à un ordinateur. Le protocole de transmission choisi est l'USB pour sa facilité d'utilisation et l'accès au branchement.Celui-ci calculera l'intervalle de temps entre chaque changements d'état et en fera une moyenne.Cette opération ne peut pas être réalisée par un micro-contrôleur seul, car il y a beaucoup d'informations à stocker pour améliorer la précision des résultats et la mémoire de ce type de composant serait insuffisante.

Illustration 17: Chaine de Markov de l'état d'une porte

Ouverte

Fermée

T ouvertureT fermeture

Présentation de la carte

Celle-ci permet d'utiliser tout les modes de transmission (Interupt, Bulk et Isochronous) elle possède différents boutons afin de simuler l'ouverture et la fermeture des portes.Des exemples qui peuvent être adaptée à notre cas sont disponible.

Interface homme-machine

Les librairies founit par Silicon lab sont compilables avec Visual C++, j'ai essayé avec d'autres compilateurs mais cela ne fonctionnait pas.

Ce programme est constitué d'un tableau à 4 colonnes (nombre de portes) et trois lignes. La première affiche les compteur horaire, la deuxième l'historique des données et la dernière affiche les moyennes calculées.

J'ai donc créer une Interface Homme Machine en Win32.

L'algorithme du programme Host est le suivant :

Affichage de l'interfaceRecherche des périphérique USBConnexion au périphériqueEnvoie d'un bit de startFaire{

Réception des données, affichage et sauvegarde dans un fichierCalcul des moyennes

}Tant que ( bouton_stop == 0 )Envoie d'un bit de stopDéconnexion

L'algorithme du micro-contrôleur est le suivant :

Illustration 18: Carte USB

InitialisationBoucle infini{

Attente d'un bit de startFaire{

Envoie de l'état des interrupteurs par USB}Tant que ( stop == 0 )

}

Dans un premier temps la carte doit être sélectionnée grâce aux flèches en haut à gauche. Ensuite il faut cliquer sur « Connecter » pour commencer le transfert de données et démarrer les compteurs horaires.Selon l'activité des portes le tableau doit se remplir et les valeurs moyennes se mettre à jour.Les données sont ensuite sauvegardées dans des fichiers texte au même endroit que le programme. Pour vider ces fichiers il suffit de cliquer sur le bouton sur l'interface.Une fois la capture de données terminée on peut quitter le programme grâce à la croix rouge en haut à droite ou « fichier » → « Quitter ».Le programme ne doit pas être tué par le gestionnaire de tache car le micro-contrôleur continuerai d'envoyer des informations qui seraient lues au prochain lancement du logiciel et qui serai éronnéesEn cas de plantage faire un reset du micro-contrôleur avant de cliquer sur connecter.

Illustration 19: Capture d'écran de l'interface

Présentation du protocole Zigbee et de la couche 802.15.4

802.15.4

Une des contraintes de ce projet est d'embarquer le ventilateur et capteur dans un module qui soit le plus autonome en énergie possible et qu'il y ai le moins de fils possible entre ces modules et le calculateur.

Le protocole 802.15.4 a été choisit, qui est un protocole réseau sans-fil, pour son autonomie et le fait qu'il introduise des aspect temps réel dans un réseau.En effet l'autonomie d'un périphérique Bluetooth est de l'ordre de quelque jours, pour le Wifi (802,.11) elle est de quelque heures alors que pour les Wpan on atteint 3 ans d'autonomie.Ceci est du au fait qu'entre chaque échange de données (Supertrame) les périphériques et le maitre se mettront en veille.

La portée des périphériques utilisant le protocole 802.15.4 est de l'ordre d'une centaine de mètres comme pour la communication Bluetooth alors que l'on peut atteindre des kilomètres avec un réseau WIFI.Le débit théorique d'un tel réseau dans le cadre d'un système embarqué est de 100 kbit/s.

En dehors de ces caractéristiques, le protocole 802.15.4 permet une communication maitre/esclave et introduit une communication inter-maitre qui ne sera pas utilisé dans ce projet. Il utilise une topologie réseau en étoile.Celui-ci permet aussi d'assigner des adresses courtes au périphériques, ce qui facilitera la manipulations des données.

Ce protocole est constitué de la couche physique ainsi que la couche MAC (liaison). Il indique donc comment la couche supérieur doit dialoguer avec elle-même, et comment fonctionne la couche physique.

L'envoie de données peut se faire de deux manières :

− GTS (Garantie Time Slot) : Une super-trame est envoyée par le coordinateur et les esclaves répondent dans cette même trame. Ce mode est temps réel car aucun risque de collision et une transmission périodique des informations.

− CSMA/CD : La bande passante disponible est utilisée pour envoyer les données. Il y a risque de collision et donc de retard sur les informations.

Au dessus de cette couche réseau, une couche réseau peut être implantée comme Zigbee, 6lowPan, Z-Wave, …

Ceux-ci s'occuperont alors de la couche de liaison, transport.

Dans notre cas le protocole Zigbee sera utilisé, car il propose une communication temps réelle et a déjà été implanté à titre de démonstration dans les micro-contrôleur utilisés.

Zigbee

Le protocole Zigbee appartient à la Zigbee Alliance c'est à dire que si on veut développer une application réseau il faut demander la « stack » de base à la Zigbee alliance.Afin d'obtenir cette stack, il faut faire partie de la Zigbee Alliance (couteux), développer une application déjà programmée par un membre de l'alliance, ou encore développer sa propre stack (en accord avec la norme Zigbee).

Dans notre cas je modifierai l'exemple fournit par Silicon Labs qui était membre de cette alliance quand les cartes Zigbee ont été développées.

Ce protocole étant surtout utilisé pour le routage de paquet, le protocole Zigbee ne sera pas utilisé mais j'utiliserai les couches liaisons et physique proposé dans l'exemple.

Routage au niveau de la couche réseau.

La méthode de routage proposé par la Zigbee alliance est un routage dit réactif, c'est à dire que la table de routage se construit au moment où il y a une demande de la part d'un nœud réseau.Cette méthode a pour avantage d'occuper peu le réseau et donc d'être économe en énergie, en contrepartie le temps de routage est plus long. Celle-ci s'appelle AODV (Ad hoc On-Demand Vector Routing).Ce type de routage ne sera pas utilisé car il y a un seul nœud (Coordinateur), ce routage aura été mis en place si il y avais plusieurs maitres.

Routage au niveau applicatif :

Celui-ci se fait grâce à une table de liaison qui est contenue dans la mémoire du coordinateur.Il permet de faire la liaison entre une application (périphérique réseau avec un autre protocole (Ethernet par exemple)) et les esclaves. Je n'utiliserai pas ceci car il y a 4 périphériques connecté a un coordinateur qui va dialoguer avec un calculateur, sachant qu'il y a une seul source (coordinateur ou pc) et un seul destinataire (PC ou Coordinateur) il n'y a pas besoin de routage au niveau applicatif.

Mise en place d'un réseau Zigbee

Présentation du Matériel

Les cartes Zigbee sont identiques pour les maitres et esclaves seul la partie programmation du micro-contrôleur les différencie.

Chaque carte est composé d'une puce Zigbee, d'un micro-contrôleur, d'un pont USB, d'un jeu de LED et de boutons poussoirs et un support de pile.Dans le micro-contrôleur il y a 5 timers, 2 convertisseurs analogique-numérique et 2 autres numérique-analogique.

Les ventilateurs ont été câblés sur une sortie analogique et les capteurs de température sur un entrées analogique.Les ventilateurs sont alimentés en 12Volt ce qui évite les surtensions. La valeur hexadécimal à envoyer pour obtenir cette tension est : AB00.La valeurs minimal pour que les ventilateur tourne semble être au alentours des 3000.

Les mesures des capteurs de température étaient très bruitées, j'ai dû les changer pour des thermistances avec une plage de température plus réduite autour de nos points de fonctionnement.Pour cela des sondes de température médicale ont été commandée. Ces capteurs ont pour avantage d'être à peu prés linéaire dans la plage de température dans laquelle il sera utilisé.J'ai aussi fait une carte électronique afin d'extraire les mesures en faisant passer le minimum de courant dans le capteur (pour limiter l'échauffement).

J'ai fait une identification de ces capteurs afin d'en déduire les équations.

Illustration 21: Valeur hexadécimal en fonction de la température des pièces

Illustration 20: Thermistance et sa carte électronique

Les équations qui lient les valeurs en hexadécimal au températures sont les suivantes :

V 1=3,8×T 13168V 2=14,96×T 22878V 3=7,68×T 33123V 4=4,08×T 43305Où V n représente la valeur en hexadécimal de la température de la pièce et T n la température.

Toutes les températures seront ensuite transmisent à un ordinateur grâce au pont USB. Le micro-contrôleur recevra les consignes des ventilateurs par cette même connexion.

Explication et modification du code de la couche physique et Zigbee

Afin de déterminer les différentes fréquences d'envoi et de réception de trames, j'ai utilisé un modèle simulink qui prend en compte les contraintes du réseau. A partir de celui-ci je pourrais déterminer quelle est la fréquence d'échantillonnage minimum du systèmes et donc la fréquence d'envoi de données.

Afin de configurer ceci deux paramètres sont à notre disposition, SO et BO (Superframe Order et Beacon Order) et ce calcule comme suit :

− Intervalle entre chaque supertrame : BI=aBaseSuperframeDuration×2BO

− Durée de la portion active de la supertrame (durée ou le périphérique/maitre est éveillé):SD=aBaseSuperframeDuration×2SO

Dans notre cas SO et BO on tout deux la même valeur c'est à dire 5 afin que les données soit transmisent toutes les 0,5 secondes et que la durée de supertrame soit suffisante.

L'exemple fournit par Silicon labs permet de connecter des esclaves au nombre de 3, d'envoyer des données des périphériques vers le coordinateur et de ce déconnecter.Cet exemple est constitué de plusieurs fichiers : couche physique, couche MAC, interruption, bouton, démarrage, et programme principal.Le fichier d'initialisation des cartes Zigbee est déjà compilé il est donc difficile de le modifier.

A l'aide de la norme 802.15.4 je doit créer un protocole application qui maintient une connexion

Illustration 22: 5 cartes Zigbee avec 4 esclaves (rouge) et un maitre (Vert)

entre les cartes, qui permet une communication bi-directionnel, et une allocation d'adresses fixes.

Algorithme :

− Configuration des périphériques et coordinateur.− Connexion du Coordinateur puis des esclaves.− Lecture CAN− Transmission des températures des pièces à travers le réseau sans-fil− Transmission des données au PC.− Réception des vitesses de ventilateurs.− Envoie des vitesses au esclaves à travers un CNA

Les programmes fournis par Silicon Lab ne permettaient pas la communication bi-directionnelle, je les ai modifiés pour envoyer des données par le protocole CSMA/CD pour les trames à destination des esclaves. Le coordinateur envoie une trame pour dialoguer avec touts les esclaves, les données étant triées par adresses de destinataires croissantes.Chaque esclave lira alors la valeur dans la case correspondante à son adresse.

Pour maintenir une connexion stable j'ai dû répertorier les différentes raisons de déconnexion possible :

− Réseau inactif− Pas de données− Plantage de la puce 802.15.4− Plantage d'un esclave (micro-contrôleur)− Plantage du maitre

− Perturbation électromagnétique− Dédoublement d'adresses

J'ai eu un problème de détection de déconnexion des périphériques esclaves. Pour le résoudre j'ai mis en place un système détection de déconnexion des esclaves et un systèmes de redémarrage par le réseau. J'ai donc rajouté une information en début de trame afin d'indiquer le type de trame. Ceci a pour effet de réduire le nombre de données envoyées mais dans notre cas on peut se le permettre car il reste de la place disponible dans les trames.

Les différents types de trames sont :• Ping/réponse de ping : le coordinateur envoie une trame ping commençant par FF les

esclaves doivent alors répondre dans un intervalle de temps définit. Si aucune réponse n'est reçue le maitre modifie sa table d'adresses.

• Re-connexion : Les données sont triées par ordre croissant des périphériques, chaque esclave récupère la valeur correspondant à son adresse si un 0 est lut il doit se reconnecter. Ces trames sont repérées par la valeur 1 en en-tête.

• Données : ce sont les trames qui transportent les données. Leur type est 2.

• Trames vide : Elle servent à maintenir la connexion quand il n'y a pas de dialogue elle sont repérées par un 0 en tête de trame.

Si un micro-contrôleur ne reçoit pas de trames au bout d'un certain temps il doit redémarrer.J'ai essayer d'implanter des watchdog dans les micro-contrôleur afin de réduire encore une chance de plantage mais celui-ci se déclenchait trop souvent ceci malgré une fréquence de l'ordre de 70ms d'actualisation du Chien de garde (temporisation de 300ms).

Afin d'éviter le dédoublement d'adresse j'ai mit en place une correspondance entre les adresses MAC et adresses de toutes les autres couches supérieurs. Toutes les requêtes de connections d'un périphérique ne figurant pas dans la table d'adresses sera rejeté. On peut ainsi assigner des adresses fixes en fonction de la pièce dans laquelle se trouve l'esclave. Une table d'adresses est constituée de 3 colonnes : adresse MAC, adresse réseau, état (utilisé ou non) et de quatre lignes correspondant au 4 pièces.

Avec ces deux méthodes le système fonctionne pendant 8 heures environ dans un milieu moyennement perturbé et environ deux heures en milieu perturbé en ajustant la fréquence. Le problème vient souvent du maitre qui lorsqu'il est vraiment planté, crash le réseau. Un Watchdog pourrait résoudre ce problème.

Sur cette illustration, en jaune il y a les données des différents esclaves, et en bleu se sont les supertrames (Pour voir que les périphériques dialoguent dans les supertrames, il faut regarder les dates de réception et d'envoi des trames).

Envoie des données par Matlab

Cette partie a été faite avec l'aide de Joan Marine Proenza.Le pont USB ne fait en réalité que convertir les données d'une liaison RS232 vers le PC à travers une connexion USB. Sur l'ordinateur un port série virtuel est ajouté et ensuite tout se fait comme une communication série RS232.Les données transmisent sont sur 8 bits et sont envoyées à la suite nous devons donc convertir les valeurs avant de les envoyer par la liaison série.

Afin de récupérer les données sous Matlab, un bloc Simulink dédié à la communication RS232 a été crée. Celui a été programmé en C par Joan Marine Proenza et compilé avec Visual c++.

Les données reçues seront ensuite triées par type et par adresses. Puis elles seront converties en valeur numérique puis lissées. On peut ensuite les connecter au contrôle du procédé.

Illustration 23: Trames envoyées par le réseau sans-fil

Les vitesses des ventilateurs doivent aussi séparées en mots de 8 bits et sont envoyées à la suite au micro-contrôleur. Ces données sont ensuite remisent en ordre et envoyées sur le réseau par le coordinateur.

Illustration 24: Bloc Simulink pour la communication USB

(UART)

A la suite de ce stage une identification et la mise en place d'un régulateur pourront être réalisé.

Identification

Dans un premier temps, une identification sera faite en envoyant une consigne (échelon) au ventilateur, ensuite les données seront récupérées sur Matlab.

Grâces à divers algorithmes et au modèle théorique nous pourrons les matrices A1 , A2 , B1 et Bw pourront être recalculées.

Une fois cette identification faite les équations du régulateur seront corrigé afin qu'ils soit plus précis par rapport au système.

Asservissement

Le boucle est fermée par la réception de données du module Zigbee, en plus de la température des pièces, la pression et de la température du sous-sol doivent être connu. Pour cela le module Zigbee devra être connecter sur le même ordinateur que le Compac Rio où sur le compac Rio lui-même.Pour fermer la boucle les informations du module Zigbee seront utilisées à travers la connexion USB. Les vitesses des ventilateurs seront envoyés par la liaison USB et ensuite sur le réseau sans-fils à destination des esclaves.

R s 2 3 2

r s 2 3 2 p r o v e s

T o W o r k s p a c e

T

R s 2 3 2

r s 2 3 2 p r o v e s

D a t a _ p r o c e s s i n g

I n 1O u t 1

C o n t r o l

T d m _ p l

Illustration 25: Simulink du procédé en boucle fermé

Conclusion

Je suis satisfait de la manière dont c'est déroulé mon stage et des résultat que nous avons obtenue avec l'équipe Bâtiment intelligent. Le réseau Zigbee est opérationnel pendant plusieurs heures; Les ventilateurs tétaient piloté par l'ordinateur et qui recevais les informations thermiques du système. Il reste cependant quelques améliorations à apporter en particulier ajouter un Watchdog, ajuster la fréquence de fonctionnement pour être moins perturbé par l'extérieur. Hormis les problèmes de déconnexion le réseau est prêt à fonctionner aussi bien pour l'identification que la régulation.

Le système d'identification USB est prêt à être utilisé il a été testé.

Une des carte a été programmée avec les fichiers joints, avant d'utiliser la carte il faudra la vérifier la programmation avec les fichiers joints dans l'interface homme-machine. La connexion fonctionne correctement sans limite de temps et de cycles d'ouverture/fermeture.

Ce stage a été très intéressant car j'ai pu travailler sur des périphériques réseau sans-fil, qui est un domaine en expansion actuellement, je pense que nous retrouverons bientôt des Wpan dans nos baladeurs, nos maisons, nos lieu de travail, …

J'ai aussi pu travailler sur la communication USB, ce que j'avais déjà fait lors d'un stage précédent pendant mais cette fois je me suis concentré sur le développement du programme sur le PC (Host).

J'ai appris le développement d'une interface homme-machine avec la gestion des drivers, le développement de communication avec Matlab qui permet de faire du « Hardware in the loop » c'est à dire récupérer les informations du système pour les transmettre à Matlab afin de faire fonctionner ce logiciel en calculateur pour régulateur.

Ce stage a été une très bonne expérience, j'ai réussi à m'intégrer rapidement dans l'équipe de recherche dans laquelle beaucoup de personnes se sont rendu disponible pour m'apporter les informations qui me manquaient.

Bibliographie

http://users.skynet.be/ybet/hardware2_ch2/hard2ch2_1.gif (schema des couches réseau)

http://www.gipsa-lab.inpg.fr/

http://fr.wikipedia.org

802.15.4TM IEEE Standard for Information technologyTelecommunications and informationexchange between systems Local and metropolitan area networks—Specific requirements(Norme 802.15.4)

http://fr.wikipedia.org/

http://www.gipsa-lab.inpg.fr/

http://users.skynet.be/ybet/hardware2_ch2/hard2ch2_1.gif

http://users.skynet.be/ybet/hardware2_ch2/hard2ch2_1.gif

G:\button.c samedi 4 septembre 2010 14:01

//reseau zegbee

//============================================================================================

=====

// button.c

//--------------------------------------------------------------------------------------------

-----

// Copyright 2006 Silicon Laboratories, Inc.

// http://www.silabs.com

//

// Module Description:

// This module include all functions related to the buttons to the 802.15.4 MAC

programming

// example MAC_Blinky. Each function is commented. Many of these functions access the

802.15.4

// MAC via shared data structures. Please see AN269 for more information.

//

// Target:

// C8051F121

//

// Tool chain:

// Keil C51.EXE version 7.05

// Keil BL51.exe version 5.15

// Silicon Laboratories IDE version 2.51

//

// Project Name:

// MAC_Blinky

//

// Release 1.0

// -Initial Revision

// -05 JAN 2006

//

//

// This software must be used in accordance with the End User License Agreement.

//

// This module may be used with third party modules. Other modules are copyright of their

// respective owners.

//

//============================================================================================

=====

#include "../../head/headers.h"

#include "../../Head/Main/button.h"

//============================================================================================

=====

// void CheckButton(void)

//

// This function polls and dubounces the four buttons. Each button has an associate count

variable

// in the Button array. This function is called from main and is non-blocking code.

// The debounce function requires that the button be held down for greater than MAXCOUNT

itterations

// and also released for the same periood.

//

// Once a button press has been detected, the button state veraible will be set to button

press.

// The button state variable is reset to BUTTON_UP status by the associate button function

-1-


once

// completly serviced.

//

//============================================================================================

=====

unsigned char tmpShortAddress[2];

SAVE_INFO xinfo;

void CheckButton(void)

{

unsigned char n;

for(n=0;n<4;n++)

{

if((P3 & BM(n))==0) // if button n pressed

{

if((Button[n]&BUTTON_STATUS)==BUTTON_UP)

{

if((Button[n] & MAX_BUTTON_COUNT)==MAX_BUTTON_COUNT)

{

Button[n] = BUTTON_DOWN;

}

else

{

Button[n]++;

}

}

}

else // button is up

{

if((Button[n]&BUTTON_STATUS)==BUTTON_DOWN)

{

if((Button[n] & MAX_BUTTON_COUNT)==MAX_BUTTON_COUNT)

{

Button[n] = BUTTON_PRESS;

}

else

{

Button[n]++;

}

}

}

}

}

//============================================================================================

=====

//

// void ProcessButton(void)

//

// This function processes the functions associated with each button. Since this function is

called

// from main() is is a non-blocking function. The buttons will only be processed if the mac is

-2-


// ready for a new command. If the network to mac buffer has mac task pending, the

ProcessButton()

// function will not process the button commands in this iteration of the main loop.

//

// Some of the button fucntions have dependencies or pre-existing conditions. Upon reset the

device

// may be configures as a coordinator by pressing Button[0] or can associate with a

coordinator

// by pressing Button[1]. After this, Button[0] and Button[1] should be ignored.

// The macShortAddress is set to 0XFFFF upon reset. The short address is set to 0x0000 for

the

// coordinator or is set to some number less than 0xFFFE upon association. Thus, the short

address

// may be used to test for coordinator or association.

//

//

//============================================================================================

=====

void ProcessButton(void)

{

int z;

//WatchDogEnable(TRUE);

if((n_m_msg_t.primtype & NWK_Buffer_Valid) == 0) // is MAC ready?

{

if( Button[0] == BUTTON_PRESS) // was Button[0] pressed?

{

buttonStartRequest(); // start as coordinator

}


{

buttonAssociateRequest(); // attempt to associate

}


{

LED13_OFF();

LED12_OFF();

/* n_m_msg_t.msg.MCPS_DATA_request.msdu[0]=0x01;

for(z=1;z<16;z++)

{

n_m_msg_t.msg.MCPS_DATA_request.msdu[z]=0xAA;

}

buttonDataRequest();

//buttonDataRequest(); */

// reco(); // send data to coordinator

}


{

if((IsCoordinator==FALSE)&&(XdataSaveBuffer.MAC_PIB.macShortAddress!=0xFFFF)) //

if device associated

{

buttonDisassociateRequest(); // disassociate

}

else

{

-3-


Button[3]=BUTTON_UP; // ignore button

}

}

}

}

//--------------------------------------------------------------------------------------------

-----

// buttonStartRequest()

//

// This function is called from ProcButton() when the start button has been pressed. The

ProcButton()

// checks for an empty network to mac buffer and this function assumes the buffer is empty.

//

// It takes four MAC primitives to reset and configure the coordinator. So a state machine

is used

// in this function. The function will continue to be called until until the button status is

// cleared by the final state.

//

//--------------------------------------------------------------------------------------------

-----

void buttonStartRequest(void)

{

static unsigned char startState=0;

switch(startState)

{

case 0:

// reset MAC and default PIB values

n_m_msg_t.msg.MLME_RESET_request.setDefaultPib=TRUE;

n_m_msg_t.primtype=gMlmeResetReq_c|NWK_Buffer_Valid;

startState++;

break;

case 1:

//set short add attribute ID

n_m_msg_t.msg.MLME_SET_request.pibAttribute = macShortAddressID;

tmpShortAddress[0] = DEMO_COORD_ADDR&0XFF;

tmpShortAddress[1] = DEMO_COORD_ADDR>>8;

n_m_msg_t.msg.MLME_SET_request.pibAttributeValue = tmpShortAddress;

n_m_msg_t.primtype = gMlmeSetReq_c|NWK_Buffer_Valid;

startState++;

break;

case 2:

// mlme start request

//set pan id

n_m_msg_t.msg.MLME_START_request.panId = DEMO_PAN_ID;

//set logical channel

n_m_msg_t.msg.MLME_START_request.logicalChannel = DEMO_CHANNEL;

//set beacon order

n_m_msg_t.msg.MLME_START_request.beaconOrder = BO;

//set super frame order

n_m_msg_t.msg.MLME_START_request.superFrameOrder =SO;

//set device is pan Coordinator

n_m_msg_t.msg.MLME_START_request.panCoordinator = TRUE;

-4-


//set batteryLifeExt Flag

n_m_msg_t.msg.MLME_START_request.batteryLifeExt = FALSE;

//set coordRealignment Flag

n_m_msg_t.msg.MLME_START_request.coordRealignment = FALSE;

//set securityEnable Flag

n_m_msg_t.msg.MLME_START_request.securityEnable = FALSE;

//set primtype Flag

n_m_msg_t.primtype = gMlmeStartReq_c|NWK_Buffer_Valid;

startState++;

break;

case 3:

//enable association permit

n_m_msg_t.msg.MLME_SET_request.pibAttribute = macAssociationPermitID;

n_m_msg_t.msg.MLME_SET_request.pibAttributeValue = TRUE;

n_m_msg_t.primtype = gMlmeSetReq_c|NWK_Buffer_Valid;

Button[0] = BUTTON_UP; //Clear Button status

startState = 0;

break;

default:

startState=0;

break;

}

}

//--------------------------------------------------------------------------------------------

-----

// buttonAssociateRequest ()

//

// This function is called from ProcButton() when the associate button has been pressed. The

// ProcButton() checks for an empty network to mac buffer and this function assumes the

buffer is

// empty.

//

// This function contains a state machine with two states. The first state resets the mac.

The

// second state initiates an active scan.

//

// The rest of the association transaction is handled by the mac2nwk callback functions. Upon

// conclusion of the active scan, a scan confim will be sent to the nwk layer. The scan

confirm

// will initiate an association request. If the association confirm is successful, an LED

will be

// turned on.

//

//--------------------------------------------------------------------------------------------

-----

void buttonAssociateRequest (void)

{

unsigned char i;

static unsigned char assocState=0;

switch(assocState)

{

case 0:

// reset MAC and default PIB values

n_m_msg_t.msg.MLME_RESET_request.setDefaultPib=TRUE;

n_m_msg_t.primtype=gMlmeResetReq_c|NWK_Buffer_Valid;

-5-


assocState++;

break;

case 1:

n_m_msg_t.msg.MLME_SYNC_request.logicalChannel=DEMO_CHANNEL;

n_m_msg_t.msg.MLME_SYNC_request.trackBeacon=TRUE;

n_m_msg_t.primtype = gMlmeSyncReq_c|NWK_Buffer_Valid;

assocState++;

break;

case 2:

n_m_msg_t.msg.MLME_ASSOCIATE_request.logicalChannel = DEMO_CHANNEL;

//get coordinator addr mode

n_m_msg_t.msg.MLME_ASSOCIATE_request.coordAddrMode = 8;

//set coordinator pan id

n_m_msg_t.msg.MLME_ASSOCIATE_request.coordPanId = DEMO_PAN_ID;

//n_m_msg_t.msg.MLME_ASSOCIATE_request.coordPanId =

m2n_msg[byTemp].msg.MLME_SCAN_confirm.resList.pPanDescriptorList[0].dwCoordPANId&0xFF;

//n_m_msg_t.msg.MLME_ASSOCIATE_request.coordPanId <<= 8;

//n_m_msg_t.msg.MLME_ASSOCIATE_request.coordPanId +=

(m2n_msg[byTemp].msg.MLME_SCAN_confirm.resList.pPanDescriptorList[0].dwCoordPANId>>8)&0xFF;

// set coordinator extended address

for(i = 0;i<8;i++)

n_m_msg_t.msg.MLME_ASSOCIATE_request.coordAddress[i] = 0;//copy

//set capablitiy information

n_m_msg_t.msg.MLME_ASSOCIATE_request.capabilityInfo = 0x80;

//security, not support in this version

n_m_msg_t.msg.MLME_ASSOCIATE_request.SecurityLevel = 0x00;

//set primtype Flag

n_m_msg_t.primtype = gMlmeAssociateReq_c|NWK_Buffer_Valid;

assocState=0;

Button[1] = BUTTON_UP;

break;

/* case 2:

n_m_msg_t.msg.MLME_GTS_request.securityEnable= FALSE;

n_m_msg_t.msg.MLME_GTS_request.gtsCharacteristics= 0X24; // (2 slots

direction 0 alloc 1 : n01xx = 0x n4

n_m_msg_t.primtype = gMlmeGtsReq_c|NWK_Buffer_Valid;


assocState = 0;

break;*/

default:

assocState=0;

break;

}

}

//--------------------------------------------------------------------------------------------

-----

// buttonDataRequest ()

//

// This function is called from ProcButton() when the data request button has been pressed.

The

-6-



buffer is

// empty.

//

// This function will send data to the coordinator using the short address of the

coordinator as

// the destination and the associated short addres as the source. Dummy data is used just to

// demonstrate data transmision. In a typical application this data might adc mesurement.

//

//--------------------------------------------------------------------------------------------

-----

void buttonDataRequest(void)

{

unsigned char i;

// send to coordinator

n_m_msg_t.msg.MCPS_DATA_request.dstAddr[0] = 0xFF; //copy dest addr


// get address mode

n_m_msg_t.msg.MCPS_DATA_request.srcAddrMode = srcSHORT_ADDRESS_MODE; //source

n_m_msg_t.msg.MCPS_DATA_request.dstAddrMode = dstSHORT_ADDRESS_MODE; //destination

//get source pan id

n_m_msg_t.msg.MCPS_DATA_request.srcPanId = XdataSaveBuffer.MAC_PIB.macPANId;

// get src addr

n_m_msg_t.msg.MCPS_DATA_request.srcAddr[0] = 0x00;


//get destination pan id

n_m_msg_t.msg.MCPS_DATA_request.dstPanId = XdataSaveBuffer.MAC_PIB.macPANId;

// get msdu handle

n_m_msg_t.msg.MCPS_DATA_request.msduHandle = 0x01;

//get transmit options

n_m_msg_t.msg.MCPS_DATA_request.txOptions = 0x00;

// get msdu length

// n_m_msg_t.msg.MCPS_DATA_request.msduLength = 16;

// get msdu

// n_m_msg_t.msg.MCPS_DATA_request.msdu[0]=0x01;

// for(i=1;i<16;i++)

// {

// n_m_msg_t.msg.MCPS_DATA_request.msdu[i]=0x88;

// }

//set primtype Flag

n_m_msg_t.primtype = gMcpsDataReq_c|NWK_Buffer_Valid;

xinfo.MAC_PIB.macCoordShortAddress=XdataSaveBuffer.MAC_PIB.macCoordShortAddress;

xinfo.MAC_PIB.macShortAddress=XdataSaveBuffer.MAC_PIB.macShortAddress;

frames();

//Clear Button Status


}

void data_master(void)

{

Button[2]=BUTTON_DOWN;

}

void Data_ping(void)

-7-


{

unsigned char i;




// get address mode

n_m_msg_t.msg.MCPS_DATA_request.srcAddrMode = srcSHORT_ADDRESS_MODE; //source

n_m_msg_t.msg.MCPS_DATA_request.dstAddrMode = dstSHORT_ADDRESS_MODE; //destination

//get source pan id

n_m_msg_t.msg.MCPS_DATA_request.srcPanId = XdataSaveBuffer.MAC_PIB.macPANId;

// get src addr




n_m_msg_t.msg.MCPS_DATA_request.dstPanId = XdataSaveBuffer.MAC_PIB.macPANId;

// get msdu handle

n_m_msg_t.msg.MCPS_DATA_request.msduHandle = 0x01;


n_m_msg_t.msg.MCPS_DATA_request.txOptions = 0x00;//0x02;

// get msdu length

n_m_msg_t.msg.MCPS_DATA_request.msduLength = 16;

// get msdu

for(i=0;i<16;i++)

{

n_m_msg_t.msg.MCPS_DATA_request.msdu[i]=0xFF;

}

//n_m_msg_t.msg.MCPS_DATA_request.msdu[addr]=0x00;

//set primtype Flag

n_m_msg_t.primtype = gMcpsDataReq_c|NWK_Buffer_Valid;

xinfo.MAC_PIB.macCoordShortAddress=XdataSaveBuffer.MAC_PIB.macCoordShortAddress;

xinfo.MAC_PIB.macShortAddress=XdataSaveBuffer.MAC_PIB.macShortAddress;

//Clear Button Status

//Button[2] = BUTTON_UP;

frames();

}

//--------------------------------------------------------------------------------------------

-----

// buttonDisassociateRequest ()

//

// This function is called from ProcButton() when the disassociate button has been pressed.

The


buffer is

// empty.

//

// Once the disassociation notify frame has been acknowledged, a disassociate confim will be

sent

// to the nwk layer. If the disassociate confirm is successful, an LED will be turned off.

//--------------------------------------------------------------------------------------------

-8-


-----

void buttonDisassociateRequest (void)

{

unsigned char byTemp;

// copy short address

n_m_msg_t.msg.MLME_DISASSOCIATE_request.DisassShortAddress=0xFFFE; //force long

addressing mode

//n_m_msg_t.msg.MLME_DISASSOCIATE_request.DisassShortAddress=0x0000;

//copy device address

for(byTemp=0;byTemp<8;byTemp++)

n_m_msg_t.msg.MLME_DISASSOCIATE_request.deviceAddress[byTemp] = XdataSaveBuffer.

MAC_PIB.macCoordExtendedAddress[byTemp];//copy

// copy disassociate reason

n_m_msg_t.msg.MLME_DISASSOCIATE_request.disassociateReason= 0x02;

// copy security enable, not support in this version

n_m_msg_t.msg.MLME_DISASSOCIATE_request.securityEnable= 0x00;

//set primtype Flag

n_m_msg_t.primtype = gMlmeDisassociateReq_c|NWK_Buffer_Valid;


}

void coord(void)

{

Button[0]=BUTTON_PRESS;

}

-9-

G:\IsrProc.c samedi 4 septembre 2010 14:02

// Resau zigbee programme interuption

/* ________________________________________________ ____________________________

# Copyright (c) 2005

# Helicomm Inc. All rights reserved.

#

# Redistribution and use in source and binary form s, with or without

# modification, are prohibited without the written consents of Helicomm, Inc.

#

# THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED

# WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE I MPLIED WARRANTIES OF

# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PUR POSE.

* _________________________________________________ ____________________________

*

* File: IsrProc.c

*__________________________________________________ _____________________________*/

//------------------------------------------------- -----------------------------------------

// DOXYGEN PREAMBLE

//------------------------------------------------- -----------------------------------------

/**

* \ingroup group_system

*/

/*! \file IsrProc.c

* \brief uart0 isr and timer0 isr.

*

* \brief AUTH: zdy

* \brief DATE: 19 MAY 05

* \brief Target: C8051F121

* \brief Tool chain: KEIL C51 7.06 / KEIL EVAL C51

* \brief Detailed description for IsrProc.c later...

*/

//------------------------------------------------- -----------------------------------------

// INCLUDE

//------------------------------------------------- -----------------------------------------

// Headers.h defins MACRO_CLINTON

#include "../../Head/headers.h"

//------------------------------------------------- -----------------------------------------

// FUNCTIONS

//------------------------------------------------- -----------------------------------------

void ISR2 (void ) interrupt 2 {}










-1-








/**

* Name: TIMER0_ISR

*

* Input Parameters:

* N/A

*

* Output Parameters:

* N/A

*

* Descriptions:

* time0 isr

*

*

* Side Effect:

* derive State machine of mac.

*

* Applicability: FFD - Mandatory; RFD - Mandator y

*

* See Also:

* \seealso mac_base.c...

*

*/

void TIMER0_ISR (void ) interrupt 1

{

unsigned char bySFR = SFRPAGE;

SFRPAGE= 0; // set SFR page

//disable global interrupt

DISABLE_GLOBAL_INT();

// WatchDogEnable(FALSE);

//reload T0

TH0 =0xFC;

TL0 =0x18 ;

//WDTCN=0xA5;

//enable global interrupt

ENABLE_GLOBAL_INT();

// FEED_WATCH_DOG();

// ProcessMAC2NWK();


//call state machine of MAC layer

time ();

ping ();

ExecuteMac ();

//clear interrupt flag

TF0 = 0;

//timer0 run

TR0 = 1;

-2-


// WatchDogEnable(TRUE);

SFRPAGE= bySFR ;

return ;

}

-3-

G:\mac2nwk.c samedi 4 septembre 2010 14:02

//Reseau Zigbee programme couche Mac

//================================================= ===========================================

=====

// mac2nwk.c

//------------------------------------------------- -------------------------------------------

-----



//


// This module includes the ProcessMAC2NWK() fun ction. This function processes all data

messages

// coming back from the 802.15.4 MAC. Many of th ese messages cause actions such turning on

// LEDs. Some messages in turn call other MAC pr imitives. All of these are hendled in

this one

// modeule. Please see AN26 for additional infor mation.

//

// Target:

// C8051F121

//

// Tool chain:




//

// Project Name:

// MAC_Blinky

//

// Release 1.0


// -05 JAN 2006

//

//

// This software must be used in accordance with th e End User License Agreement.

//

// This module may be used with third party modules . Other modules are copyright of their


//

//================================================= ===========================================

=====

#include "../../head/headers.h"

#define DEMO_PAN_ID (0x0B07)

#define DATA 0x01

#define PING 0xFF

#define EMPTY 0x00

int con =0,n;

int dev_add [8]={0,0,0,0,0,0,0,0}; // adress table

int adress [54]={

1,0x000b ,0x5700 ,0x0000 ,0x0678 ,0,

2,0x000b ,0x5700 ,0x0000 ,0x0831 ,0,

3,0x000b ,0x5700 ,0x0000 ,0x0a07 ,0,

4,0x000b ,0x5700 ,0x0000 ,0x06ea ,0,

5,0x000b ,0x5700 ,0x0000 ,0x0a20 ,0,

6,0x000b ,0x5700 ,0x0000 ,0x0937 ,0,

7,0x000b ,0x5700 ,0x0000 ,0x0a46 ,0,

-1-


8,0x000b ,0x5700 ,0x0000 ,0x0941 ,0,

9,0x0000 ,0x0000 ,0x0000 ,0x0000 ,0}

,add[4]={0,0,0,0};

int add_temp =0,add_other =0x0A;

int k,nb=2,nb2=0,t =0,t2 ,t3 =0;

int t4 =0;

int times =0;

void ProcessMAC2NWK(void );

void ping (void );

void time (void );

void reco (void );

void frames (void );

int nb_trame =0,t_ping =0;

int flag =1;

char Byte2 [9];

char Byte ;

int envia =0;

int i ,rec [9],k;

char in [10];

unsigned int tr =0,lop =0;

#define UART_BUFFERSIZE 64

unsigned char UART_Buffer [UART_BUFFERSIZE],receive [aMaxMACFrameSize];

unsigned char slave2 [aMaxMACFrameSize],slave3 [aMaxMACFrameSize],slave4 [aMaxMACFrameSize],

slave5 [aMaxMACFrameSize],slave6 [aMaxMACFrameSize];

unsigned char UART_Buffer_Size = 0;

unsigned char UART_Input_First = 0;

unsigned char UART_Output_First = 0;

unsigned char TX_Ready =1;

void ProcessMAC2NWK(void );

unsigned char *padd;

unsigned char dev ,GC2;

/*int conv(int dat)

{

int tp;

if (tp>0x09) tp+=55; else tp+=48;

return tp;

}*/

/************* Send data throw UART BY JOAN * *****************/

void uart (void )

{

int p,del ;



if(receive [1]==01){

-2-


for(p=0;p<4;p++){

if(flag ==1){

SBUF0=receive [p];

flag =0;

for(del =0;del <350;del ++);

}

}

}


for(p=0;p<4;p++){

if(flag ==1){

SBUF0=slave2 [p];

flag =0;


}

}

}


for(p=0;p<4;p++){

if(flag ==1){

SBUF0=slave3 [p];

flag =0;


}

}

}


for(p=0;p<4;p++){

if(flag ==1){

SBUF0=slave4 [p];

flag =0;


}

}

}

-3-



for(p=0;p<4;p++){

if(flag ==1){

SBUF0=slave5 [p];

flag =0;


}

}

}


for(p=0;p<4;p++){

if(flag ==1){

SBUF0=slave6 [p];

flag =0;


}

}

}

SBUF0=0x0F;

// for(p=0;p<8;p++){

// receive[p]=0;

// }

// If the complete word has been entered via the te rminal followed

// by carriage return

if((TX_Ready == 1) && (UART_Buffer_Size != 0) && (Byte == 13))

{

TX_Ready = 0; // Set the flag to zero

TI0 = 1; // Set transmit flag to 1

}

}

/************************************************** *******************************************

*/

void ProcessMAC2NWK(void )

{

unsigned char byTemp;

unsigned char i ,j ;

unsigned char testarray [TransactionBuffLenth ];

unsigned char testsuccs [TransactionBuffLenth ], CA[8];

-4-


unsigned char resulttest ,D,GC,LT,SC;

unsigned short SA;

unsigned char test =0,dev2 =0,devi =0,devi2 =0;

GTS_LIST paddlist [7];//={0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x000 0};

GTS_LIST paddlist2 [7];

bit defer_m2n ;

UDBYTE PANId;

static unsigned int AssociatedAddress = 0;

// WDTCN=0xA5;

//WatchDogEnable(FALSE);

//find information's Fifo

/* for(i=0;i<7;i++)

{

//for(j=0;j<8;j++)

//{GTSManage.GTSList[i].ExtenAddr[j]=0x0000;}

paddlist[i].ShortAddr=0x0000;

paddlist[i].LifeTime=0x00;

paddlist[i].Descriptor=0x00;

paddlist[i].ShortAddr=GTSManage.GTSList[i].ShortAdd r;

paddlist[i].LifeTime=GTSManage.GTSList[i].LifeTime;

paddlist[i].Descriptor=GTSManage.GTSList[i].Descrip tor;

paddlist2[i].ShortAddr=0x0000;

paddlist2[i].Descriptor=0x00;

paddlist2[i].LifeTime=0x00;

paddlist2[i].ShortAddr=InvalidGTSList.GTSList[i].Sh ortAddr;

paddlist2[i].LifeTime=InvalidGTSList.GTSList[i].Lif eTime;

paddlist2[i].Descriptor=InvalidGTSList.GTSList[i].D escriptor;

// GTSManage.GTSList[i].ShortAddr=0x0000;

// GTSManage.GTSList[i].LifeTime=0x00;

//for(j=0;j<8;j++) PendingList.PendingAddr[i].Exten Addr[j]=0;

for(j=0;j<10;j++)

{ if

((paddlist[i].ShortAddr==adress[j*6])&&(paddlist[i] .LifeTime!=0x00)&&(paddlist[i].LifeTime!=0x

FF))

adress[j*6+5]=1;

if ((paddlist[i].ShortAddr==adress[j*6])&&(paddlist [i].LifeTime==0x00))

adress[j*6+5]=0;

}

}

dev=0;

dev=GTSManage.GTSCount;

dev2=GTSManage.SlotCount;

devi=InvalidGTSList.GTSCount;

devi2=InvalidGTSList.SlotCount;

if (dev<1){

times=2;

}

*/

for(byTemp = 0;byTemp<TransactionBuffLenth ;byTemp++)

if((m2n_msg[byTemp].primtype &NWK_Buffer_Valid ) == NWK_Buffer_Valid )

-5-


break;

//if find

if(byTemp<TransactionBuffLenth )

{

defer_m2n = 0;

//information's type

switch((m2n_msg[byTemp].primtype )&emptyBuffer )

{

//reset confirm

case gNwkResetCnf_c :

//all off

LED12_ON();

P2=0xFF;

break;

//set confirm

case gNwkSetCnf_c :

break;

//get confirm

case gNwkGetCnf_c :

break;

//start confirm

case gNwkStartCnf_c :

// get status

if(m2n_msg[byTemp].msg.MLME_START_confirm .status ==SUCCESS)

{

// turn on green coordinator LED

times =1;

LED6_ON();

// times==2;//reconnection

}

break;

//associate confirm

case gNwkAssociateCnf_c :

if(m2n_msg[byTemp].msg.MLME_ASSOCIATE_confirm .status ==SUCCESS)

{

// turn on yellow associate LED

LED7_ON();

n_m_msg_t.msg.MLME_GTS_request .securityEnable = FALSE;

n_m_msg_t.msg.MLME_GTS_request .gtsCharacteristics = 0X24; // (2 slots

direction 0 alloc 1 : n01xx = 0x n4

n_m_msg_t.primtype = gMlmeGtsReq_c |NWK_Buffer_Valid ;

}

break;

//disassociate confirm

case gNwkDisassociateCnf_c :

if(m2n_msg[byTemp].msg.MLME_DISASSOCIATE_confirm .status ==SUCCESS)

{

// turn off yellow associate LED

LED7_OFF();

}

break;

//scan confirm

case gNwkScanCnf_c :

-6-


LED12_ON();

break;

//associate indication

//associate indication

case gNwkAssociateInd_c :


if((n_m_msg_t.primtype & NWK_Buffer_Valid ) == 0)

{

add_temp =0;

con =0;

i =0;

for (i =0;i <8;i ++) dev_add [i ]=m2n_msg[byTemp].msg.MLME_ASSOCIATE_indication .

deviceAddress [i ]; // read adresse

for (i =0;i <5;i ++)

{

add[i ]=dev_add [7-(2*i )]<<8;

// concatenate adresse

add[i ]+=dev_add [7-(2*i +1)];

}

i =0;

while(!((add_temp !=0)||(i >=9))) // compare with the table (in real

we juste compare the least part of the adresse)

{

for(j =0;j <4;j ++)

{

if(adress [(6*i )+1+j ]==add[j ]) add_temp =adress [i *6]&0x000000FF ;

else add_temp =0;

}

if(add_temp !=0)

{

//break;

// break;

adress [(i *6+5)]=1;

}

else i ++;

}

/* if (add_temp==0)

{add_temp=add_other;

add_other++;

}*/

//set associate's device short address

n_m_msg_t.msg.MLME_ASSOCIATE_response.assocShortAddress [0] = (add_temp &

0xFF);

n_m_msg_t.msg.MLME_ASSOCIATE_response.assocShortAddress [1] = (add_temp >> 8);

// association successful

if (add_temp ==0) n_m_msg_t.msg.MLME_ASSOCIATE_response.status = 0x02 ;

else n_m_msg_t.msg.MLME_ASSOCIATE_response.status = 0x00 ;

//security not support in this version

n_m_msg_t.msg.MLME_ASSOCIATE_response.securityEnable = FALSE;

n_m_msg_t.primtype = gMlmeAssociateRes_c |NWK_Buffer_Valid ;

LED7_ON();

delay16us (0xFFFF);

LED7_OFF();

t =-500;

times =1;

-7-



}

else

{

defer_m2n = 1;

}


break;

//disassociate indication

case gNwkDisassociateInd_c :

LED11_ON();

delay16us (0xFFFF);

LED11_OFF();

LED12_ON();

if(IsCoordinator )

{

/* for (i=0;i<7;i++)

{

//if (adress[i]==GTSManage.GTSList[0].ShortAddr) ad ress[i+7]=0;

}*/

LED8_ON();

delay16us (0xFFFF);

LED8_OFF();

}

break;

//orphan indication

case gNwkOrphanInd_c :

LED12_ON();

times =1;

break;

//poll confirm

case gNwkPollCnf_c :

times =1;

LED12_ON();

break;

//data confirm

case gMcpsDataCnf_c :

if(IsCoordinator ==FALSE)

{

LED9_ON();

delay16us (0xFFFF);

LED9_OFF();

}

break;

//data indication

case gMcpsDataInd_c : //mcps data indication

if(IsCoordinator )

{ //WatchDogEnable(FALSE);

// n_m_msg_t.msg.MLMS_GTS_indication.devAddress[

// for(j=0;j<8;j++)

// receive[j]=m2n_msg[byTemp].msg.MCPS_DATA_indicati on.srcAddr[j];

j =0;

while(GTSManage.GTSList [j ].ShortAddr !=m2n_msg[byTemp].msg.

-8-


MCPS_DATA_indication .srcAddr [0])

j ++;

GTSManage.GTSList [j ].LifeTime =15;

SA=GTSManage.GTSList [j ].ShortAddr ;

D=GTSManage.GTSList [j ].Descriptor ;

LT=GTSManage.GTSList [j ].LifeTime ;

GC=GTSManage.GTSCount;

if (GC!=GC2)

{

GC2=GC;

times =1;

}

SC=GTSManage.SlotCount ;

nb_trame =0;

/* k=0;

for (i=0;i<7;i++)

{ if (PendingList.PendingAddr[i].ShortAddr!=0x0000 ) k++;

// paddlist[i].ShortAddr=PendingList.PendingAddr[i] .ShortAddr;

}

if(k!=dev)

{

n_m_msg_t.msg.MCPS_DATA_request.msdu[0]=0x02;

////WatchDogEnable(TRUE);

for(i=1;i<16;i++) n_m_msg_t.msg.MCPS_DATA_request.m sdu[i]=0;

for(i=0;i<7;i++) if (PendingList.PendingAddr[i].Sho rtAddr!=0x0000)

n_m_msg_t.msg.MCPS_DATA_request.msdu[(PendingList.P endingAddr[i].ShortAddr)]=1;


}*/


for(i =0;i <9;i ++)

{

if (SA==adress [i *6])

{

t3 =0;

adress [(i *6)+5]=1;

}

}

// for(j=0;j<4;j++) receive[j]=m2n_msg[byTemp].msg.M CPS_DATA_indication.msdu[j];

/* for (j=0;j<15;j++){

if (SA==adress[j])

{

adress[j+15]=1;

adress[j+30]=1;

}

}*/

/*************************** Sending part by Johan **********************************/

for(j =0;j <4;j ++){

receive [j ]=m2n_msg[byTemp].msg.MCPS_DATA_indication .msdu[j ];

}


for(j =0;j <4;j ++){

receive [j ]=m2n_msg[byTemp].msg.MCPS_DATA_indication .msdu[j ];

}

}

-9-



for(j =0;j <4;j ++){

slave2 [j ]=m2n_msg[byTemp].msg.MCPS_DATA_indication .msdu[j ];

}

}


for(j =0;j <4;j ++){


}

}


for(j =0;j <4;j ++){


}

}


for(j =0;j <4;j ++){


}

}


for(j =0;j <4;j ++){


}

}

SFRPAGE=UART0_PAGE;

uart ();


/***********************************************/

}

break;

//beacon notify indication

case gNwkBeaconNotifyInd_c :

LED12_ON();

break;

//gts indication deco esclave

case gNwkGtsInd_c :

//TR1=1;

t =0;

times =1;

LED12_ON();

//times=1;

-10-


con ++;

break;

//gts confirm

case gNwkGtsCnf_c :

// unsigned char i;


LED13_ON();

/* n_m_msg_t.msg.MCPS_DATA_request.dstAddr[0] = 00 ; //copy dest addr

n_m_msg_t.msg.MCPS_DATA_request.dstAddr[1] = 00; //copy dest addr

// get address mode

n_m_msg_t.msg.MCPS_DATA_request.srcAddrMode = sr cSHORT_ADDRESS_MODE; //source

n_m_msg_t.msg.MCPS_DATA_request.dstAddrMode = ds tSHORT_ADDRESS_MODE; //destination

//get source pan id

n_m_msg_t.msg.MCPS_DATA_request.srcPanId = DE MO_PAN_ID;

// get src addr

n_m_msg_t.msg.MCPS_DATA_request.srcAddr[0] = 1; //

XdataSaveBuffer.MAC_PIB.macShortAddress&0xFF;

n_m_msg_t.msg.MCPS_DATA_request.srcAddr[1] =

0;//(XdataSaveBuffer.MAC_PIB.macShortAddress>>8)&0x FF;


n_m_msg_t.msg.MCPS_DATA_request.dstPanId = DE MO_PAN_ID;

// get msdu handle

n_m_msg_t.msg.MCPS_DATA_request.msduHandle = 0x 01;


n_m_msg_t.msg.MCPS_DATA_request.txOptions = 0x 02;

// get msdu length

n_m_msg_t.msg.MCPS_DATA_request.msduLength = 1;

// get msdu

for(i=0;i<1;i++)

{

n_m_msg_t.msg.MCPS_DATA_request.msdu[i]=i;

}

//set primtype Flag

n_m_msg_t.primtype = gMcpsDataCnf_c|NWK_Buffer_V alid;*/

break;

//rx enable confirm

case gNwkRxEnableCnf_c :

break;

//communication status indication

case gNwkCommStatusInd_c :

LED12_ON();

break;

//sync loss indication

case gNwkSyncLossInd_c :

LED12_ON();

times =1;

break;

//purge confirm

case gMcpsPurgeCnf_c :

LED12_ON();

times =1;

break;

//extended address indication, this is only support by this firmware, not standard

case gMcpsExdAddrInd_c :

-11-


break;

//error

default:

break;

}

if(!defer_m2n )

{

//clear primtype Flag

m2n_msg[byTemp].primtype = emptyBuffer ;

}

}


}

void UART0_Interrupt (void ) interrupt 4

{




SFRPAGE= UART0_PAGE;

if (RI0 == 1)

{

ES0=0;

REN0=0; //DISABLE RECEPTION

// for(i=0;i<4;i++){

// if (SBUF0==0x000D) tr=4;

if(SBUF0==0xFF){

tr =0;

}

else{

in [tr ]= SBUF0;

/* if(in[tr]==0xFE){

in[tr]=0x00;

}*/

tr ++;

}

if(tr ==9){


for(lop=1;lop<9;lop++){

n_m_msg_t.msg.MCPS_DATA_request.msdu[lop]=in[lop- 1];

}

-12-


for(lop=9;lop<16;lop++){

n_m_msg_t.msg.MCPS_DATA_request.msdu[lop]=0;

}

buttonDataRequest();*/

tr =0;

LED9_ON();

delay16us (0xFFFF);

LED9_OFF();

}

flag =1; // Clear interrupt flag

REN0=1;

RI0 = 0;

}

//}

if (TI0 == 1) // Check if transmit flag is set

{

TI0 = 0; // Clear interrupt flag

flag =1;

}

//enable global interrupt


ES0=1;

return;


}

void ping (void )

{

int z;

nb2=0;

for (z=30;z<45;z++)

{

if (adress [z]==1) nb2++;

}

if (nb2==nb)

{

/* for (z=0;z<15;z++)

{

adress[z+30]=0;

nb_trame=0;

-13-


}*/

}

if (t4 >=600) // send data

{

n_m_msg_t.msg.MCPS_DATA_request .msduLength = 10;

n_m_msg_t.msg.MCPS_DATA_request .msdu[0]=0x01 ;

for(lop =1;lop <9;lop ++){

n_m_msg_t.msg.MCPS_DATA_request .msdu[lop ]=in [lop -1];

}

buttonDataRequest ();


for(z=1;z<16;z++) n_m_msg_t.msg.MCPS_DATA_request.ms du[z]=z;


t4=0;*/

}

/* if (nb_trame>7)

{

times=2;

t=0;

for (z=0;z<30;z++) adress[z+15]=0;

Data_ping();

nb_trame=0;

}*/


if ((t >=0x800 ) && (times ==0))

{

t =0;

times =1;

}

if (times ==1) //update the adress table

{

t =0;

LED11_ON();

delay16us (0xFFFF);

LED11_OFF();

for(z=1;z<10;z++) adress [((z-1)*6)+5]=0;

times =2;

}

if ((t >=0x500 ) && (times ==2)) // reconnexion frames

{



for(z=1;z<10;z++)

{

n_m_msg_t.msg.MCPS_DATA_request .msdu[z]=adress [((z-1)*6)+5];

}


times =0;

t =0;

}

if (t >=0x4000 )

{

/* n=0;

for (z=0;z<15;z++) if (adress[z+15]==1) n++;

if (n<4)

{

-14-


LED10_ON();

times=2;

t=0;

Data_ping();

//for (z=0;z<15;z++) adress[z+15]=0;

//nb=n;

}

else

{

times=0;

t=0;

}

if (t3>=0x1000)

{

// RSTSRC|=0x10;

t3=0;

}

/* if (t2>=0x9000)

{

n_m_msg_t.msg.MCPS_DATA_request.msdu[0]=0x02;

for(z=1;z<16;z++)

{

n_m_msg_t.msg.MCPS_DATA_request.msdu[z]=adress[z+29 ];

}


for (z=0;z<15;z++)

{

adress[z+30]=0;

}

}*/

}

}

void time (void )

{

int z;

t ++;

t2 ++;

t3 ++;

t4 ++;

if (t >0x5000 )

{t =0;

// LED13_OFF();

}

if (t3 >0x1000 )

{t3 =0;

// RSTSRC|=0x10;

}


if (t4 >0x4000 ) t4 =0;

if (t2 >0x5000 )

{

t2 =0;

//LED12_OFF();

//if (nb_trame < 20) nb_trame++;

}

-15-


}

void reco (void )

{ int z;



////WatchDogEnable(TRUE);

for(z=1;z<9;z++)

{

n_m_msg_t.msg.MCPS_DATA_request .msdu[z]=0;

}


//times=3;

//t=0;

}

void frames (void )

{

t4 =0;

}

-16-

G:\main.c samedi 4 septembre 2010 14:03

//reseau zigbee programme principal

//================================================= ===========================================

=====

// main.c

//------------------------------------------------- -------------------------------------------

-----



//


// This is the main module for the MAC_Blinky pr ogramming example. This module includes

only

// the main loop. The MAC library, button code, and mac2nwk code are external to the

// main module.

//

//

// Target:

// C8051F121

//

// Tool chain:




//

// Project Name:

// MAC_Blinky

//

// Release 1.0


// -05 JAN 2006

//

//

// This software must be used in accordance with th e End User License Agreement.

//

// This module may be used with third party modules . Other modules are copyright of their


//

//================================================= ===========================================

=====

//------------------------------------------------- -------------------------------------------

-----

// INCLUDE

//------------------------------------------------- -------------------------------------------

-----

#include "../../Head/headers.h"

#include "../../Head/Main/Main.h"

#define BAUDRATE 57600 // Baud rate of UART in bps

// SYSTEMCLOCK = System clock frequency in Hz

#define SYSTEMCLOCK (8000000L * 9 / 4)

sfr16 RCAP4 = 0xca ; // Timer2 capture/reload

sfr16 TMR4 = 0xcc ; // Timer2

int fr =0;

int dat [16];

/*#define UART_BUFFERSIZE 64

-1-


unsigned char UART_Buffer[UART_BUFFERSIZE];

unsigned char UART_Buffer_Size = 0;

unsigned char UART_Input_First = 0;

unsigned char UART_Output_First = 0;

unsigned char TX_Ready =1;*/

//char Byte2[9];

//char Byte;

//------------------------------------------------- -------------------------------------------

-----

// GLOBAL VARIABLES

//------------------------------------------------- -------------------------------------------

-----

TEST_INFO EXTDATA TestInfo ;

SAVE_INFO EXTDATA XdataSaveBuffer ;

//================================================= ===========================================

=====

// main()

//================================================= ===========================================

=====

void Port (void )

{

char SFRPAGE_SAVE= SFRPAGE; // Save Current SFR page

SFRPAGE= CONFIG_PAGE; // Set SFR page

XBR0 = 0x04 ; // Enable UART0

XBR1 = 0x00 ;

XBR2 = 0x40 ; // Enable crossbar and weak pull-up

P0MDOUT|= 0x01 ; // Set TX pin to push-pull

P1MDOUT|= 0x40 ; // Set P1.6(LED) to push-pull

SFRPAGE= SFRPAGE_SAVE; // Restore SFR page

}

//INICIALITZACIO OSCILADOR

void OSCILLATOR_Init (void )

{

int i ; // Software timer

char SFRPAGE_SAVE= SFRPAGE; // Save Current SFR page

SFRPAGE= CONFIG_PAGE; // Set SFR page

OSCICN = 0x80 ; // Set internal oscillator to run

// at its slowest frequency

CLKSEL = 0x00 ; // Select the internal osc. as

// the SYSTEMCLOCK source

// Initialize external crystal oscillator to use 22 .1184 MHz crystal

OSCXCN= 0x67 ; // Enable external crystal osc.

for (i =0;i <256;i ++); // Wait at least 1ms

-2-


while (!(OSCXCN& 0x80 )); // Wait for crystal osc to settle

SFRPAGE= LEGACY_PAGE;

FLSCL |= 0x30 ; // Initially set FLASH read timing for

// 100MHz SYSTEMCLOCK (most conservative

// setting)

if (SYSTEMCLOCK<= 25000000 ) {

// Set FLASH read timing for <=25MHz

FLSCL &= ~0x30 ;

} else if (SYSTEMCLOCK<= 50000000 ) {


FLSCL &= ~0x20 ;

} else if (SYSTEMCLOCK<= 75000000 ) {


FLSCL &= ~0x10 ;

} else { // set FLASH read timing for <=100MHz

FLSCL &= ~0x00 ;

}

// Start PLL for 50MHz operation

SFRPAGE= PLL0_PAGE;

PLL0CN = 0x04 ; // Select EXTOSC as clk source

PLL0CN |= 0x01 ; // Enable PLL power

PLL0DIV = 0x04 ; // Divide by 4

PLL0FLT &= ~0x0f ;

PLL0FLT |= 0x0f ; // Set Loop Filt for (22/4)MHz input clock

PLL0FLT &= ~0x30 ; // Set ICO for 30-60MHz

PLL0FLT |= 0x10 ;

PLL0MUL = 0x09 ; // Multiply by 9

// wait at least 5us

for (i =0;i <256;i ++);

PLL0CN |= 0x02 ; // Enable PLL

while (PLL0CN & 0x10 == 0x00 ); // Wait for PLL to lock

SFRPAGE= CONFIG_PAGE;

CLKSEL = 0x02 ; // Select PLL as SYSTEMCLOCK source

SFRPAGE= SFRPAGE_SAVE; // Restore SFRPAGE

}

//INICIALITZACIO UART

void UART0_Init (void )

{

char SFRPAGE_SAVE;

SFRPAGE_SAVE= SFRPAGE; // Preserve SFRPAGE

SFRPAGE= TMR4_PAGE;

TMR4CN= 0x00 ; // Timer in 16-bit auto-reload up timer

// mode

-3-


TMR4CF= 0x08 ; // SYSCLK is time base; no output;

// up count only

RCAP4 = -((long ) SYSTEMCLOCK/BAUDRATE/16);

TMR4 = RCAP4;

TR4= 1; // Start Timer2


SCON0= 0x50 ; // 8-bit variable baud rate;

// 9th bit ignored; RX enabled

// clear all flags

SSTA0 = 0x1F; // Clear all flags; enable baud rate

// doubler (not relevant for these

// timers);

// Use Timer2 as RX and TX baud rate

// source;

ES0 = 1;

IP |= 0x10 ;

SFRPAGE= SFRPAGE_SAVE; // Restore SFRPAGE

}

void main (void )

{

int i ,j ,z;

//disable watch dog timer

WatchDogEnable (FALSE);

//disable all global interrupt


Port ();

LED13_ON();

// TMOD |=0x10; /* Set Mode (8-bit timer with reloa d) */

// TMOD &=0xDF;

// TH1 = 0x00; /* Reload TL1 to count 1 00 clocks */

// TL1 = 0x00;

// ET1 = 1; /* Enable Timer 1 I nterrupts */

// TR1 = 1; /* Start Timer 1 Ru nning */

//initiate system

SystemInit ();

//initiate default macpib [before cc2420Init()]

SetDefault_macpib ();

//initiate parameter releted with mac layer

init_MacParameter ();

//initiate parameter of phy layer

PHY_PIB_init ();

//initiate chipcon 2420

CC2420Init ();

//enable fifo interrupt

ENABLE_FIFOP_INT();

//initiate extended address

initExtendedAddress ();

//enable all global interrupt


-4-


//set transceiver with rx on

SPI_Strobe (CC2420_SRXON);

//reset pan

n_m_msg_t.msg.MLME_RESET_request.setDefaultPib = TRUE;

mResetReq();

memset((unsigned char *)&Button ,0,sizeof(Button ));

UART0_Init ();

OSCILLATOR_Init ();


IP =IP &0xEF;

LED13_ON();

coord ();

//IP=IP|0x02;


// reco();

while(1)//repeat forever

{



//enable interrupt

EA = 1;

//WatchDogEnable(FALSE);

F121PowerManage ();


//check button

CheckButton ();


//Process Button information

ProcessButton ();

//Process MAC to NWK buffer


ProcessMAC2NWK();


//deal with power economization


if (IsCoordinator ) ping ();

}

}

/*

void UART0_Interrupt (void) interrupt 4

{

int i;

SFRPAGE = UART0_PAGE;

if (RI0 == 1)

{

if( UART_Buffer_Size == 0) { // If new word is entered

UART_Input_First = 0; }

RI0 = 0; // Clear i nterrupt flag

-5-


Byte2[i] = SBUF0; // Rea d a character from UART

i++;

if (UART_Buffer_Size < UART_BUFFERSIZE)

{

UART_Buffer[UART_Input_First] = Byte; // S tore in array

UART_Buffer_Size++; // Update array's size

UART_Input_First++; // Update counter

}

}

if (TI0 == 1) // Check if tran smit flag is set

{

TI0 = 0; // Clear i nterrupt flag

if (UART_Buffer_Size != 1) // If buff er not empty

{

// If a new word is being output

if ( UART_Buffer_Size == UART_Input_First ) {

UART_Output_First = 0; }

// Store a character in the variable byte

Byte = UART_Buffer[UART_Output_First];

/* if ((Byte >= 0x61) && (Byte <= 0x7A)) { // If upper case letter

Byte -= 32; }

SBUF0 = Byte; // Transmi t to Hyperterminal

UART_Output_First++; // Update counter

UART_Buffer_Size--; // Decreas e array size

*//*

}

else

{

UART_Buffer_Size = 0; // Set th e array size to 0

TX_Ready = 1; // Indica te transmission complete

}

}

}*/

-6-


-7-

G:\test.cpp samedi 4 septembre 2010 14:00

//Interface homme machine USB

// test.cpp : définit le point d'entrée pour l'appl ication.

//

// Return codes

#include <windows.h>

#include "stdafx.h"

#include "test.h"

#include "SiUSBXp.h"

//#include "3DMeterCtrl.h"

#include <windowsx.h>

#include <stdio.h>

#include <string.h>

#include <iostream>

#define ID_PUSHBUTTON_1 110




#define SI_SUCCESS 0x00

#define SI_DEVICE_NOT_FOUND 0xFF

#define SI_INVALID_HANDLE 0x01

#define SI_READ_ERROR 0x02

#define SI_RX_QUEUE_NOT_READY 0x03

#define SI_WRITE_ERROR 0x04

#define SI_RESET_ERROR 0x05

#define SI_INVALID_PARAMETER 0x06

#define SI_INVALID_REQUEST_LENGTH 0x07

#define SI_DEVICE_IO_FAILED 0x08

#define SI_INVALID_BAUDRATE 0x09

#define SI_FUNCTION_NOT_SUPPORTED 0x0a

#define SI_GLOBAL_DATA_ERROR 0x0b

#define SI_SYSTEM_ERROR_CODE 0x0c

#define SI_READ_TIMED_OUT 0x0d

#define SI_WRITE_TIMED_OUT 0x0e

#define SI_IO_PENDING 0x0f

#define IDT_TIMER1 123456

#define IDT_TIMER2 654321

#define MAX_LOADSTRING 100

DWORD d;

DWORD dwBytesSucceed = 0;

DWORD dwBytesReadRequest = (sizeof(USB_iobuf )-4);

DWORD dwBytesWriteRequest = (sizeof(USB_iobuf )-4);

HDC hdc;

int stat ,len ;

char *c_ouv ,*c_fer ,*c_ptr , cmoy_ouv [200], cmoy_fer [200],c[200],*c_ouv1 ,*c_fer1 ,*c_ouv2 ,*

c_fer2 ,*c_ouv3 ,*c_fer3 ,cmoy_ouv1 [200], cmoy_fer1 [200],cmoy_ouv2 [200], cmoy_fer2 [200],

cmoy_ouv3 [200], cmoy_fer3 [200];

double sum_ouv,sum_fer ,sum_ouv1 ,sum_fer1 ,sum_ouv2 ,sum_fer2 ,sum_ouv3 ,sum_fer3 ; //total

ouverture fermeture

int quad,to [4],tf [4],t ,tps ,to1 [4],tf1 [4],to2 [4],tf2 [4],to3 [4],tf3 [4],tps1 ,tps2 ,tps3 ;

-1-


int cpt0 [4],cpt1 [4];

int cpt [2];

int *o,*f ,*w,*o1,*o2,*o3,*f1 ,*f2 ,*f3 ;

int ouv ,fer ,i ,j ,ouv1 ,fer1 ,ouv2 ,fer2 ,ouv3 ,fer3 ,i1 ,i2 ,i3 ;

int ** tableau ;

FILE *stream ;

LPCSTR tmp_cpt ;

// Variables globales :

HINSTANCE hInst ; // instance actuelle

TCHAR szTitle [MAX_LOADSTRING]; // Le texte de la barre de titre

TCHAR szWindowClass [MAX_LOADSTRING]; // le nom de la classe de fenêtre principale

// Pré-déclarations des fonctions incluses dans ce module de code :

ATOM MyRegisterClass (HINSTANCE hInstance );

BOOL InitInstance (HINSTANCE, int );

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);

DWORD dwNumDevices= 0;

SI_DEVICE_STRING devStr ;

int Error (UINT);

float moyenne(int *buff ,int i );

char print_val (int *buf , int i );

int APIENTRY _tWinMain (HINSTANCE hInstance ,

HINSTANCE hPrevInstance ,

LPTSTR lpCmdLine ,

int nCmdShow)

{

UNREFERENCED_PARAMETER(hPrevInstance );

UNREFERENCED_PARAMETER(lpCmdLine );

// TODO : placez ici le code.

MSG msg;

HACCEL hAccelTable ;

// Initialise les chaînes globales

LoadString (hInstance , IDS_APP_TITLE , szTitle , MAX_LOADSTRING);

LoadString (hInstance , IDC_TEST, szWindowClass , MAX_LOADSTRING);

MyRegisterClass (hInstance );

// Effectue l'initialisation de l'application :

if (!InitInstance (hInstance , nCmdShow))

{

return FALSE;

}

-2-


hAccelTable = LoadAccelerators (hInstance , MAKEINTRESOURCE(IDC_TEST));

// Boucle de messages principale :

while (GetMessage (&msg, NULL, 0, 0))

{

if (!TranslateAccelerator (msg.hwnd, hAccelTable , &msg))

{

TranslateMessage (&msg);

DispatchMessage (&msg);

}

}

return (int ) msg.wParam;

}

//

// FONCTION : MyRegisterClass()

//

// BUT : inscrit la classe de fenêtre.

//

// COMMENTAIRES :

//

// Cette fonction et son utilisation sont nécess aires uniquement si vous souhaitez que ce

code

// soit compatible avec les systèmes Win32 avant la fonction 'RegisterClassEx'

// qui a été ajoutée à Windows 95. Il est import ant d'appeler cette fonction

// afin que l'application dispose des petites ic ônes correctes qui lui sont

// associées.

//

ATOM MyRegisterClass (HINSTANCE hInstance )

{

WNDCLASSEX wcex;

wcex.cbSize = sizeof(WNDCLASSEX);

wcex.style = CS_HREDRAW| CS_VREDRAW;

wcex.lpfnWndProc = WndProc;

wcex.cbClsExtra = 0;

wcex.cbWndExtra = 0;

wcex.hInstance = hInstance ;

wcex.hIcon = LoadIcon (hInstance , MAKEINTRESOURCE(IDI_TEST ));

wcex.hCursor = LoadCursor (NULL, IDC_ARROW);

wcex.hbrBackground = (HBRUSH)(1);

wcex.lpszMenuName = MAKEINTRESOURCE(IDC_TEST);

wcex.lpszClassName = szWindowClass ;

wcex.hIconSm = LoadIcon (wcex.hInstance , MAKEINTRESOURCE(IDI_SMALL ));

return RegisterClassEx (&wcex);

}

//

// FONCTION : InitInstance(HINSTANCE, int)

//

// BUT : enregistre le handle de l'instance et cr ée une fenêtre principale

-3-


//

// COMMENTAIRES :

//

// Dans cette fonction, nous enregistrons le handle de l'instance dans une variable

globale, puis

// créons et affichons la fenêtre principale du programme.

//

BOOL InitInstance (HINSTANCE hInstance , int nCmdShow)

{

HWND hWnd;

hInst = hInstance ; // Stocke le handle d'instance dans la variable glo bale

hWnd = CreateWindowA (szWindowClass , szTitle , WS_OVERLAPPEDWINDOW,

CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance , NULL);

if (!hWnd)

{

return FALSE;

}

ShowWindow(hWnd, nCmdShow);

UpdateWindow (hWnd);

return TRUE;

}

//

// FONCTION : WndProc(HWND, UINT, WPARAM, LPARAM)

//

// BUT : traite les messages pour la fenêtre prin cipale.

//

// WM_COMMAND - traite le menu de l'application

// WM_PAINT - dessine la fenêtre principale

// WM_DESTROY - génère un message d'arrêt et retour ne

//

//

LRESULT CALLBACK WndProc(HWND hWnd, UINT message , WPARAM wParam, LPARAM lParam)

{

int wmId, wmEvent;

PAINTSTRUCT ps;

TCHAR greeting [] = _T("Péripherique connecté" );

TCHAR bad_greeting [] = _T("Péripherique non connecte" );

TCHAR read_greeting [] = _T("Read error" );

TCHAR write_greeting [] = _T("Write error" );

TCHAR ok_greeting [] = _T("Ok :)" );

TCHAR f_suppr [] = _T("Fichiers supprimés" );

TCHAR pot_greeting [sizeof(m_IObuffer .analog1 )];

unsigned char P0;

SI_STATUS status ;

int r ;

float ouv_moy, fer_moy ,ouv_moy1 , fer_moy1 ,ouv_moy2 , fer_moy2 ,ouv_moy3 , fer_moy3 ,q;

-4-


char *string ;

// timer t1;

static HWND hStatic4 , hStatic0 ,hStatic1 ,hStatic2 ,hStatic3 ,hStatic10 ,hStatic11 ,hStatic12 ,

hStatic13 ,hStatic20 ,hStatic21 ,hStatic22 ,hStatic23 ,hStatic5 ,hStatic30 ,hStatic31 ,hStatic32 ,

hStatic33 ,hStatic6 ,hBouton1 ,hBouton2 ,hBouton3 ,hBouton4 ,hStatic14 ,hStatic24 ,hStatic34 ,

hStatic7 ,hStatic8 ;

// UINT timer1;

switch (message)

{

case WM_CREATE:

// Timer 1 = USB, Timer 2=horloge (1s)

status = SI_GetNumDevices (&dwNumDevices );

tableau = new int * [2];

for ( int i =0 ; i < 2 ; i ++)

tableau [i ] = new int [3];

tableau [1][1]=1;

*tableau =(int *) realloc (*tableau ,2);

//porte 1

hStatic0 =CreateWindowEx (WS_EX_CLIENTEDGE,"STATIC" ,"" ,WS_VISIBLE | WS_CHILD |

SS_CENTER,350,50,50,300,hWnd,0,0,0);


SS_CENTER,400,50,50,300,hWnd,0,0,0);


SS_CENTER,350,400,100,20,hWnd,0,0,0);


SS_CENTER,350,425,100,20,hWnd,0,0,0);

hStatic4 =CreateWindowExA (WS_EX_CLIENTEDGE,"STATIC" ,"" ,WS_VISIBLE | WS_CHILD |

ES_AUTOHSCROLL,350,20,100,22,hWnd,0,0,0);

//porte 2


SS_CENTER,500,50,50,300,hWnd,0,0,0);


SS_CENTER,550,50,50,300,hWnd,0,0,0);


SS_CENTER,500,400,100,20,hWnd,0,0,0);


SS_CENTER,500,425,100,20,hWnd,0,0,0);



//porte 3


SS_CENTER,650,50,50,300,hWnd,0,0,0);


SS_CENTER,700,50,50,300,hWnd,0,0,0);


SS_CENTER,650,400,100,20,hWnd,0,0,0);


SS_CENTER,650,425,100,20,hWnd,0,0,0);



-5-


//porte 4


SS_CENTER,800,50,50,300,hWnd,0,0,0);


SS_CENTER,850,50,50,300,hWnd,0,0,0);


SS_CENTER,800,400,100,20,hWnd,0,0,0);


SS_CENTER,800,425,100,20,hWnd,0,0,0);



//reste

hStatic5 =CreateWindowEx (0,"STATIC" ,"" ,WS_VISIBLE | WS_CHILD | SS_CENTER, 100,50,150,

25,hWnd,0,0,0);

hStatic6 =CreateWindowEx (0,"STATIC" ,"Périphérique non connecté" ,WS_VISIBLE | WS_CHILD

| SS_CENTER, 50,25,200,25,hWnd,0,0,0);

hStatic7 =CreateWindowEx (0,"STATIC" ,"Moy. ouverture" ,WS_VISIBLE | WS_CHILD | SS_CENTER

, 250,400,100,25,hWnd,0,0,0);

hStatic8 =CreateWindowEx (0,"STATIC" ,"Moy. fermeture" ,WS_VISIBLE | WS_CHILD | SS_CENTER

, 250,425,100,20,hWnd,0,0,0);

hBouton1 =CreateWindowEx (0,"BUTTON","Vider fichiers" ,WS_VISIBLE | WS_CHILD, 50, 330,

100,25,hWnd,(HMENU)ID_PUSHBUTTON_1,0,0);

hBouton2 =CreateWindowEx (0,"BUTTON",">" ,WS_VISIBLE | WS_CHILD, 75, 50,25,25,hWnd,(

HMENU)ID_PUSHBUTTON_2,0,0);

hBouton3 =CreateWindowEx (0,"BUTTON","<" ,WS_VISIBLE | WS_CHILD, 50, 50,25,25,hWnd,(

HMENU)ID_PUSHBUTTON_3,0,0);

hBouton4 =CreateWindowEx (0,"BUTTON","Connecter" ,WS_VISIBLE | WS_CHILD, 50, 100,100,25,

hWnd,(HMENU)ID_PUSHBUTTON_4,0,0);

// initialisation des variables

cpt [1]=0;

cpt [0]=0;

to [0]=0;

tf [0]=0;

sum_ouv=0;

sum_fer =0;

ouv =0;

fer =0;

r =sprintf (c,"o : %d\n" ,to [0]);

c_ouv = (char *) malloc (sizeof(c));

r =sprintf (c,"f : %d\n" ,to [0]);

c_fer = (char *) malloc (sizeof(c));


c_ouv1 = (char *) malloc (sizeof(c));


c_fer1 = (char *) malloc (sizeof(c));









o1= (int *) malloc (0);

f1 = (int *) malloc (0);

-6-






status = SI_GetProductString (0, devStr , SI_RETURN_SERIAL_NUMBER);

r =sprintf (c,devStr );

Edit_SetText (hStatic5 ,c);

//return 0;

case WM_COMMAND:

wmId = LOWORD(wParam);

wmEvent = HIWORD(wParam);

// Analyse les sélections de menu :

switch (wmId)

{

case IDM_ABOUT:

DialogBox (hInst , MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About );

break;

case ID_PUSHBUTTON_1:

fopen_s (&stream ,"porte1.txt" ,"w" );

fclose ( stream );


fclose ( stream );


fclose ( stream );


fclose ( stream );

Button_Enable (hBouton1 ,0);

break;


if ((m_nDeviceNum+1)!=dwNumDevices ) m_nDeviceNum++; else m_nDeviceNum=(

dwNumDevices -1);

status = SI_GetProductString (m_nDeviceNum, devStr , SI_RETURN_SERIAL_NUMBER);

if (status ==SI_SUCCESS) r =sprintf (c,devStr ); else r =sprintf (c,"Non détécté" );


break;


if (m_nDeviceNum>0) m_nDeviceNum--;

status = SI_GetProductString (m_nDeviceNum, &devStr , SI_RETURN_SERIAL_NUMBER);

if (status ==SI_SUCCESS) r =sprintf (c,devStr ); else r =sprintf (c,"Non détécté" );


break;


if (m_IObuffer .led1 ==0)

{

status = SI_Open ((DWORD)m_nDeviceNum, &m_hUSBDevice);

m_IObuffer .led1 =1;

status = SI_Write (m_hUSBDevice, &m_IObuffer , dwBytesWriteRequest , &

dwBytesSucceed );

-7-


if (status ==SI_SUCCESS)

{

Edit_SetText (hStatic6 ,"Périphérique connecté" );


SetTimer (hWnd,IDT_TIMER2,1000,(TIMERPROC) NULL); // Timer 1 = USB,

Timer 2=horloge (1s)

SetTimer (hWnd,IDT_TIMER1,100,(TIMERPROC) NULL);

}

}

break;

case IDM_EXIT :

break;

default:

return DefWindowProc (hWnd, message, wParam, lParam );

}

break;

case WM_PAINT:

hdc = BeginPaint (hWnd, &ps);

// TODO : ajoutez ici le code de dessin...

EndPaint (hWnd, &ps);

break;

case WM_TIMER:

switch (wParam)

{

case IDT_TIMER1: //timer pour reception de trame usb

// lecture usb

memset(&m_IObuffer , 0, sizeof(USB_iobuf ));

dwBytesSucceed = 0;

status = SI_Read (m_hUSBDevice, &m_IObuffer , dwBytesReadRequest , &dwBytesSucceed );

//reupération et mise en forme des données

P0 = m_IObuffer .port & 0x0F;

//for(j=0;j>=4;j++)

//{}

if ((P0 & 0x01 )==1) cpt0 [0]=0; //porte fermé

if ((P0 & 0x01 )==0) cpt0 [0]=1; //porte ouverte

if (((P0 & 0x02 ) >> 1)==1) cpt0 [1]=0; //porte fermé

if (((P0 & 0x02 ) >> 1)==0) cpt0 [1]=1; //porte ouverte





if ((cpt1 [0]==0)&& (cpt0 [0]==1)) // detection ouverture porte 1

{

cpt1 [0]=cpt0 [0];

ouv ++;

-8-


o= (int *)realloc (o,ouv *sizeof(int ));

f = (int *)realloc (f ,ouv *sizeof(int ));

fopen_s (&stream ,"porte1.txt" ,"a+" );

if (i !=0) fprintf (stream ,"%d,%d\n" ,*(o+(i -1)),*(f +(i -1)));

fclose ( stream );

//fopen_s(&stream,"fermeture.txt","a+");

//if (i!=0) fprintf(stream,"%d\n",*(f+(i-1)));

//fclose( stream );

*(o+i )=to [0];

tps +=to [0];

to [0]=0;

}

if ((cpt1 [0]==1)&& (cpt0 [0]==0)) // detection fermeture porte1

{

cpt1 [0]=cpt0 [0];

fer ++;

*(f +i )=tf [0];

i ++;

tf [0]=0;

}


{

cpt1 [1]=cpt0 [1];

ouv1 ++;

o1= (int *)realloc (o1,ouv1 *sizeof(int ));

f1 = (int *)realloc (f1 ,ouv1 *sizeof(int ));


if (i1 !=0) fprintf (stream ,"%d,%d\n" ,*(o1+(i1 -1)),*(f1 +(i1 -1)));

fclose ( stream );



//fclose( stream );

*(o1+i1 )=to1 [0];

tps1 +=to1 [0];

to1 [0]=0;

}

if ((cpt1 [1]==1)&& (cpt0 [1]==0)) // detection fermeture porte 2

{

cpt1 [1]=cpt0 [1];

fer1 ++;

*(f1 +i1 )=tf1 [0];

i1 ++;

tf1 [0]=0;

}


{

cpt1 [2]=cpt0 [2];

ouv2 ++;





fclose ( stream );


-9-



//fclose( stream );

*(o2+i2 )=to2 [0];

tps2 +=to2 [0];

to2 [0]=0;

}


{

cpt1 [2]=cpt0 [2];

fer2 ++;

*(f2 +i2 )=tf2 [0];

i2 ++;

tf2 [0]=0;

}


{

cpt1 [3]=cpt0 [3];

ouv3 ++;





fclose ( stream );



//fclose( stream );

*(o3+i3 )=to3 [0];

tps3 +=to3 [0];

to3 [0]=0;

}


{

cpt1 [3]=cpt0 [3];

fer3 ++;

*(f3 +i3 )=tf3 [0];

i3 ++;

tf3 [0]=0;

}

// moyenne ouverture porte 1

j =0;

q=0;

while (j !=i )

{

q+=*(o+j );

j ++;

}

if (i !=0) ouv_moy=q/i ; else ouv_moy=0;

// moyenne fermeture porte 1

j =0;

q=0;

while (j !=i )

{

q+=*(f +j );

-10-


j ++;

}

if (i !=0) fer_moy =q/i ; else fer_moy =0;

/* if ((cpt1[3]==1)&& (cpt0[3]==0)) // detection fer meture

{

cpt1[3]=cpt0[3];

fer3++;

*(f3+i3)=tf3[0];

i3++;

tf3[0]=0;

}*/


j =0;

q=0;

while (j !=i1 )

{

q+=*(o1+j );

j ++;

}

if (i1 !=0) ouv_moy1 =q/i1 ; else ouv_moy1 =0;


j =0;

q=0;

while (j !=i1 )

{

q+=*(f1 +j );

j ++;

}

if (i1 !=0) fer_moy1 =q/i1 ; else fer_moy1 =0;


j =0;

q=0;

while (j !=i2 )

{

q+=*(o2+j );

j ++;

}



j =0;

q=0;

while (j !=i2 )

{

q+=*(f2 +j );

j ++;

}



j =0;

q=0;

while (j !=i3 )

{

-11-


q+=*(o3+j );

j ++;

}



j =0;

q=0;

while (j !=i3 )

{

q+=*(f3 +j );

j ++;

}


// affichage contenu tableau ouverture porte 1

r =sprintf (c_fer ,"f : %d\n" ,tf [0]);

r =sprintf (c_ouv ,"o : %d\n" ,to [0]);

if (i !=0)

{// affichage ouverture

j =i -1;

while (j >=0)

{

r =sprintf (c,"%ds\n" ,*(o+j ),i ,j );

c_ouv = (char *) realloc (c_ouv ,sizeof(c));

strcat (c_ouv ,c);

j --;

}

//affichage fermeture

j =i -1;

while (j >=0)

{

r =sprintf (c,"%ds\n" ,*(f +j ));

c_fer = (char *) realloc (c_fer ,sizeof(c));

strcat (c_fer ,c);

j --;

}

}


r =sprintf (c_fer1 ,"f : %d\n" ,tf1 [0]);

r =sprintf (c_ouv1 ,"o : %d\n" ,to1 [0]);

if (i1 !=0)


j =i1 -1;

while (j >=0)

{

r =sprintf (c,"%ds\n" ,*(o1+j ),i1 ,j );

c_ouv1 = (char *) realloc (c_ouv1 ,sizeof(c));

strcat (c_ouv1 ,c);

j --;

}

-12-



j =i1 -1;

while (j >=0)

{

r =sprintf (c,"%ds\n" ,*(f1 +j ));

c_fer1 = (char *) realloc (c_fer1 ,sizeof(c));

strcat (c_fer1 ,c);

j --;

}

}




if (i !=0)


j =i2 -1;

while (j >=0)

{

r =sprintf (c,"%ds\n" ,*(o2+j ));


strcat (c_ouv2 ,c);

j --;

}


j =i2 -1;

while (j >=0)

{



strcat (c_fer2 ,c);

j --;

}

}




if (i3 !=0)


j =i3 -1;

while (j >=0)

{

r =sprintf (c,"%ds\n" ,*(o3+j ));


strcat (c_ouv3 ,c);

j --;

}


j =i3 -1;

while (j >=0)

{

-13-




strcat (c_fer3 ,c);

j --;

}

}

// affichage porte 1

r =sprintf (cmoy_ouv , "%.2f " ,ouv_moy);

r =sprintf (cmoy_fer , "%.2f" ,fer_moy );


r =sprintf (cmoy_ouv1 , "%.2f " ,ouv_moy1 );

r =sprintf (cmoy_fer1 , "%.2f" ,fer_moy1 );







Edit_SetText (hStatic0 ,c_ouv );

Edit_SetText (hStatic1 ,c_fer );

Edit_SetText (hStatic10 ,c_ouv1 );

Edit_SetText (hStatic11 ,c_fer1 );





c_ptr =cmoy_ouv ;

Edit_SetText (hStatic2 ,c_ptr );

c_ptr =cmoy_fer ;


c_ptr =cmoy_ouv1 ;


c_ptr =cmoy_fer1 ;


c_ptr =cmoy_ouv2 ;


c_ptr =cmoy_fer2 ;


c_ptr =cmoy_ouv3 ;


c_ptr =cmoy_fer3 ;


if (cpt1 [0]==1) Edit_SetText (hStatic4 ,"Porte 1 ouv." ); else Edit_SetText (hStatic4

,"Porte 1 fermée" );

if (cpt1 [1]==1) Edit_SetText (hStatic14 ,"Porte 2 ouv." ); else Edit_SetText (

hStatic14 ,"Porte 2 fermée" );



-14-




break;

case IDT_TIMER2 : //timer pour horloge (toutes les secondes)

if (cpt0 [0]==0) to [0]++;

if (cpt0 [0]==1) tf [0]++;

if (cpt0 [1]==0) to1 [0]++;

if (cpt0 [1]==1) tf1 [0]++;

if (cpt0 [2]==0) to2 [0]++;

if (cpt0 [2]==1) tf2 [0]++;

if (cpt0 [3]==0) to3 [0]++;

if (cpt0 [3]==1) tf3 [0]++;


break;

default : break;

}

break;

case WM_DESTROY:

m_IObuffer .led1 =0;

status = SI_Write (m_hUSBDevice, &m_IObuffer , dwBytesWriteRequest , &dwBytesSucceed

);

DestroyWindow (hWnd);

PostQuitMessage (0);

break;

default:

return DefWindowProc (hWnd, message, wParam, lParam );

}

return 0;

}

// Gestionnaire de messages pour la boîte de dialog ue À propos de.

INT_PTR CALLBACK About(HWND hDlg, UINT message , WPARAM wParam, LPARAM lParam)

{

UNREFERENCED_PARAMETER(lParam );

switch (message)

{

case WM_INITDIALOG:

return (INT_PTR)TRUE;

case WM_COMMAND:

if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)

{

EndDialog (hDlg , LOWORD(wParam));

return (INT_PTR)TRUE;

}

break;

}

return (INT_PTR)FALSE;

}

-15-

G:\USB_MAIN.c samedi 4 septembre 2010 14:01

//Programme USB microcontroleur

//------------------------------------------------- ----------------------------

// USB_MAIN.c

//------------------------------------------------- ----------------------------


//

// AUTH: JS

// DATE: 22 FEB 02

//

//

// Target: C8051F34x

// Tool chain: KEIL C51 6.03 / KEIL EVAL C51

// SDCC 2.8.0

//

// REVISIONS:

// 5/26/09 - ES: Ported Code to compiler independe nt format.

// Compatible with SDCC.

// 10/11/06 - PKC: Changed port I/O and ADC Mux set tings to accommodate

// potentiometer at P2.5 on the 'F340 Ta rget Board; Changed

// USBXpress API interrupt to 17.

// 1/24/06 - PKC: Changed 'F320.h to 'F340.h

// 4/4/03 - DM: Ported code to use USB_API.lib instead of custom solution.

// 5/6/03 - DM: Made changes to use new driver wi th better throughput.

// 11/22/02 - DM: Added support for switches and s ample USB

// interrupt application.

//

// Acceptable Warnings: In Keil, Warning L15: Multi ple call to USB_CLOCK_START

// can be safely ignored.

//

//------------------------------------------------- ----------------------------

// Includes

//------------------------------------------------- ----------------------------

#include "compiler_defs.h"

#include "C8051f340_defs.h"

#include <stddef.h>

#include "USB_API.h"

#define INTERRUPT_USBXpress 17

//------------------------------------------------- ----------------------------

// Global CONSTANTS

//------------------------------------------------- ----------------------------

SBIT (Led1, SFR_P2, 2); // LED='1' means ON

SBIT (Led2, SFR_P2, 3);

#define Sw1 0x01 // These are the port2 bits for Sw1

#define Sw2 0x02 // and Sw2 on the development board

U8 works =0;

U8 Switch1State = 0; // Indicate status of switch

U8 Switch2State = 0; // starting at 0 == off

U8 Toggle1 = 0; // Variable to make sure each button

U8 Toggle2 = 0; // press and release toggles switch

U8 Potentiometer = 0x00 ; // Last read potentiometer value

-1-


U8 Temperature = 0x00 ; // Last read temperature sensor value

U8 Out_Packet [8] = {0,0,0,0,0,0,0,0}; // Last packet received from host

U8 In_Packet [8] = {0,0,0,0,0,0,0,0}; // Next packet to sent to host

/*** [BEGIN] USB Descriptor Information [BEGIN] *** /

SEGMENT_VARIABLE(USB_VID, U16, SEG_CODE) = 0x10C4;

SEGMENT_VARIABLE(USB_PID, U16, SEG_CODE) = 0xEA61;

SEGMENT_VARIABLE(USB_MfrStr [], U8, SEG_CODE) = // Manufacturer String

{

0x1A,

0x03 ,

'S' ,0,

'i' ,0,

'l' ,0,

'i' ,0,

'c' ,0,

'o' ,0,

'n' ,0,

' ' ,0,

'L' ,0,

'a' ,0,

'b' ,0,

's' ,0,

};

SEGMENT_VARIABLE(USB_ProductStr [], U8, SEG_CODE) = // Product Desc. String

{

0x10 ,

0x03 ,

'U' ,0,

'S' ,0,

'B' ,0,

' ' ,0,

'A' ,0,

'P' ,0,

'I' ,0

};

SEGMENT_VARIABLE(USB_SerialStr [], U8, SEG_CODE) = // Serial Number String

{

0x1A,

0x03 ,

'S' ,0,

'i' ,0,

'l' ,0,

'i' ,0,

'c' ,0,

'o' ,0,

'n' ,0,

' ' ,0,

'L' ,0,

'a' ,0,

'b' ,0,

's' ,0,

};

-2-


SEGMENT_VARIABLE(USB_MaxPower, U8, SEG_CODE) = 15; // Max current = 30 mA

// (15 * 2)

SEGMENT_VARIABLE(USB_PwAttributes , U8, SEG_CODE) = 0x80 ; // Bus-powered,

// remote wakeup not

// supported

SEGMENT_VARIABLE(USB_bcdDevice , U16, SEG_CODE) = 0x0100 ; // Device release

// number 1.00

/*** [ END ] USB Descriptor Information [ END ] *** /

SEG_CODEconst U8 TEMP_ADD= 112; // This constant is added to Temperature

//------------------------------------------------- ----------------------------

// Function Prototypes

//------------------------------------------------- ----------------------------

void Timer_Init (void ); // Start timer 2 for use by ADC and to check

switches

void Adc_Init (void );

void Port_Init (void );

void Suspend_Device (void );

void Initialize (void );

//------------------------------------------------- ----------------------------

// Main Routine

//------------------------------------------------- ----------------------------

void main (void )

{

PCA0MD&= ~0x40 ; // Disable Watchdog timer

USB_Clock_Start (); // Init USB clock *before* calling USB_Init

USB_Init (USB_VID,USB_PID,USB_MfrStr ,USB_ProductStr ,USB_SerialStr ,USB_MaxPower,

USB_PwAttributes ,USB_bcdDevice );

Initialize ();

USB_Int_Enable ();

while (1)

{

// It is possible that the contents of the followin g packets can change

// while being updated. This doesn't cause a probl em in the sample

// application because the bytes are all independen t. If data is NOT

// independent, packet update routines should be mo ved to an interrupt

// service routine, or interrupts should be disable d during data updates.

if (Out_Packet [0] == 1)

{Led1 = 1; // Update status of LED #1

works =1;

}

else

{

works = 0;

Led1 =0;

}

if (Out_Packet [1] == 1) Led2 = 1; // Update status of LED #2

else Led2 = 0;

P1 = (Out_Packet [2] & 0x0F); // Set Port 1 pins

-3-


In_Packet [0] = Switch1State ; // and switch 1 to host

In_Packet [1] = Switch2State ; // and switch 2 to host

In_Packet [2] = (P0 & 0x0F); // Port 0 [0-3] (make sure j9 & j10 jumpered)

In_Packet [3] = Potentiometer ; // Potentiometer value

In_Packet [4] = Temperature ; // Temperature sensor value*/

}

}

//------------------------------------------------- ----------------------------

// Initialization Subroutines

//------------------------------------------------- ----------------------------

//-------------------------

// Port_Init

//-------------------------

// Port Initialization

// - Configure the Crossbar and GPIO ports.

//

void Port_Init (void )

{

P2MDIN = 0xDF; // Port 2 pin 5 set as analog input

P0MDOUT|= 0x0F; // Port 0 pins 0-3 set high impedence

P1MDOUT|= 0x0F; // Port 1 pins 0-3 set high impedence

P2MDOUT|= 0x0C; // Port 2 pins 0,1 set high impedence

P2SKIP = 0x20 ; // Port 1 pin 7 skipped by crossbar

XBR0 = 0x00 ;

XBR1 = 0x40 ; // Enable Crossbar

}

//-------------------------

// Timer_Init

//-------------------------

// Timer initialization

// - 1 mhz timer 2 reload, used to check if switch pressed on overflow and

// used for ADC continuous conversion

//

void Timer_Init (void )

{

TMR2CN = 0x00 ; // Stop Timer2; Clear TF2;

CKCON &= ~0xF0; // Timer2 clocked based on T2XCLK;

TMR2RL = -(24000000 / 12); // Initialize reload value

TMR2 = 0xffff ; // Set to reload immediately

ET2 = 1; // Enable Timer2 interrupts

TR2 = 1; // Start Timer2

}

//-------------------------

// Adc_Init

//-------------------------

// ADC initialization

-4-


// - Configures ADC for single ended continuous con version or Timer2

//

void Adc_Init (void )

{

REF0CN = 0x0E; // Enable voltage reference VREF

AMX0P = 0x1E; // Positive input starts as temp sensor

AMX0N= 0x1F; // Single ended mode(negative input = gnd)

ADC0CF = 0xF8; // SAR Period 0x1F, Right adjusted output

ADC0CN = 0xC2; // Continuous converion on timer 2 overflow

// with low power tracking mode on

EIE1 |= 0x08 ; // Enable conversion complete interrupt

}

//-------------------------

// Suspend_Device

//-------------------------

// Called when a DEV_SUSPEND interrupt is received.

// - Disables all unnecessary peripherals

// - Calls USB_Suspend()

// - Enables peripherals once device leaves suspend state

//

void Suspend_Device (void )

{

// Disable peripherals before calling USB_Suspend()

P0MDIN = 0x00 ; // Port 0 configured as analog input




ADC0CN&= ~0x80 ; // Disable ADC0

ET2 = 0; // Disable Timer 2 Interrupts

USB_Suspend(); // Put the device in suspend state

// Once execution returns from USB_Suspend(), devic e leaves suspend state.

// Reenable peripherals

ADC0CN|= 0x80 ; // Enable ADC0

P0MDIN = 0xFF;

P1MDIN = 0x7F; // Port 1 pin 7 set as analog input

P2MDIN = 0xFF;

P3MDIN = 0x01 ;

ET2 = 1; // Enable Timer 2 Interrupts

}

//-------------------------

// Initialize

//-------------------------

// Called when a DEV_CONFIGURED interrupt is receiv ed.

// - Enables all peripherals needed for the applica tion

//

void Initialize (void )

{

Port_Init (); // Initialize crossbar and GPIO

Timer_Init (); // Initialize timer2

-5-


Adc_Init (); // Initialize ADC

}

//-------------------------

// Timer2_ISR

//-------------------------

// Called when timer 2 overflows, check to see if s witch is pressed,

// then watch for release.

//

INTERRUPT(Timer2_ISR , INTERRUPT_TIMER2)

{

if (!(P2 & Sw1)) // Check for switch #1 pressed

{

if (Toggle1 == 0) // Toggle is used to debounce switch

{ // so that one press and release will

Switch1State = ~Switch1State ; // toggle the state of the switch sent

Toggle1 = 1; // to the host

}

}

else Toggle1 = 0; // Reset toggle variable

if (!(P2 & Sw2)) // This is the same as above, but for Switch2

{

if (Toggle2 == 0)

{

Switch2State = ~Switch2State ;

Toggle2 = 1;

}

}

else Toggle2 = 0;

TF2H = 0; // Clear Timer2 interrupt flag

}

//-------------------------

// Adc_ConvComplete_ISR

//-------------------------

// Called after a conversion of the ADC has finishe d

// - Updates the appropriate variable for either po tentiometer or temperature sensor

// - Switches the Adc multiplexor value to switch b etween the potentiometer and temp sensor

//

INTERRUPT(Adc_ConvComplete_ISR , INTERRUPT_ADC0_EOC)

{

if (AMX0P == 0x1E) // This switches the AMUX between

{ // the temperature sensor and the

Temperature = ADC0L; // potentiometer pin after each

Temperature += TEMP_ADD;

AMX0P = 0x04 ; // switch to potentiometer ('F340 - P2.5)

ADC0CF = 0xFC; // place ADC0 in left-adjusted mode

}

else

{

Potentiometer = ADC0H;

AMX0P = 0x1E; // switch to temperature sensor

ADC0CF = 0xF8; // place ADC0 in right-adjusted mode

-6-


}

AD0INT = 0;

if(works ==1) Block_Write (In_Packet , 8);

}

// Example ISR for USB_API

INTERRUPT(USB_API_TEST_ISR, INTERRUPT_USBXpress)

{

U8 INTVAL = Get_Interrupt_Source ();

if (INTVAL & RX_COMPLETE)

{

Block_Read (Out_Packet , 8);

}

if (INTVAL & DEV_SUSPEND)

{

Suspend_Device ();

}

if (INTVAL & DEV_CONFIGURED)

{

Initialize ();

}

}

// Startup code for SDCC to disablt WDT before init ializing variables so that

// a reset does not occur

#if defined SDCC

void _sdcc_external_startup (void )

{

PCA0MD&= ~0x40 ; // Disable Watchdog timer

}

#endif

// ================================================ ============================

// *** END OF FILE ***

// ================================================ ============================

-7-

Réseau sans fil dans le cadre d'un bâtiment intelligent et...

Documents

Transcript of Réseau sans fil dans le cadre d'un bâtiment intelligent et...