Communication en simplex entre deux ordinateurs par utilisation du canal lumineux

Communication en simplex entre deux ordinateurs par utilisation du canal lumineux

Résumé


Le projet de fin d’études qui nous a été proposé a pour objectif de transmettre une information à distance sans fil, en utilisant comme support de transmission la lumière à l’instar de la fibre optique.

  • La transmission se fait dans l’espace par émission infrarouge codé par le microcontrôleur Arduino.
  • La réception se fait par un photo-transistor qui convertit la lumière au courant et le transmet à l’Arduino qui décode.

Les outils de programmation sont le langage C et le Visual Basic.

L’envoi du message et la réception se fait entre deux ordinateurs.

Introduction


Le présent mémoire a pour objectif d’exposer le travail réalisé tout au long du projet de fin d’études, dont l’intitulé est : « La communication en simplex entre deux ordinateurs en utilisant un canal lumineux ».

Ce projet est basé sur la transmission des informations par infrarouge de texte codé, et les afficher dans une interface en Visual Basic. L’émission et la réception des informations nécessitent un émetteur-récepteur infrarouge et une programmation au préalable de l’Arduino et la création d’une interface en Visual Basic.

Ce dispositif peut servir, moyennant l’utilisation d’un émetteur laser et d’un récepteur laser, de relier deux immeubles pour la communication numérique.

Ce même dispositif de communication peut être utilisé dans plusieurs domaines à la maison et les domaines de la sécurité. Notre choix de l’utiliser dans les domaines de sécurité est basé sur la transmission d’un langage chiffré, en termes de réduction des risques et garantir une émission-réception par des termes spécifiques.

Le premier chapitre de ce travail est dédié aux généralités sur l’Arduino, la partie émission-réception et le Visual BASIC.

Nous présentons une étude d’interfaçage et une explication détaillée des programmes utilisés au deuxième chapitre.

Le troisième chapitre présentera le schéma et l’explication de la maquette de projet.

Cahier des charges


Ce mémoire a pour but de faciliter la communication entre deux postes de travail sans intervention humaine, transformé les textes sont codés et affichés dans une interface en Visual Basic.

Nous avons opté pour le Code Morse comme langage de transmission des informations.

Le dispositif de communication est constitué de deux Arduino, une diode émettrice d’infrarouge et un récepteur infrarouge. Dans ce fait il est demandé que :

1. La partie émettrice soit conçue de :

  •    Un ordinateur.
  •    Un Arduino .
  •    Un émetteur infrarouge.
  •    Codage en Morse.
  •    Une interface en Visual Basic qui permet d’afficher et d’envoyer le message.

2. La partie réceptrice soit conçue de :

  •    Un ordinateur
  •    Un Arduino
  •    Un récepteur infrarouge
  •    Une programmation d’Arduino du Code Morse
  •    Une interface en Visual Basic qui permet d’afficher le message reçu.

Structure de cahier des charges

Communication en simplex entre deux ordinateurs par utilisation du canal lumineux

Chapitre 1 : Généralités


I. L’Arduino

1. Définition

Les cartes Arduino sont des cartes électroniques matériellement libres (open source) sur lesquelles se trouve un microcontrôleur programmable basé sur une simple carte d’entrée-sortie qui est un environnement de développement qui met en œuvre le langage Processing.

L’Arduino peut être utilisé pour construire des objets interactifs indépendants comme il peut être connecté à un ordinateur pour communiquer avec des logiciels, pour cela l’Arduino utilise la plupart des entrées/sorties du microcontrôleur pour l’interfaçage avec les autres circuits.

Dans le cadre de notre projet nous avons utilisé le modèle UNO  de la société ARDUINO qui est une carte électronique dont le cœur est un microcontrôleur ATMEL  de référence AT Méga 328, et de composants complémentaires qui facilitent la programmation et l’interfaçage avec d’autres circuits. Chaque modèle possède au moins un régulateur   linéaire 5 V et un oscillateur à une horloge (quartz) cadencée à 16 MHz.

Le microcontrôleur peut être programmé pour analyser et produire des signaux électriques, de manière à effectuer des tâches très diverses comme la domotique (le contrôle des appareils domestiques, l’éclairage, le chauffage…), le pilotage d’un robot, de l’informatique embarquée. L’intérêt principal de cette carte Arduino est sa facilité d’utilisation.

Figure 1: Les différents composants et ports d’entrées/sorties de la carte Arduino.
Figure 1: Les différents composants et ports d’entrées/sorties de la carte Arduino.

2. Domaines d’utilisations

Petit à petit les cartes électroniques sont développées, mais pour le moment l’Arduino reste majoritaire dans de nombreux cas.

Si l’avantage de l’utilisation de la carte Arduino UNO par rapport aux autres cartes d’Arduino, en effet l’Arduino UNO offre de nombreux points positifs comme l’environnement de programmation qui est clair et simple, la multiplateforme tourne sous Windows, Macintosh et linux, le logiciel et matériel open source est extensible.

Par sa simplicité d’utilisation, Arduino UNO est utilisé dans beaucoup d’applications comme l’électronique industrielle et embarquée, le modélisme, la domotique mais aussi dans des différents domaines comme l’art et le spectacle, ou bien peut être connecté à un ordinateur pour communiquer avec ses logiciels.

Une carte Arduino, comme toutes les cartes à microcontrôleur, permet de piloter un système de manière interactive à partir du programme que l’on aura défini et mis dans sa mémoire. Par exemple gérer automatiquement l’ouverture d’une porte de garage, envoyer un SMS quand le jardin est trop sec et gérer le système d’arrosage à distance, piloter un robot.

3. Les différents types d’Arduino

Il existe différentes cartes d’Arduino utilisables selon leurs fonctionnalités :

i. La carte Arduino UNO

C’est la carte idéale pour découvrir l’environnement Arduino, elle permet à tout débutant de réaliser ses projets.

Figure 2: Une carte Arduino UNO.
Figure 2: Une carte Arduino UNO.

Sa simplicité devient un handicape lorsqu’il s’agit de multiplier les périphériques, de manipuler des algorithmes lourds ou d’interaction avec les  OS Android pour lesquels d’autres cartes Arduino sont plus adoptées.

ii. La carte Arduino LEONARDO

C’est la carte qui est prévue pour succéder à la carte ARDUINO UNO en présentant des caractéristiques équivalentes mais une ergonomie revue et une stabilité plus éprouvée.

Figure 3: Une carte Arduino LEONARDO.
Figure 3: Une carte Arduino LEONARDO.

Sa diffusion moins importante limite le support utilisateur disponible sur le net.

iii. La carte Arduino MEGA

La carte ARDUINO MEGA est la carte la plus diffusée après la carte ARDUINO UNO. Elle offre un nombre d’entrées/sorties beaucoup plus important (54 contre 14), un processeur plus puissant doté d’une mémoire plus vaste qui permet d’exploiter des algorithmes plus complexes.

Figure 4: Une carte Arduino MEGA
Figure 4: Une carte Arduino MEGA
iv. La carte ARDUINO MEGA ADK

La carte ARDUINO MEGA ADK offre les mêmes caractéristiques techniques que la carte ARDUINO MEGA mais son port USB permet de la connecter avec un environnement Android ouvrant de nouvelles perspectives d’interaction avec le monde des Smartphones et des capteurs dont ils sont dotés. Sa mise en œuvre nécessite par contre de solides connaissances en Java et la capacité à développer ses propres applications.

Figure 5: Une carte Arduino MEGA ADK.
Figure 5: Une carte Arduino MEGA ADK.
v. La carte Arduino DUE

La carte ARDUINO DUE est une évolution de la carte ARDUINO MEGA et offre des performances réputées 3 fois supérieures. Elle permet de manipuler rapidement des algorithmes lourds particulièrement utiles dans le monde de la robotique par exemple.

Figure 6: Une carte Arduino DUE.
Figure 6: Une carte Arduino DUE.
 vi. La carte Arduino NANO

La carte ARDUINO NANO n’est ni plus ni moins qu’une carte ARDUINO UNO miniaturisée. Sa taille et son poids réduits la destinent à une utilisation dans des espaces réduits ou dans des applications de robotique ou de modélisme pour lesquels le poids et la taille sont des facteurs déterminants.

Figure 7: Une carte Arduino NANO.
Figure 7: Une carte Arduino NANO.
 vii. La carte Arduino MINI PRO

La carte ARDUINO MINI PRO est une carte ARDUINO UNO simplifiée à l’extrême permettant néanmoins de piloter de petits projets ou certains éléments d’un projet. Cette carte n’intègre pas de port USB ce qui rend sa connectivité délicate.

Figure 8: Une carte Arduino MINI PRO.
Figure 8: Une carte Arduino MINI PRO.
 viii. La carte ARDUINO YUN

La carte ARDUINO YUN, récemment proposée par ARDUINO, est conçue pour contrer les avantages de la carte RASPBERRY. Elle est un dérivé de la carte LEONARDO et a pour objectif de combiner la puissance de Linux avec la facilité d’utilisation d’une carte ARDUINO. Elle est également la première carte ARDUINO à être dotée nativement d’un wifi intégré.

Figure 9: Une carte Arduino YUN
Figure 9: Une carte Arduino YUN

4. La liaison RS-232

i. Définition et utilité 

La liaison RS232 est une liaison série qui permet de transmettre des informations sans avoir à transmettre l’horloge de synchronisation. Elle utilise des tensions de fonctionnement non compatibles avec la logique 5V car elle fonctionne sur les niveaux +12V ou -12V. Son principal intérêt est le nombre de fils réduits, puisque trois suffisent à la transmission d’informations : un fil pour émettre, un autre pour recevoir et un dernier pour la masse. Dans notre projet, nous avons dû prévoir la connexion du port série du PC à la plaquette d’Arduino UNO.

La transmission série de type RS232 est l’une des transmissions dites asynchrones , car il n’y a pas de signal d’horloge dans le câble ; cela implique que l’émetteur et le récepteur soient configurés au même débit, que l’on exprime en bits par seconde, et que la configuration de la liaison soit identique sur les deux postes informatiques utilisés (nombre de bits de chaque donnée identique), nombre de bits de stop (qui permettent de délimiter chaque donnée) identique et utilisation d’un même type de bit de parité (qui est un des moyens utilisés pour vérifier l’intégrité des données transmises à la réception) sur les deux postes.

Il est tout à fait possible d’obtenir une liaison série RS232 à partir d’un câble convertisseur USB/RS232, on se limitera ici à la mise en œuvre d’une liaison série entre deux postes de travail.

ii. Caractéristique 

La transmission d’informations nécessite l’utilisation d’un langage commun (écrit ou oral) ou d’un code commun. Il en est de même pour la transmission d’informations numériques entre deux postes de travail ou entre un poste de travail et un équipement, ce qui nécessite l’utilisation de règles communes : type de liaison, vitesse de transmission, format des données transmises, détection d’erreurs …

Vitesse de transmission : elle se compte en bauds (bits par seconde). On peut choisir 1200 bauds, 2400 bauds, 4800 bauds, 9600 bauds, 19200 bauds…

Même si ce type de communication est peu à peu remplacé par l’USB, la liaison série de type RS232 est encore très utilisée dans l’industrie, pour connecter différents appareils électroniques (automate, appareil de mesure…) mais aussi pour la fabrication de matériels informatiques professionnels. En effet, la plupart des composantes (commutateur administrable, routeur…) d’un système de gestion de réseau informatique professionnel contiennent une liaison série de type RS232.

II. L’émetteur-récepteur infrarouge

1.Définition

Un émetteur-récepteur est un équipement électronique combinant un récepteur et un émetteur qui partagent des circuits communs.

i. Diodes émettrice infrarouge :

Les diodes émettrices infrarouge sont des diodes comme les LED mais qui émettent dans   l’infrarouge, ils ont donc un rayonnement invisible.

Les émetteurs sont des diodes infra-rouges comparables aux LED fonctionnant dans le spectre visible. Elles sont alimentables en continu sous une tension similaire, de l’ordre de 2 à 3V. Leur courant nominal est d’environ 10-20mA. Mais nous verrons qu’il est possible, afin d’optimiser les performances et les distances de transmission, que l’on peut, en modulant le signal, c’est-à-dire en le scindant en plusieurs parties à une certaine fréquence, par exemple 40 kHz, qu’on peut appliquer via un transistor, un fort courant 1de quelques centaines de mA à la diode pendant la transmission.

Le but d’un émetteur est de transmettre à distance des informations très variées : voix, lumière ou musique, photographiques ou films, séquence de lettres ou de chiffres donc un transducteur sera nécessaire pour le convertir sous forme électrique, dont la fréquence est comprise entre 20Hz et 20 KHz, c’est-à-dire les fréquences audibles, c’est ainsi que l’évolution de la technologie de transmission s’est manifestée positivement avec les années et son développement a donné une propagation des composantes.

Figure 10: Des diodes émettrices infrarouges.
Figure 10: Des diodes émettrices infrarouges.
ii. Détecteur infrarouge (récepteur):  

Les récepteurs classiques sont des photodiodes ou phototransistors se comportant comme leurs homologues non optiques, la tension à leur borne ou le courant les traversant variant selon la quantité de lumière reçue, exprimée en mW/cm².

Un détecteur de rayonnement IR transforme ce rayonnement incident en un signal électrique. On distingue deux types de détecteurs:

  • Les détecteurs thermiques qui ne sont sensibles qu’à l’énergie du rayonnement.
  • Les détecteurs quantiques qui transforment les photons incidents en charges électriques.
Figure 11: Un récepteur infrarouge.
Figure 11: Un récepteur infrarouge.
iii. L’infrarouge

Le rayonnement infrarouge (IR) est un rayonnement électromagnétique  de longueur d’onde comprise entre 0,8 μm (lumière rouge visible) et 1 mm (micro-ondes).

La technologie infrarouge est basée sur le principe de la lumière infrarouge invisible à l’œil nu. Au-delà de la lumière rouge, visible, on trouve le proche infrarouge utilisé dans les barrières à infrarouge actif. Le faisceau des colonnes, d’une longueur d’onde supérieure à celle de la lumière visible crée donc un mur immatériel et invisible.

Actuellement on réalise des émetteurs avec des meilleurs performances et des dimensions réduites ainsi des types d’émetteurs fonctionnent automatiquement et même commandés à distance ce qui la favorise dans les années 60 l’exception des émetteurs AM, aussi plusieurs solutions pratiques et économiques ont été adoptées dont le principe de base est l’introduction des informations dans une fréquence propre à chaque émetteur appelée porteuse d’où le principe de modulation.

2. Domaines d’utilisations

Les principaux domaines d’applications concernent :

i. Industriel :

Dans le domaine industriel, l’imagerie thermique permet de détecter les points chauds annonciateurs de pannes électriques ou mécaniques. Les armoires électriques et les centres de commande du moteur sont régulièrement inspectés à l’aide d’une caméra thermique La détection précoce des anomalies permet d’éviter les arrêts de production et de faire des économies.

ii. Bâtiment :

Les professionnels du bâtiment recherchent les défauts d’isolation et d’autres imperfections à l’aide d’une caméra thermique. Les réparations qui s’ensuivent procurent des économies d’énergie considérables.

iii. Surveillance aux frontières :

Les agents de sécurité aux frontières protègent leur pays contre les contre bandières et d’autres intrus. Avec une caméra thermique, ils sont capables de distinguer une personne à 20 km de distance dans l’obscurité totale.

iv. Sécurité :

Pour sécuriser certaines installations comme les ports, les aéroports, les centrales nucléaires, les entrepôts, les immeubles, et biens d’autres contre les intrus, nos clients utilisent des caméras thermiques.

v. Recherche :

L’imagerie thermique joue aussi un rôle crucial dans la recherche fondamentale et appliquée. Elle peut accélérer la conception des produits, et donc avancer leur mise sur le marché. Pour ces applications exigeantes, FLIR Système commercialise des caméras thermiques aux performances très élevées.

vi. Maritime :

Sur les bateaux de plaisance et commerciaux, les caméras thermiques FLIR sont utilisées pour la navigation de nuit, la sécurité à bord, la recherche d’homme à la mer et la détection des pirates.

vii. Véhicule :

Les caméras thermiques FLIR sont installées dans certaines voitures pour améliorer la vision du conducteur, qui voit jusqu’à 4 fois plus loin qu’avec les phares. Elles sont également installées dans certains véhicules spéciaux utilisés par les pompiers, les mineurs ou l’armée.

 viii. Automation :

Les caméras thermiques permettent aussi de surveiller en permanence le processus de production et d’éviter les incendies.

ix. Police :

Les policiers les utilisent pour voir sans être vu. ILS peuvent facilement trouver des suspects dans l’obscurité totale, sans toutefois révéler leur propre position.

x. Détection de gaz :

Les fuites de certains gaz sont clairement visibles avec une caméra thermique.

III. Le Visual Basic

1.Définition

Le Visual Basic est un langage de programmation de troisième génération, de style orienté objets, conçu par la compagnie Microsoft qui a adapté le langage BASIC à la programmation du système d’exploitation Windows.

Le langage Visual Basic est relativement facile à utiliser mais offre une multitude d’options qui permettent à de nombreux programmeurs professionnels de produire des programmes très sophistiqués.

Visual Basic est disponible en plusieurs éditions :

  •   Entreprise : Crée pour la programmation en équipe et les environnements client-serveur, ou le traitement et les données sont distribués à plusieurs ordinateurs, cette édition inclut un jeu complet d’outils et assistants pour l’empaquetage et la distribution des applications.
  •  Professionnelle : cocue pour la programmation professionnelle qui souhaite exploiter pleinement d’environnement de programmation Visual Basic.
  •  Initiation : l’essentiel de Visual Basic avec un jeu complémentaire d’outils standards tout ce dont vous avez besoin pour vous lancer dans la programmation Visual Basic.

2. Domaines d’utilisations

Les langages interprétés, tel le basic, vous permettent d’exécuter le programme à tout moment, alors que vous l’écrivez. Cette rapidité de la réponse en fait de bons points de départ pour l’apprentissage.

Visual Basic est un outil encore très répandu qui permet aux entreprises de développer rapidement des programmes sous Windows. L’environnement permet entre autres de compléter des applications existantes par des interfaces intuitives et conviviales développées en interne. Cette formation apporte aux participants les connaissances et compétences nécessaires pour créer des applications avec Visual Basic. Ils apprendront les techniques nécessaires pour s’orienter par la suite vers la programmation des composants applicatifs.

La plupart des taches de programmation deviennent aussi simple que de déplacer des objets graphiques à l’aide de la souris.

Le Visual Basic est l’un des outils de programmation les plus conviviaux, le développement d’une application consiste en grand partie à disposer des objets graphiques et à en régler le comportement à l’aide des propriétés, Visual Basic est en fait le seul vrai langage de programmation que débutants puissent apprendre si facilement.

IV. Le code utilisé

Nous avons opté pour le Code Morse comme langage de transmission des informations.

1. Définition

Le code morse est un code de transmission d’information pour la télégraphie utilisant seulement deux caractères appelés « brève » et « longue » ou « point » et « trait » lorsqu’on le transcrit sur papier. La différence entre les caractères ne repose que sur la durée d’émission, c’est pourquoi ce code est assez universel et peut être utilisé avec différents supports tels que courant électrique, onde radio ou lumière.

Le code a été inventé par Samuel Morse (1791-1872), en 1838 aux États-Unis pour transmettre des informations sur des fils électriques.

L’alphabet morse ou code morse, est un code permettant de transmettre un texte à l’aide de séries d’impulsions courtes et longues, qu’elles soient produites par des signes, une lumière, un son ou un geste.

Cet ensemble de points et de traits permet la représentation des lettres de l’alphabet latin (A à Z), des chiffres (0 à 9), Chaque lettre de l’alphabet ainsi que les chiffres et des caractères de contrôle sont formés d’un ensemble de point et de trait (1 à 6).

Figure 12: Tableau du codage en Morse.
Figure 12: Tableau du codage en Morse.

2. Domaines d’utilisations

Le code morse peut être utilisable dans le système télégraphique à l’origine de la première télécommunication à longue distance.

Le code morse est toujours utilisé aujourd’hui (certaines parties du spectre radio sont toujours réservées aux seules transmissions en morse). Utilisant un simple signal radio non modulé, il demande moins d’équipement pour envoyer et recevoir que d’autres formes de communications radio. Il peut être utilisé avec un bruit de fond important, un signal faible et demande très peu de bande passante.

Le morse est principalement utilisé par les militaires comme moyen de transmission, souvent chiffrée, ainsi que dans le civil pour certaines émissions à caractère automatique : radiobalises en aviation, indicatif d’appel des stations maritimes, des émetteurs internationaux (horloges atomiques), ou bien encore pour la signalisation maritime par certains transpondeurs radar et feux. Le morse est également pratiqué par des amateurs comme de nombreux radioamateurs scouts (morse sonore et lumineux), ainsi que comme sonnerie par défaut de réception de message pour certains téléphones portables.

Chapitre 2 : Interfaçage et programmation


I. Interface en Visual Basic

Le Visual Basic est un ensemble de commande et d’options de commandes par lequel on envoie des instructions à l’ordinateur, les programmes sont souvent constitués de plusieurs programmes interagissant les uns sur les autres.

Le Visual Basic est un langage strictement textuel, l’entrée et la sortie des données se font en mode texte.

Il est devenu l’un des langages les plus utilisés, il est à la fois interprété et compilé. A mesure que vous écrivez votre programme Visual Basic vous pouvez le tester en l’exécutant de façons interprétées, jusqu’à ce que tous les bogues aient été isolés et éliminés.

1- Interfaces graphiques

Figure 13: L’écran de programmation en Visual Basic.
Figure 13: L’écran de programmation en Visual Basic.

Avant Visual Basic, l’écriture de programme constitue une tâche fastidieuse sous plusieurs rapports dabs un environnement textuel.

Grace à la nature de Visual Basic, vous ne touchez au clavier que bien plus tard dans le processus de programmation. Au lieu d’utiliser de papier, vous dessinez directement vos écrans à l’aide des outils Visual Basic.

Figure 14: Création des écrans en Visual Basic.
Figure 14: Création des écrans en Visual Basic.

Une fois que vous avez placé les contrôles sur la feuille et que vous avez des propriétés individuelles vous êtes prêt à écrire le code qui répondra aux événements déclenchés par ces contrôles.

Figure 15: Les boutons de commandes d'une fenêtre de Visual Basic.
Figure 15: Les boutons de commandes d’une fenêtre de Visual Basic.
  • La fenêtre Nouveau projet : s’affiche au lancement de Visual Basic ou lorsque vous choisissez la  commande fichier.
  • La barre d’outils : située sous la barre de menus se modifie, en effet, quatre barres d’outils sont disponibles.
  • Débogage : s’affiche lorsque vous employer les outils de débogage pour corriger votre programme.
  • Edition : Faciliter l’édition du code Visual Basic.
  • Editer le code de feuille : Aide à la disposition  des objets sur la feuille.
  • Standard : Barre d’outils par défaut, affichée sous la barre de menus.
Figure 16: Le fonctionnement des principaux composants de Visual Basic.
Figure 16: Le fonctionnement des principaux composants de Visual Basic.

La fenêtre propriétés : qui affiche quelques-unes de propriétés d’un contrôle Label. Vous pouvez constater que les informations affichées dans la fenêtre propriétés quant au nom, au type et à la description, reflètent le contrôle sélectionné.

Figure 17: Les propriétés du contrôle.
Figure 17: Les propriétés du contrôle.

2. Les fonctions du programme de Visual Basic

  i. Import system :

L’instruction Imports permet le référencement direct des types contenus dans un espace de noms donné.

Vous pouvez fournir un nom d’espace de noms unique ou une chaîne d’espaces de noms imbriqués. Chaque espace de noms imbriqué est séparé de l’espace de noms du niveau supérieur suivant par un point (.), comme l’exemple suivant :

Imports System.Collections.Generic

ii. Public Class :

Déclare le nom d’une classe et introduit la définition des variables, des propriétés, des événements et des procédures que la classe contient.

Une instruction Class définit un nouveau type de données. Une classe est un bloc de construction fondamental d’une programmation orientée objet.

Vous pouvez utiliser Class uniquement au niveau de l’espace de noms ou du module. Cela signifie que le contexte de déclaration pour une classe doit être un fichier source, un espace de noms, une classe, une structure, un module ou une interface, et ne peut pas être une procédure ou un bloc.

iii. Dim myport :

Déclare et alloue de l’espace de stockage pour une ou plusieurs variables.

Le compilateur Visual Basic utilise l’instruction Dim pour déterminer le type de données de la variable et d’autres informations, telles que le code pouvant accéder à la variable.

iv. Delegate Sub :

Les délégués sont des objets qui font référence aux méthodes.  Ils sont parfois décrits comme des pointeurs fonction de type sécurisé car ils sont comparables aux pointeurs fonction utilisés dans d’autres langages de programmation.  Mais contrairement aux pointeurs de fonction, les délégués Visual Basic sont un type référence basé sur la classe System Delegate.

Les délégués peuvent faire référence à des méthodes partagées (méthodes qui peuvent être appelées sans une instance spécifique d’une classe) et à des méthodes d’instance.

v. Private Sub :

Une procédure Sub est une série d’instructions Visual Basic délimitées par les instructions Sub et End Sub.  La procédure Sub effectue une tâche, puis retourne le contrôle au code appelant, mais ne retourne pas de valeur au code appelant.

Chaque fois que la procédure est appelée, ses instructions sont exécutées à partir de la première instruction exécutable située après l’instruction Sub jusqu’à la première instruction End Sub.

II. Programme de l’Arduino

1.Interface graphiques

i. Fenêtre principale:
Figure 18: fenêtre principale du programme de l'Arduino.
Figure 18: fenêtre principale du programme de l’Arduino.
  • La barre des menus vous permet d’accéder les fonctionnalités du logiciel Arduino.
  • La barre de boutons vous permet de vérifier la syntaxe et transférer les programmes, créer, ouvrir et sauver votre code, ainsi d’ouvrir le moniteur série.
  • Le programme est écrit dans la fenêtre d’édition des programmes avant d’être envoyé sur la carte Arduino.
  • Les programmes sont écrits dans l’éditeur de texte.
  • La zone de messages donne l’écart de l’opération en cours et affiche également les erreurs.
  • La console texte affiche les messages produits par le logiciel Arduino inclut des messages d’erreur.
ii. fenêtre du terminal

Cette fenêtre permet de :

  • Lire les informations envoyées à la carte Arduino (zone d’affichage des messages et des caractères reçue).
  • De taper des informations envoyées directement à la carte (zone de saisie des valeurs à envoyer).
Figure 19: Fenêtre du terminal série.
Figure 19: Fenêtre du terminal série.
iii. Les principales fonctions
Figure 20: Les principaux fonctions du programme de l'Arduino
Figure 20: Les principaux fonctions du programme de l’Arduino
iv. Sélectionner une carte :
Figure 21: Comment sélectionner une carte Arduino.
Figure 21: Comment sélectionner une carte Arduino.
v. Sélectionner un port série :
Figure 22: Comment sélectionner un port série.
Figure 22: Comment sélectionner un port série.

2. Les fonctions du langage Arduino

Les programmes Arduino peuvent être divisés en trois parties principales : la structure, les valeurs (variables et constantes) et les fonctions. Le langage Arduino est basé sur les langages C/C++.

i. Structure
a. Les fonctions de base

Ces deux fonctions sont obligatoires dans tout programme en langage Arduino

  • void setup ()

La fonction setup () est appelée au démarrage du programme. Cette fonction est utilisée pour initialiser les variables, le sens des broches, les librairies utilisées. La fonction setup n’est exécutée qu’une seule fois, après chaque mise sous tension ou reset (réinitialisation) de la carte Arduino.

Void setup () 
 { 
 
 }
  • void loop ()

Après avoir créé une fonction setup (), qui initialise et fixe les valeurs de démarrage du programme, la fonction loop () (boucle en anglais) fait exactement ce que son nom suggère et s’exécute en boucle sans fin, permettant à votre programme de s’exécuter et de répondre. Utiliser cette fonction pour contrôler activement la carte Arduino.

Void loop () 
 {
 }
b. Structures de contrôle
  • If

L’instruction if (« si » en français), utilisée avec un opérateur logique de comparaison, permet de tester si une condition est vraie, par exemple si la mesure d’une entrée analogique est bien supérieure à une certaine valeur.

Le format d’un test if est le suivant :

If (une Variable > 50) 
 {
  // faire quelque chose
 }
  • If … else

L’instruction if/else (si/sinon en français) permet un meilleur contrôle du déroulement du programme que la simple instruction if, en permettant de grouper plusieurs tests ensemble. Par exemple, une entrée analogique peut-être testée et une action réalisée si l’entrée est inférieure à 500, et une autre action réalisée si l’entrée est supérieure ou égale à 500.

If (brocheCinqEntree < 500) 
 {
  // action A
 } 
 else 
 {
  // action B
 }
  • For

L’instruction for est utilisée pour répéter l’exécution d’un bloc d’instructions regroupées entre des accolades. Un compteur incrémental est habituellement utilisé pour incrémenter et finir la boucle. L’instruction for est très utile pour toutes les opérations répétitives et est souvent utilisées en association avec des tableaux de variables pour agir sur un ensemble de données ou broches.

Il y a 3 parties dans l’entête d’une boucle for :

For (initialisation; condition; incrémentation) {
 
 //instruction(s)à exécuter;
 
 }
  • While

Les boucles while (« tant que » en français) bouclent sans fin, et indéfiniment, jusqu’à ce que la condition ou l’expression entre les parenthèses ( ) devienne fausse. Quelque chose doit modifier la variable testée, sinon la boucle while ne se terminera jamais. Cela peut être dans votre code, soit une variable incrémentée, ou également une condition externe, soit le test d’un capteur.

While (expression) {// tant que l'expression est vraie

// instructions à effectuer }

  • Do…while

La boucle do / while (« faire tant que » en français) fonctionne de la même façon que la boucle while, à la différence près que la condition est testée à la fin de la boucle, et par conséquent la boucle do sera toujours exécutée au moins une fois.

Do // faire...
 {
 // bloc d'instruction

} while (condition); // tant que la condition est vraie

 

c. Syntaxe de base
  • ;

Utilisé (et obligatoire) à la fin d’une instruction

Int a = 13; // le point-virgule indique la fin de l'instruction
  • {}

Les accolades sont un élément majeur de la programmation en langage C. Elles sont utilisées dans plusieurs constructions différentes, décrites ci-dessous, et cela peut parfois entraîner la confusion chez les débutants.

Void myfunction (datatype argument) {// ouverture de la fonction
// vos instructions ici
} // fermeture de la fonction

  •  //

Les commentaires sont des lignes de texte incluses dans le programme et qui ont pour but de vous informer vous-même ou les autres de la façon dont le programme fonctionne. Ces lignes ajoutées sont ignorées par le compilateur, et ne sont pas programmées dans le microcontrôleur, et par conséquent elles ne n’occupent aucun espace mémoire dans le microcontrôleur ATMega.

Les commentaires ont pour seul but de vous aider à comprendre (ou à vous rappeler) comment votre programme fonctionne ou d’en informer les autres. Il y a deux façons de créer des lignes de commentaires :

// Commentaire sur une seule ligne : tout ce qui suit les "//" est ignoré par le compilateur
d. Opérateur de comparaison
  • == (égal à)
  • != (différent de)
  • <  (inférieure à)
  • >  (supérieure à)
  • ≤  (inférieure ou égal à)
  • ≥ (supérieure ou égal à)
e. Opérateurs composés
  • ++ incrémentation
  • — décrémentation
ii. Variables et constantes

Les variables sont des expressions que vous pouvez utiliser dans les programmes pour stocker des valeurs.

a. Constantes prédéfinies

Les constantes prédéfinies du langage Arduino sont des valeurs particulières ayant une signification spécifique.

  • HIGH / LOW

Lorsqu’on lit ou on écrit sur une broche numérique, seuls deux états distincts sont possible, la broche ne peut prendre/être qu’à deux valeurs : HIGH (HAUT) ou LOW (BAS).

  • INPUT / OUTPUT

Les broches numériques peuvent être utilisées soit en mode INPUT (= en entrée), soit en mode OUTPUT (= en sortie).

  • true / false

Il existe deux constantes utilisées pour représenter le VRAI et le FAUX dans le langage Arduino : true et false.

b. Types des données

Les variables peuvent être de type variés qui sont décrits ci-dessous.

  • Char

Déclare une variable de un octet de mémoire (8 bits) qui contient une valeur correspondant à un caractère. Les caractères unitaires sont écrits entre guillemets uniques, comme ceci ‘A’ (pour des chaînes de caractères, utiliser les guillemets double : « ABC »).

Char mon Char='B'; // déclare une variable char
  • Int

Déclare une variable de type Int (pour intégrer, entier en anglais). Les variables de type Int sont votre type de base pour le stockage de nombres, et ces variables stockent une valeur sur 2 octets. Elles peuvent donc stocker des valeurs allant de – 32 768 à 32 767.

  • Long

Déclare des variables de type long. Les variables de type long sont des variables de taille élargie pour le stockage de nombre entiers, sur 4 octets (32 bits), de -2 147 483 648 à + 2 147 483 647.

Long var = valeur;

Var : le nom de la variable long

Valeur : la valeur donnée à la variable

iii. Fonction
a. Entrées/sorties numériques
  • Pin Mode (broche, mode)

Configure la broche spécifiée pour qu’elle se comporte soit en entrée, soit en sortie.

Pin Mode (broche, mode)

Broche: le numéro de la broche de la carte Arduino dont le mode de fonctionnement (entrée ou sortie) doit être défini.

Mode: soit INPUT (entrée en français) (=0) ou OUTPUT (sortie en français) (=1).

  • Digital Write (broche, valeur)

Met un niveau logique HIGH (HAUT en français) ou LOW (BAS en français) sur une broche numérique. Si la broche a été configurée en SORTIE avec l’instruction pinMode (), sa tension est mise à la valeur correspondante : 5V (ou 3.3V sur les cartes Arduino 3.3V) pour le niveau HAUT, 0V (masse) pour le niveau BAS.

DigitalWrite (broche, valeur)

Broche: le numéro de la broche de la carte Arduino.

Valeur : HIGH ou LOW (ou bien 1 ou 0).

  • Int digital Read (broche)

Lit l’état (= le niveau logique) d’une broche précise en entrée numérique, et renvoie la valeur HIGH (HAUT en français) ou LOW (BAS en français).

Digital Read (broche)

Broche : le numéro de la broche numérique que vous voulez lire. (Int)

  • Analog Write (broche, valeur)

Génère une impulsion de largeur / période voulue sur une broche de la carte Arduino (Modulation de Largeur d’Impulsion en français).

AnalogWrite (broche, valeur);
b.  Temps
  •  Unsigned long millis ()

Renvoie le nombre de millisecondes depuis que la carte Arduino a commencé à exécuter le programme courant. Ce nombre débordera (c à d sera remis à zéro) après 50 jours approximativement.

Variable_unsigned_long=millis ();
  • Delay (ms)

Réalise une pause dans l’exécution du programme pour la durée (en millisecondes) indiquée en paramètre.

Delay (ms);

Ms (unsigned long): le nombre de millisecondes que dure la pause

c. Communication
  • Serial

La librairie Serial est utilisée pour les communications par le port série entre la carte Arduino et un ordinateur ou d’autres composants. Toutes les cartes Arduino ont au moins un port Série (également désigné sous le nom d’UART ou USART) : Serial. Ce port série communique sur les broches 0 (RX) et 1 (TX) avec l’ordinateur via le port USB.

d. Les fonctions de la librairie
  • Begin ()

Fixe le débit de communication en nombre de caractères par seconde (l’unité est le baud) pour la communication série.

Pour communiquer avec l’ordinateur, utiliser l’un de ces débits : 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, or 115200. Vous pouvez, également, spécifier d’autres débits – par exemple, pour communiquer sur les broches 0 et 1 avec un composant qui nécessite un débit particulier.

  • Available ()

Donne le nombre d’octets (caractères) disponible pour lecture dans la file d’attente (buffer) du port série.

Serial.available ();
  • Read ()

Lit les données entrantes sur le port Série.

Serial. Read ();
  • Print ()

Affiche les données sous le port série sous forme lisible pour les humains (texte ASCII. Cette instruction peut prendre plusieurs formes.

Les nombres à virgules (float) sont affichés de la même façon sous forme de caractères ASCII pour chaque chiffre, par défaut avec 2 décimales derrière la virgule.

  • Write ()

Ecrit des données binaires sur le port série. Ces données sont envoyées comme une série d’octet; pour envoyer les caractères correspondants aux chiffres d’un nombre, utiliser plutôt la fonction print ().

Chapitre 3 : Maquette du projet (Application)


I. Partie émetteur

1.Programme en Arduino

Ce programme permet de coder un message envoyé par l’émetteur :

Const Int LMSG=100;                 

Const Int out=7;                          

Char lettre [LMSG];                    

Int count=0;

 

char Lettre [44] = {'a','b','c','d','e','f','g',

'h','i','j','k','l','m','n',

'o','p','q','r','s','t','u',

'v','w','x','y','z',' ','1','2',

'3','4','5','6','7','8','9',

'0','.',',',':','(',')','?','!'};               

Int Morse [44][5] = {{1,2,0,0,0},//a

{2,1,1,1,0},//b

{2,1,2,1,0},//c

{2,1,1,0,0},//d                           

{1,0,0,0,0},//e                           

{1,1,2,1,0},//f                            

{2,2,1,0,0},//g 

{1,1,1,1,0},//h                           

{1,1,0,0,0},//i

{1,2,2,2,0},//j

{2,1,2,0,0},//k

{1,2,1,1,0},//l

{2,2,0,0,0},//m

{2,1,0,0,0},//n

{2,2,2,0,0},//o

{1,2,2,1,0},//p

{2,2,1,2,0},//q

{1,2,1,0,0},//r

{1,1,1,0,0},//s

{2,0,0,0,0},//t

{1,1,2,0,0},//u

{1,1,1,2,0},//v

{1,2,2,0,0},//w

{2,1,1,2,0},//x

{2,1,2,2,0},//y

{2,2,1,1,0},//z

 

{2,1,2,1,2},//espace

 

{1,2,2,2,2},//1

{1,1,2,2,2},//2

{1,1,1,2,2},//3

{1,1,1,1,2},//4

{1,1,1,1,1},//5

{2,1,1,1,1},//6

{2,2,1,1,1},//7

{2,2,2,1,1},//8

{2,2,2,2,1},//9

{2,2,2,2,2},//0

 

{2,1,2,1,1},//point

{2,2,2,1,0},//virgule

{2,2,1,1,2},//:
{2,2,1,2,2},//(
{1,1,2,1,1},//)
{1,2,2,1,1},//?
{1,2,2,2,1}//!
};
void courte(){
digitalWrite(out, HIGH);   
Delay (3);
digitalWrite (out, LOW);
delay (1);
}
void longue(){
digitalWrite(out, HIGH);  
delay (5);
digitalWrite (out, LOW);
delay (1);
}
void code (char l) {
For (int i=0; i<44; i++){
If(l==Letter[i]){
For(int j=0; j<5; j++){
If(Morse[i][j]==2) longue();    
If (Morse[i][j]==1) courte();
}
}
}
Delay(7);
}


Void setup() {
Serial. Begin(9600);
pin Mode(out,OUTPUT);
count=0;

for(int i=0;i<LMSG;i++) letter[i]=NULL;

}
void loop() {
while (!Serial. Available()) {}
while (Serial. Available()> 0) {
letter[count]=Serial. Read();
count++;
if(count>LMSG-1) count=0;
}
for(int i=0;i<LMSG;i++){                      
if(lettre[i]!=NULL) {code(lettre[i]);  
Serial. Print(lettre[i]);
delay(200);}
}
for(int i=0;i<LMSG;i++) lettre[i]=NULL;      
}

2. Programme en Visual Basic (EMISSION)

Imports System

Imports System. Threading          

Imports System.IO.Ports

Imports System.ComponentModel
                                      

Public Class Form1                                                     
                                                                                                                                                                                                            
    Dim myport As Array   

Delegate Sub SetTextCallback(ByVal [text] As String)

  Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

        myport = IO.Ports.SerialPort.GetPortNames()         

        ComboBox1.Items.AddRange(myport)                             

         Button2.Enabled = False                               


    End Sub

    Private Sub ComboBox1_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ComboBox1.SelectedIndexChanged

    End Sub
    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        SerialPort1.PortName = ComboBox1.Text      

        SerialPort1.BaudRate = ComboBox2.Text                                 

        SerialPort1.Open()

               

        Button1.Enabled = False           

        Button2.Enabled = True

        Button3.Enabled = True


    End Sub

 
    Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click

        SerialPort1.Write(RichTextBox1.Text & vbCr) 

                                                                  

    End Sub


 Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click

        SerialPort1.Close()   

     Button1.Enabled = True             

     Button2.Enabled = False                                                                                               

     Button3.Enabled = False

 

    End Sub

    Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button4.Click

        End

 End Sub

3. Interface en Visual Basic

Cette partie consiste à envoyer un message à l’aide d’une interface de Visual Basic : 

Figure 23: Interface d'émission en Visual Basic.
Figure 23: Interface d’émission en Visual Basic.

II. Partie récepteur

1.programme Arduino

Ce programme permet de décoder le message reçu par le récepteur et l’afficher sur la fenêtre du Visual basic.

Const Int in=4;                                                

Char lettre;

Int val=0;

Int Signal [30];                                             

Int count=0;

Int start=0;

Unsigned long echo=0;

Char Lettre [44] = {'a','b','c','d','e','f','g',

                  'h','i','j','k','l','m','n',

                  'o','p','q','r','s','t','u',

                  'v','w','x','y','z',' ','1','2',

                  '3','4','5','6','7','8','9',

                  '0','.',',',':','(',')','?','!'};                                            

Int Morse [44][5] = {{1,2,0,0,0},//a

                    {2,1, 1,1,0},//b

                    {2,1,2,1,0},//c                                              

                    {2,1,1,0,0},//d                                              

                    {1,0,0,0,0},//e                                             

                    {1,1,2,1,0},//f 

                    {2,2,1,0,0},//g

                    {1,1,1,1,0},//h

                    {1,1,0,0,0},//i

                    {1,2,2,2,0},//j

                    {2,1,2,0,0},//k

                    {1,2,1,1,0},//l

                    {2,2,0,0,0},//m

                    {2,1,0,0,0},//n

                    {2,2,2,0,0},//o

                    {1,2,2,1,0},//p

                    {2,2,1,2,0},//q

                    {1,2,1,0,0},//r

                    {1,1,1,0,0},//s

                    {2,0,0,0,0},//t

                    {1,1,2,0,0},//u

                    {1,1,1,2,0},//v

                    {1,2,2,0,0},//w

                    {2,1,1,2,0},//x

                    {2,1,2,2,0},//y

                    {2,2,1,1,0},//z

                    

                    {2,1,2,1,2},//espace

                    

                    {1,2,2,2,2},//1

                    {1,1,2,2,2},//2

                    {1,1,1,2,2},//3

                    {1,1,1,1,2},//4

                    {1,1,1,1,1},//5

                    {2,1,1,1,1},//6

                    {2,2,1,1,1},//7

                    {2,2,2,1,1},//8

                    {2,2,2,2,1},//9

                    {2,2,2,2,2},//0

 

                    {2,1,2,1,1},//point

                    {2,2,2,1,0},//virgule

                    {2,2,1,1,2},//:

                    {2,2,1,2,2},//(

                    {1,1,2,1,1},//)

                    {1,2,2,1,1},//?

                    {1,2,2,2,1}//!

                    }; 

 

 

Char décoder(){

  for(Int i=0; i<44; i++){

    if(Signal[0]==Morse[i][0] && Signal[1]==Morse[i][1] && Signal[2]==Morse[i][2] && Signal[3]==Morse[i][3]  && Signal[4]==Morse[i][4])

    Return Lettre[i];                             

  }                                                                                                                                                               

}  

Void setup () {

  Serial. Begin (9600);

  Pin Mode (in, INPUT);                                     

  for (int i=0;i<5;i++) Signal[i]=0;

  Start=0;

}

void loop() {

   echo = pulse In(in,HIGH,60000);                       

   If (echo>0) {

     While (start==0) {

       If (echo==0){

         Signal [count] =0;

         Count++;

         If (count>4) {count=0;    start=1 ;}

       }

       else if(écho<4000){

         Signal[count]=1;                              

         Count++;

         If (count>4) {count=0;    start=1 ;}

       }

       else{  

         Signal[count]=2;                              

         Count++;

         If (count>4) {count=0;   start=1 ;}

       }

       Echo = pulse in (in, HIGH, 60000) ;}

   }

   if(Start == 1){

      

     lettre=décoder();

     Serial. Print(lettre);                             

     For (int i=0; i<5; i++) Signal[i] =0;

     Start=0;

   }  

}

2.Programme Visual Basic (RECEPTION)

Imports System

Imports System.Threading

Imports System.IO.Ports                        

Imports System.ComponentModel     

 

 

 
 

Public Class Form1

    Dim myPort As Array         

    Delegate Sub SetTextCallback(ByVal [text] As String)    

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

        myPort = IO.Ports.SerialPort.GetPortNames()   

        ComboBox1.Items.AddRange(myPort)               

 

        Button2.Enabled = False

    End Sub

 

    

 
Private Sub ComboBox1_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ComboBox1.SelectedIndexChanged    

                                                         

    End Sub
  Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click     

 

        SerialPort1.PortName = ComboBox1.Text    

        SerialPort1.BaudRate = ComboBox2.Text     

        SerialPort1.Open()

        Button1.Enabled = False                            

        Button2.Enabled = Ture                                   

                                                                                                                                

    End Sub

 
   

 Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click

        SerialPort1.Close()

        Button1.Enabled = Ture   

    End Sub
 

    Private Sub SerialPort1_DataReceived(ByVal sender As System.Object, ByVal e As System.IO.Ports.SerialDataReceivedEventArgs) Handles SerialPort1.DataReceived

        ReceivedText(SerialPort1.ReadExisting()) 

 

    End Sub

    Private Sub ReceivedText(ByVal [text] As String)    

        If Me.RichTextBox1.InvokeRequired Then   

 

            Dim x As New SetTextCallback(AddressOf ReceivedText)    

            Me.Invoke(x, New Object() {(text)})

        Else

            Me.RichTextBox1.Text &= [text]      

        End If

    End Sub

 
    Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click                  End

    End Sub
End Class

3. Interface en Visual BASIC

Cette partie consiste à afficher le message dans la partie réception du Visual Basic : 

Figure 24: Interface d'affichage en Visual Basic.
Figure 24: Interface d’affichage en Visual Basic.

III. Schéma électronique sous ISIS

ISIS est un logiciel professionnel, utilisé dans l’électronique pour simuler des circuits et créer des typons.

Le logiciel ISIS de Proteus est principalement connu pour éditer des schémas électroniques, permet également de simuler ces schémas ce qui permet de déceler certaines erreurs dès l’étape de conception.

L’utilisation du logiciel « ISIS » permet de mieux visualiser le bon déroulement du système ainsi d’avoir une idée claire sur la partie matérielle, il nous permet de limiter les essais réels.

Figure 25 : Schéma électronique sous ISIS.
Figure 25 : Schéma électronique sous ISIS.
  • Exemple :

Codage du caractère « a» et affichage dans un oscilloscope 

Figure 26: Exemple d'affichage du caractère "a".
Figure 26: Exemple d’affichage du caractère « a ».

Conclusion


L’élaboration de ce travail dans le cadre du projet de fin d’étude, nous a permis d’appliquer nos connaissances théoriques en électronique et d’acquérir une expérience au niveau de la réalisation pratique.

Ce travail constitue un des multiples aspects de la richesse des applications et d’outils informatiques, ce projet vous a donné une meilleure idée sur la complémentarité entre le côté théorique et le côté pratique. En effet ce projet a été une source de découverte de plusieurs domaines tels que l’informatique pour la programmation embarquée et la conception des schémas électroniques.

L’objectif de ce projet a été pour nous l’occasion d’expérimenter une autre méthode de codé et transmis des données par lumière.

A la fin de ce travail, nous espérons que ce rapport sera dans le futur un support pour d’autres étudiants et qu’ils pourront en fonction de complémentarité leur besoin.

Bibliographie


  • http://www.arduino.cc/
  • www.wikipedia.org
  • http://www.electromecanique.net/
  • http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ARDUINO
  • http://www.craslab.org/interaction/files/LivretArduinoCRAS.pdf

Auteurs


Ce travaille a été réaliser par les étudiants :

  • ZEGOUTE Meryam
  • IDRISSI-YAHYAOUI Azzedine
  • ESSAIH Zinelabidine

Sous l’encadrement du professeur RADHY Nour-Eddine

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *