was successfully added to your cart.
Category

Débutant Arduino

(Re)Découvrez l’Arduino

By | Débutant Arduino | No Comments

Nous allons découvrir ensemble ce qu’est l’Arduino et à quoi cela peut-il servir. Nous apprendrons ensemble les bases du langage de programmation de l’Arduino, ainsi que quelques notions de POO (programmation orienté objet) qui peuvent s’avérer très utiles lorsque vos codes commencent à être compliqués.

Bien entendu, nous apprendrons comment utiliser les capteurs les plus répandus ainsi que des bases en électroniques pures. De plus, des cours complémentaires sur des composants standards (diode, diode Zener, transistor PNP/NPN…) apparaîtront.

L’équipe de rédaction de SimpleDuino s’efforcera de mettre à jour ces cours, et en y ajoutant les liens nécessaires vers des cours et tutoriels complémentaires.

Si vous avez des questions ou remarques particulières, n’hésitez pas à entrer en contact avec nous en écrivant à [email protected] ou en posant directement votre question sur le forum.

I) L’Arduino

1°) Historique

L’Arduino est une carte programmable développée autour d’une puce AtMega328 (pour l’Arduino UNO) produite par la société Atmel. D’autres modèles de carte Arduino existent. Ces modèles vous sont décrits dans la partie suivante.

L’Arduino a été créée par Massimo Banzi en 2005. Massimo Banzi, professeur de design à, souhaitait rendre ludique et facile l’apprentissage de la programmation des microcontrôleurs à ses élèves, débutants en informatique, afin de rendre les objets intelligents. Il décida, avec ses associés, d’inventer une carte programmable fonctionnant sous un langage de programmation simple et accessible à tous.

Image du prototype Arduino

Image du prototype Arduino

2°) Tableau comparatifs des différents modèles

Tableau comparatifs des principaux modèles (non exhaustif)

Tableau comparatifs des principaux modèles (non exhaustif)

3°) Cartographie des entrées/sorties de l’Arduino UNO

Etant l’Arduino le plus utilisé par les débutants, nous allons voir ensemble la cartographie de l’Arduino UNO afin de vous expliquer comment lire un schéma électronique. La lecture des autres cartes étant similaire, je vous laisse explorer le site d’Arduino afin de savoir ce que nos chères cartes ont dans le ventre. Vous pouvez retrouver le schéma électronique de l’arduino UNO ici. Les schémas de toutes les cartes Arduino se trouvent sur leur site. N’hésitez pas à être curieux !

Voici une vue d’ensemble de l’arduino UNO :

Schema_Arduin_UNO_explicatif

Schema Arduino UNO explicatif

Vous pouvez remarquer qu’il se trouve deux puce AtMega. Une AtMega 16u2 qui permet de convertir les données USB en données série, et la puce AtMega 328p qui est le microcontrôleur.

Sur les Arduino, quel que soit la carte, deux types d’entrées/sorties sont à différencier. Les entrées/sorties numériques et les entrées analogiques.

  • 1: Régulateur de tension 12V-5V DC
  • 2: Quartz
  • 3: Entrées analogiques
  • 4 et 5: Entrées/Sorties numériques
  • 6: Pins d’alimentations

Les parties précédemment énoncées désignent les éléments indispensables au fonctionnement d’un arduino. Grâce à ces éléments, il est possible de refaire soit même un arduino afin d’en minimiser la taille ou d’en optimiser les performances. Vous pouvez aller visiter le tutoriel suivant http://simple-duino.com/realiser-arduino-maison/ pour apprendre à réaliser un arduino.

II) Le langage Arduino

1°) Installation et découverte de l’IDE Arduino

L’IDE Arduino est un logiciel permettant de générer un code et de l’implémenter sur le microcontrôleur. Vous pouvez télécharger le logiciel Arduino IDE sur le site officiel d’Arduino.

Une fois téléchargé, lancez l’assistant d’installation, et suivez les instructions.

a) Décomposition de l’environnement de travail

L’IDE Arduino se décompose en 5 zones.

  • Zone 1: Bouton de téléversement
  • Zone 2: Bouton de lancement du port série. En cliquant sur ce bouton le port série va s’ouvrir. De cette fenêtre vous pourrez lancer des actions via des commandes envoyées sur l’Arduino par l’ordinateur.
  • Zone 3: Zone de code. C’est dans cette zone que vous allez écrire le code à implémenter sur l’Arduino.
  • Zone 4: Console de débogage. La console vous permet de visualiser où se situent les erreurs et quels sont les types d’erreurs.
  • Zone 5: Information de la configuration de l’IDE. Vous avez une vue d’ensemble de la carte que vous avez sélectionné et du port auquel vous vous êtes rattachés.
IDE Arduino explicatif

IDE Arduino explicatif

b) Le code Arduino

Le code Arduino est basé sur le langage C. Il est cependant arrangé pour qu’il soit plus simple à utiliser et par conséquent il demande moins de temps pour l’apprendre. Seul la logique de programmation est commune à tous les langages, que ce soit du Java, du C#, du C++, etc… Mais n’ayez pas peur, ce n’est pas très compliqué.

Nous allons énoncer les principales fonctions que vous devez connaître. Des explications supplémentaires se trouvent dans les tutoriels du site.

1
pinMode(pin, INPUT/OUTPUT);

Cette fonction permet de définir les pins comme étant des pins d’entrée ou de sortie.

1
digitalWrite(pin, etat);

« etat » peut être « HIGH/LOW », ou un nombre compris entre 0 et 255 pour les PWM reconnaissable avec le ~.

1
digitalRead(pin);

Récupère l’information (0 ou 1) d’un pin numérique.

1
analogRead(pin);

Récupère l’information d’un pin analogique.

III) Notions d’électroniques

1°) Loi d’Ohm, loi des Mailles, loi des Noeuds

Toute l’électronique, ou électricité en général, repose sur trois loins fondamentales qui sont la loi d’Ohm, la loi des Mailles et la loi des Noeuds.

a) Loi d’Ohm

La loi d’Ohm est la loi qui lie l’intensité, la tension et la résistance.

Loi d'Ohm

Loi d’Ohm

Avec:

  • U: Volt
  • R: Ohm
  • I: Ampère

Vous pouvez manipuler cette loi dans le sens que vous voulez, permettant ainsi de déduire des valeurs de résistances à mettre en série avec une LED par exemple. Cette loi va également beaucoup vous servir pour résoudre vos problèmes de dimensionnement de composant en complément des lois des mailles et des nœuds.

b) Loi des Mailles

La loi des mailles est une loi permettant d’établir des équations d’une maille fermée.

La loi des Mailles assure:

Loi des Mailles

Loi des Mailles

c) Loi des Noeuds

La Loi des nœuds dans un circuit est présente dès lors que votre montage comporte plusieurs branches. Le lieu de rencontre de ces « branches » s’appelle un « nœud ».

La loi des noeuds assure:

Loi des Noeuds

Loi des Noeuds

2°) Les entrées-sorties numériques

Les entrées et sorties numériques (digitales) se traitent de manière similaire. Il s’agit d’un signal binaire (0-5v). Dans un cas l’arduino est capable de générer un signal carré d’amplitude 5v, et dans l’autre l’arduino est capable d’interpréter un signal reçu en créneaux de 5v.

Vous pouvez trouver plus d’informations sur ce tutoriel expliquant les entrées et sorties numériques.

3°) Les entrées analogiques

Contrairement aux broches numériques, les broches analogiques ne fonctionnent qu’en entrée.  Il est impossible de générer un signal analogique (signal dont les variations sont continues dans les temps) à l’aide d’un arduino. Vous en avez sans doute tous déjà utilisé, les GBF permettent de générer de tel signaux, qu’ils soient sinusoïdaux, en créneaux ou en triangles.

Une donnée analogique va être, dans la quasi-totalité des cas, générée par un capteur (température, luminosité, humidité…). En effet, le capteur va fournir une image de la tension en fonction du temps. La fonction permettant de récupérer cette valeur avec l’arduino est :

1
analogRead(analog_pin);

Vous pouvez trouver plus d’informations sur ce tutoriel expliquant les entrées analogiques.

4°) La fonction PWM (Pulse Width Modulation)

La fonction Pulse Width Modulation (PWM) est un signal dont on fait varier le rapport cyclique afin que la fréquence varie.

Définition du rapport cyclique

Définition du rapport cyclique

Le rapport cyclique est défini comme:

Formule Rapport Cyclique

Formule Rapport Cyclique

Avec:

  • ton: temps à l’état haut
  • T: Période du signal
  • a: Nombre compris entre 0 et 1 (souvent on parle en %)

Imaginez que vous avez devant vous une diode. Plus le rapport cyclique est grand, plus l’intensité lumineuse de la diode sera importante. Le temps à l’état haut correspond au temps auquel la diode va s’allumer, puis le temps à l’état bas correspond au temps auquel la diode va s’éteindre. C’est cet enchainement d’état qui fait varier la fréquence et donc l’intensité lumineuse pour une LED, ou la vitesse de rotation pour un moteur par exemple.

La fonction PWM permet de faire varier ce rapport cyclique, et donc la fréquence de l’état haut. Pour se faire, nous utilisons la fonction « digitalWrite(nomPin, pwm) », où « pwm » désigne un nombre compris entre 0 et 255 qui correspond au rapport cyclique du signal.

Explication PWM

Explication PWM

On pourrait faire l’amalgame avec une entrée « analogique », mais gardez à l’esprit que nous ne travaillons qu’avec des signaux binaires, donc avec une amplitude fixe.

5°) Les fonctions delay(), millis()

La gestion du temps est une chose très délicate et difficile à assimiler. Vous allez souvent (tout le temps ?) être confronté à la manière dont vous allez gérer le temps. Faut-il que mon programme puisse faire quelque chose pendant une attente ? Comment puis-je simuler une horloge ?

La fonction que vous allez utiliser va dépendre de la tâche que vous souhaitez réaliser. La fonction « delay() » fait une pause dans le programme, et il est impossible de demander au microprocesseur de faire une action pendant cette pause. On « gèle » le déroulement du programme.

Nous préférerons utiliser la fonction « millis() » bien qu’elle soit beaucoup plus difficile à comprendre. Cette fonction va compter, sans jamais s’arrêter, le temps d’exécution du programme. C’est pourquoi il faut utiliser des conditions pour savoir quand vous souhaitez réaliser une action.

Vous pouvez donc vous demander comment détecter qu’une seconde c’est bien écoulée !

Pour cela il faut se repencher un peu dans les mathématiques et se rappeler la notion de la division euclidienne. La division euclidienne est une division qui a deux entiers appelés dividende et diviseur, associe deux entiers nommés quotient et reste. Justement, nous allons utiliser cette propriété mathématique. L’outil mathématique « modulo » (%) va effectuer cette opération.

1
2
Reste = millis() % 10000;
if(Reste == 0) {Serial.println("BOUM");}

Quand millis() est égal à 10000, 20000, 30000, etc… le « reste » sera égal à zéro. Ce qui signifiera que 10 secondes se seront écoulées. Si millis() n’est pas égal à 10000 ou un multiple de 10000, alors « reste » ne sera pas égal à zéro. Donc la boucle « if » ne sera pas exécutée.

Bien entendu, vous n’êtes pas obligé d’utiliser la fonction millis() uniquement pour cette utilisation. Mais grâce à ça, vous pouvez effectuer des actions pendant ces « attentes ».

IV) Les protocoles de communication

1°) La liaison série

La liaison série, aussi qualifiée de « UART » en anglais pour « Universal Asynchronous Receiver Transmitter », est un protocole essentiel dans la programmation Arduino. En fait, vous ne le savez peut-être pas mais chaque fois que vous appuyez sur « Téléverser », l’IDE Arduino va transmettre une série d’instruction à la puce (Atmega328P dans le cas d’un UNO) afin de la reprogrammer.

L’un des avantages majeurs de la liaison série, c’est sa simplicité de mise en œuvre. En effet, puisque l’Arduino embarque directement une librairie dédiée, il n’y a absolument aucune difficulté à initier une telle communication. Cela permet de « débuger » rapidement des programmes en visualisant à l’écran des variables que nous aurons auparavant demandé à l’Arduino d’afficher sur le port série. Cependant, la liaison série ne se limite pas seulement à des opérations de débogage et son utilisation peut être bien plus poussée. C’est le cas notamment lors de l’utilisation du module SM130, un lecteur RFID, qui fonctionne via le protocole série. Vous retrouverez un tutoriel sur notre site à l’adresse suivante: http://simple-duino.com/utilisez-les-datasheets-et-decouvrez-le-module-sm130/

Dans la continuité, l’utilisation des modules tels que les ESP8266 permettant la transmission/réception d’information par wifi requiert une bonne connaissance du protocole série. Vous trouverez un premier tutoriel sur ces modules en suivant le lien suivant: http://simple-duino.com/decouvrez-la-communication-wifi-low-cost-avec-arduino/

Il est essentiel de comprendre que la liaison série constitue un excellent outil de développement tout autant qu’un protocole de communication à part entière. Une fois que cette notion est maitrisée, on gagne largement en temps de développement puisqu’on peut alors localiser bien plus facilement les points critiques de notre programme.

2°) Les liaisons SPI et I2C

Parfois, la liaison série ne permettra pas d’interagir avec des circuits intégrés ou des modules bien spécifiques. En fait, c’est une situation qui est assez récurrente même. Généralement, ces modules utilisent la communication I2C plus que SPI. Un exemple concret de communication SPI (Serial Peripheral Interface) pourrait être le shield officiel Arduino. Il utilise en effet les six pins situés absolument à droite de votre Arduino UNO (ceux qui sont regroupés au-dessous de la vis de fixation).

Pour l’I2C, les applications sont bien plus courantes et les exemples d’utilisations bien plus nombreux. En fait, nous nous sommes très souvent retrouvé face à des circuits à contrôler via I2C, c’est le cas notamment de convertisseurs Analogiques/Numériques ou encore de circuits RTC (Real Time Clock).

Un protocole I2C, pour Inter-Integrated circuit, fonctionne en fait sur le principe de maitre/esclave. On a un module maitre, dans notre cas l’Arduino, et plusieurs modules esclaves dont les adresses sont différentes. Bien souvent, l’adresse I2C du circuit est spécifiée dans la documentation et n’est pas modifiable. Il arrive cependant que certains pins aient été prévus sur les circuits pour modifier quelques bits de l’adresse. Le protocole I2C utilise deux fils, SDA (Serial Data Line) et SCL (Serial Clock Line). Vous le comprendrez donc aisément, on a une ligne de donnée et une ligne d’horloge. Pour faire simple, à chaque fois que la ligne SCL passe à l’état Haut, l’état actuel de la ligne SDA est transmis au circuit intégré. Si SDA est à 0, le circuit reçoit donc 0 et si SDA est à 1, le circuit reçoit un 1.

Bien entendu, le protocole n’est pas aussi simple que ça. Vous vous souvenez qu’il est question d’adresse mais aussi d’acquittement des données, de bit de Start, de Stop, etc… Heureusement, Arduino va nous permettre de simplifier grandement le travail grâce à la librairie Wire.h dont vous pourrez retrouver un exemple d’application en suivant le lien suivant: http://simple-duino.com/module-ds1307-chez-sparkfun/.

V) Composants et modules

1°) Les diodes, LED

a) Diodes et diodes Zener

Les diodes sont des semi-conducteurs permettant de protéger un circuit. En effet, ce composant ne laisse passer le courant que dans un sens, le bloquant dans l’autre jusqu’à ce que la tension du circuit soit supérieure à la tension de claquage de la diode auquel cas la diode se détruit.

Schéma diode

Schéma diode

La diode Zener est quant à elle faite pour ce type d’utilisation. Cette diode, souvent montée en parallèle du composant auquel elle lui est rapportée,  va faire office de coupe circuit lorsque la tension parcourant le circuit est trop importante et risque de détériorer le composant à protéger. La diode Zener, va, à ce moment-là « claquer » et le courant va ainsi passer à travers elle plutôt que le composant monté en parallèle.

Schéma diode Zener

Schéma diode Zener

Une des utilisations intéressantes est la mise en place d’une diode Zener de 5v en parallèle d’un fils branché à un Arduino afin d’éviter des « retours » de courant supérieurs à 5v risquant de détériorer la carte.

b) LED

Une LED (DEL en français, diode électroluminescente) est un semi-conducteur capable d’émettre de la lumière lorsque d’un courant la parcourt. La LED ne laisse passer le courant que dans un sens.

Les LED fonctionnent souvent avec des courants faibles. C’est pourquoi l’utilisation de résistance est obligatoire. La valeur de la résistance nécessaire est obtenue grâce à la loi d’Ohm énoncé auparavant. Les datasheets des constructeurs fournissent les informations nécessaires au calcul de cette résistance.

Schéma diode électroluminescente

Schéma diode électroluminescente

2°) Les résistances et potentiomètres

a) Les résistances

Une résistance est un composant passif permettant de protéger un composant en abaissant la tension ou le courant le traversant.

Chaque résistance est référencée grâce à sa valeur qui peut être lue en observant ses bandes de couleurs.

Code couleur résistance

Code couleur résistance

De plus, il est possible de monter en série et en dérivation un ensemble de résistance permettant ainsi d’obtenir de nouvelles valeurs.

  • En série: La valeur de la résistance équivalente des résistances montées en série s’additionne:

Req_Serie

  • En parallèle: La valeur de la résistance équivalente des résistances montées en parallèles s’obtient de la manière suivante:

Req_Parallele

b) Les potentiomètres

Les potentiomètres sont des résistances variables. Il en existe deux sortes, les linéaires et les rotatifs.

Les deux potentiomètres fonctionnent sur le même principe. Un curseur, dont nous définissons sa position, se déplace sur une piste en carbone. La distance du fil entre la broche d’entrée et le curseur défini une valeur de résistance que l’on va noter R1, et une seconde valeur de résistance R2 est définie entre le curseur et la broche de sortie. Il ne resta plus qu’à appliquer un pont diviseur de tension.

Schéma potentiomètre rotatif

Schéma potentiomètre rotatif

Eh oui !  Un potentiomètre est un pont diviseur de tension variable !

3°) Quelques composants utiles

a) Les condensateurs et bobines

b) Les transistors et relais

Les transistors sont des semi-conducteurs à jonction PN qui, lorsqu’il est commandé, permet d’être utilisé comme interrupteur. Il existe deux types de transistors, les PNP et les NPN. Les plus utilisés sont les transistors NPN, c’est pourquoi nous expliquerons essentiellement le fonctionnement de ce type de transistor.

Chaque transistor possède trois broches.

  • B: Base
  • C: Collecteur
  • E: Emetteur
Schéma des transistors

Schéma des transistors

En appliquant un courant sur la base, le passage entre le collecteur et l’émetteur s’effectue.

c) Les AOP (Amplificateur Opérationnels)

d) Capteur de température

e) Capteur de luminosité (photorésistance, photodiode)

Les capteurs de luminosité sont des composants électroniques permettant de générer une grandeur physique (résistance, intensité) en fonction de son exposition à la lumière. Les deux grandes familles de capteur de luminosité sont :

  • Les photorésistances
  • Les photodiodes

La photorésistance est une résistance variable en fonction de son exposition à la lumière.

Si vous souhaitez découvrir comment utiliser dans un projet une photorésistance, je vous encourage à aller visiter ce tutoriel.

La photodiode est un semi-conducteur capable de générer une intensité en fonction de son exposition à la lumière. L’intensité générée par la photodiode est souvent de l’ordre du µA ou mA. Vous le savez très bien maintenant, la seule grandeur physique que l’arduino est capable de mesurer est une tension. C’est pourquoi il est nécessaire de convertir l’intensité générée par la photodiode en tension. Pour réaliser cette action on utilise généralement un montage à transimpédance (convertisseur courant-tension).

Montage à transimpédance avec photodiode

Montage à transimpédance avec photodiode

De plus, ce montage à transimpédance permet d’amplifier le signal afin qu’il puisse être interprété par l’arduino.

Remarque : L’AOP à besoin d’être alimenté en 5v (Vcc) et -5v (Vdd). La tension de -5v n’est pas naturelle. Il est néanmoins possible de l’obtenir en utilisant un composant « lmc7660 ».

4°) Des modules intéressants

Lors de la réalisation de vos projets, vous serez souvent confronté au choix technologique à utiliser pour transmettre des données. Par exemple lors de l’utilisation d’un pupitre, manette de commande pour contrôler votre mécanisme. Nous allons voir ensemble les avantages et inconvénients de chacune des technologies suivantes.

a) Modules Wifi

Grâce à la miniaturisation et à la diminution du coût des composants, la technologie wifi est devenue quelque chose de relativement simple à mettre en œuvre, notamment grâce aux modules ESP8266. Ce sont des modules qui coûtent entre 1$ et 3$ et qui sont pilotables via liaison série en transmettant simplement des commandes « AT », un standard en communication série. La porte du signal est de l’ordre d’une quinzaine de mètres mais dépend fortement de l’agencement des pièces.

L’utilisation de tels modules se révèle être un peu complexe au début mais devient rapidement simplissime face à la complexité de plus gros modules et plus coûteux comme le wifi shield officiel d’Arduino.

Vous pourrez retrouver un premier tutoriel sur les modules wifi ESP8266 sur notre site.

b) Module Bluetooth

L’avantage majeur du Bluetooth, c’est que presque tout le monde possède aujourd’hui un smartphone capable d’échanger des données en Bluetooth. L’un des inconvénients cependant, c’est la faible portée du signal Bluetooth (qui est cependant gage de sécurité dans certains cas).

Tout comme pour le wifi, il existe des modules low-cost et qui fonctionne par liaison série grâce à des commandes « AT ». L’un de ces modules serait alors le HC-05.

c) Module RF (radiofréquence)

Bien souvent, la radiofréquence se révèle être le moyen de communication le plus simple et rapide à mettre en œuvre. Un détail peut-être qui pourrait pourtant avoir un intérêt important, le signal radio est l’un des seuls capables d’évoluer dans un milieu aquatique. On trouve des kits émetteur/récepteur radiofréquence pour quelques euros sur internet et leur utilisation reste relativement simpliste comme en témoigne ce tutoriel disponible sur notre site.

 

L’Arduino n’a pas de limite, il répond à votre imagination.


Voilà ! Vous voici prêt pour concevoir et développer vos propres systèmes électroniques, domestiques ou autres. N’hésitez pas à laissez vos commentaires mais aussi à partager vos connaissances sur le forum.


Grégoire A., Thomas A., Fabien A.

Arduino et radiofréquence

Découvrez la radiofréquence avec Arduino

By | Débutant Arduino | No Comments

1- Introduction au concept de Radiofréquence

Lorsque, pour un projet quelconque, on a besoin de faire communiquer deux Arduinos sans utiliser un seul fil les liants l’un à l’autre, on se retrouve souvent confronté au choix plus ou moins difficile du type de communication à mettre en place. Alors, on pourrait penser au bluetooth, au wifi ou encore à la radiofréquence. Si les deux premières options semblent intéressantes à première vue, ces technologies nécessitent une certaine prise en main avant d’être en mesure d’en utiliser toutes les possibilités. Cependant, ce n’est pas le cas de la radiofréquence qui se détache alors rapidement de ses deux « concurrents ». En effet, la radiofréquence constitue sans doute l’un des moyens les plus simples et rapide de faire communiquer deux Arduinos ensemble. Au travers de ce tutoriel, je vous propose d’avancer pas à pas afin de comprendre en détail le fonctionnement puis l’utilisation de tels modules.

2- Fonctionnement des modules Radiofréquence

Tout d’abord, et avant d’aller plus loin dans ce tutoriel, il est nécessaire de faire un point sur le matériel que nous avons entre nos mains. Pour ma part, j’avais un kit émetteur/récepteur FS1000A comme celui-ci :

Photographie émetteur/récepteur RF

Photographie d’un kit émetteur / récepteur radiofréquence de type FS1000A

Qui trainait dans un tiroir, je baserai donc mon tutoriel sur ce kit. En plus de cela, j’ai simplement eu besoin d’un Arduino, de quelques fils et d’une résistance de 10kohms (qui n’est pas forcément utile, nous verrons plus tard)
Bien, si vous avez les même que moi, vous devriez alors avoir, au-dessus des pins, une sérigraphie qui indique GND, Vcc et Data. Détaillons d’abord ce que signifient ces indications. Pour le GND, c’est évident, cela signifie « Ground », « Masse » en anglais. Pour Vcc, c’est la valeur de niveau logique haut. Pour faire simple, puisque notre Arduino fonctionne en niveau logique 5v, on va connecter la broche Vcc du module au 5v et il saura donc que lorsqu’il reçoit 0v, cela correspond au niveau logique 0 et lorsqu’il reçoit 5v, cela correspond au niveau logique 1. Quant au Data, justement, c’est là que nous allons appliquer un niveau logique 1 ou 0 sur l’émetteur et que nous lirons un niveau logique 1 ou 0 sur le récepteur.
Pour la partie théorique seulement, le principe de fonctionnement d’un émetteur/récepteur radiofréquence est relativement simple à appréhender. En effet, lorsqu’on applique un niveau logique haut (je dirai 1 dans la suite du tutoriel) sur l’émetteur, le récepteur lira ce même niveau logique 1. Idem pour le niveau logique 0. Ainsi, on comprend la force des modules radiofréquence. Puisqu’ils transmettent directement les niveaux logiques auxquels ils sont soumis, on peut imaginer les utiliser pour faire de la transmission d’informations via la liaison Série et tout cela sans fil. Si cette notion vous semble encore floue, sachez qu’elle n’est de toute manière pas forcément très fiable. Vous découvrirez dans la suite du tutoriel qu’un signal émis par radiofréquence est perturbé pour un rien et même, que dans votre maison, vous devriez recevoir de nombreuses perturbations à la lecture des signaux, cela est notamment dû aux nombreuses ondes électromagnétiques qui nous entourent.
Pour résumer, on ne peut envoyer que des 1 ou des 0 via la radiofréquence. Lors d’un envoie, si on « donne » 1 sur le Data de l’émetteur, le Data du récepteur « Donnera » un 1, idem pour 0. Ce type d’échange permet d’envisager l’utilisation de protocoles plus complexes par radiofréquence mais ce n’est pas le sujet de ce tutoriel.

3- Premier script: Gestion du récepteur

Si vous avez, jusqu’ici, été en mesure de comprendre l’intégralité du tutoriel, alors vous devriez avoir compris que nous pouvons gérer l’émetteur « à la main », sans Arduino dans un premier temps. Ainsi, dans ce premier script concernant l’utilisation de la radiofréquence, je vous propose de nous concentrer sur l’utilisation du récepteur. Comme nous l’avons vu, ce dernier ne peut recevoir que des 0 ou des 1 et nous allons donc le câbler sur une entrée numérique, digitale donc, de notre Arduino.
Ainsi, je vous propose le câblage suivant:

ArduinoRécepteur

5v Vcc
GND GND
D2 Data

Schématiquement, cela donne le câblage suivant:

Câblage du récepteur RF sur l'Arduino

Capture d’écran du câblage entre le récepteur radiofréquence et l’Arduino effectué sur le logiciel Fritzing

Pour le script, je vous propose le code suivant que j’ai intégralement commenté:

void setup() {
  Serial.begin(9600);        // On initie la communication série sur le débit de 9600 bauds
  pinMode(2, INPUT);         // On déclare la broche D2 comme étant une entrée
}

void loop() {
  Serial.println(digitalRead(2));          // On affiche la valeur de la broche D2 dans le port série (et on saute une ligne à chaque affichage)
  delay(50);                               // On attend 50ms, cela diminue les erreurs de lecture
}

Ensuite, vous pourrez brancher votre émetteur de la manière suivante:

ArduinoEmetteur

5v Vcc
GND GND
————————— Data

Cette fois ci, schématiquement on a le câblage suivant:

Câblage de l'émetteur RF en contrôle manuel

Capture d’écran du câblage entre l’émetteur radiofréquence et son contrôle par bouton poussoir sur le logiciel Fritzing

Dans le tableau, vous remarquez que je n’ai rien spécifier pour la connexion de la broche Data de l’émetteur. C’est normal, je vous propose de brancher un fil « volant » sur le Data de l’émetteur et de simplement le relier manuellement au 5v lorsque vous souhaiterez simuler l’envoie d’un bit par radiofréquence.
Vous remarquerez que nous observons des « impulsions » sur le port série du récepteur. C’est-à-dire qu’il ne reçoit 1 que lorsque l’on connecte manuellement le Data de l’émetteur au 5v. Si on laisse connecté le Data au 5v, le récepteur ne recevra plus de données particulières et affichera donc 0. Vous comprenez alors à cet instant que nous allons travailler avec des signaux carrés. Si cette dénomination vous semble barbare, pas de panique ! Nous n’allons pas générer des signaux complexes. Un signal carré, c’est un simple passage de l’état 0 à l’état 1 puis de l’état 1 à l’état 0. En somme, c’est ce que vous venez de faire manuellement en connectant la broche Data de l’émetteur au 5v !

Vous noterez que sans aucune intervention de votre part, il est possible que vous visualisiez des valeurs de 1 sur le récepteur. C’est la manifestation des perturbations dont je vous parlais tout à l’heure.

4- Utilisation de l’émetteur et du récepteur par Arduino

Finalement, on arrive enfin à votre objectif depuis le début de ce tutoriel: Gérer l’émission et la réception d’un signal radiofréquence via Arduino. Si vous avez bien compris la partie précédente, vous devriez être en mesure d’écrire vous-même le code de cette partie.
Dans cette partie du tutoriel, nous vous proposons de réutiliser les câblages précédents ainsi que le script. Cependant, nous allons utiliser un second Arduino et y connecter notre émetteur sur D3 afin d’être en mesure de transmettre des données au récepteur. Nous procédons de la même manière que dans la partie précédente en commentant intégralement le script.

On a donc le câblage suivant:

Câblage de l'émetteur RF sur l'Arduino

Capture d’écran du câblage entre l’émetteur radiofréquence et l’Arduino sur le logiciel Fritzing

Avec le script suivant:

 

void setup()
{
	pinMode(3, OUTPUT); //On déclare la broche D3 de l'Arduino comme une sortie
}

void loop()
{
	digitalWrite(3, HIGH); //On passe la sortie D3 à l'état haut pour que l'émetteur transmette un "1" au recepteur 
	delay(250); //On attend un peu (250ms)
	digitalWrite(3, LOW); //On passe la sortie D3 à l'état bas pour que l'émetteur transmette un "0" au recepteur 
	delay(500); //On attend un peu (500ms)
}

Là, il n’y a pas grand-chose à rajouter. En mettant simultanément en route le montage émetteur et le montage récepteur, vous devriez observer des séries de 0 et de 1 plus ou moins régulières. N’oubliez pas les perturbations, elles sont omniprésentes autour de vous et peuvent perturber le signal reçu d’une manière plus ou moins prononcée. D’ailleurs, pour en éliminer une partie, on peut rajouter une résistance de 10kOhms entre le Data du récepteur et le GND de l’Arduino.

5- Conclusion

Dans ce tutoriel, nous avons eu l’occasion de voir ensemble que la communication par radiofréquence n’était pas si complexe qu’elle le semblait. Elle constitue une réelle alternative low-cost au bluetooth ou au wifi. Il faut cependant tenir compte de deux paramètres: La perturbation du signal et la sécurité de la transmission. Pour le premier paramètre, vous avez eu l’occasion de la découvrir par vous-même, les perturbations sont omniprésentes et l’une des solutions pour contrer cela constitue en la conception d’un réel protocole d’échange en radiofréquence avec des bits de début et de fin par exemple. Pour le second paramètre, celui de la sécurité, il n’est pas forcément évident d’y remédier. L’une des solution consisterait encore une fois en la création d’un protocole d’échange. Une autre solution pourrait être de modifier la plage de fréquence utilisée pour la transmission, certaines plages de fréquences sont moins sensibles aux perturbations. Attention cependant, la réglementation est assez stricte sur les plages autorisées et sur la puissance d’émission.
Un dernier point, dans ce tutoriel, nous avons proposé l’utilisation de modules radiofréquence via l’Arduino. Pourtant, et comme vous l’aurez sans doute imaginé, l’Arduino n’est absolument pas obligatoire. C’est justement pour cela que nous vous avons proposé de travailler manuellement sur le premier exemple de ce tutoriel. Si vous pouvez contrôler manuellement la transmission via un simple bouton poussoir, il n’y a aucun doute que vous pouvez faire de même avec un circuit intégré tel Attiny ou grâce à des portes logiques directement.

Le kit presse de cet article est disponible en cliquant sur ce lien

Capteur de recul Arduino

By | Débutant Arduino, Projets | 4 Comments

On se retrouve pour un nouveau tutoriel autour du capteur de recul des voitures.
Vous savez tous comment fonctionne les capteurs de recul de votre voiture, je vous propose dans ce tutoriel de coder vous même votre propre capteur de recul à l’aide de l’Arduino et de tous ces outils.

Tout d’abord, vous allez avoir besoin de matériel. Rien de grave, je vous fais une liste de ce qu’il vous faut.
Ensuite, je vais vous parler de la composition du système. En effet, ce système sera basé sur un capteur à ultrason ainsi que de 3 LEDs (Rouge, Orange, Vert).
Enfin, nous allons voir comment programmer le comportement de ce système afin d’étudier son fonctionnement. Bien entendu, les valeurs des distances peuvent varier selon vos exigences.

1°) La Led verte est allumée ET reste allumée tant que la distance entre le capteur et la voiture est supérieure à 100cm (c’est-à-dire 1 mètre).
2°) La Led orange est allumée lorsque la distance entre le capteur et la voiture est comprise entre 100cm et 30cm.
3°) La Led rouge est allumée lorsque la distance entre le capteur et la voiture est inférieure à 30cm.

 

Matériel nécessaire

  • 1x Arduino
  • 3x Résistances 100 Ohm
  • 1x Interrupteur On / Off
  • Câbles
  • Led (vert, jaune, rouge) ou une Led RGB
  • 1x Module ultrason HC-SR04
  • 1x Plaque de prototypage rapide

 

Branchement

Retrouvez ci-dessous un schéma de branchement des different composants sur la plaque de prototypage rapide.

Capteur ultrason + Led + Arduino

Branchement capteur de recul avec Led de position

 

Programmation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
int LedRed = 2;
int LedOrange = 3;
int LedGreen = 4;
int CapteurUltrasonTrig = 12;
int CapteurUltrasonEcho = 11;
 
void setup(){
     pinMode(LedRed, OUTPUT);
     pinMode(LedOrange, OUTPUT);
     pinMode(LedGreen, OUTPUT);
     pinMode(CapteurUltrasonTrig, OUTPUT);
     pinMode(CapteurUltrasonEcho, INPUT);
}
 
void loop(){
     digitalWrite(CapteurUltrasonTrig, HIGH);
     delayMicroseconds(10);
     digitalWrite(CapteurUltrasonTrig, LOW);
     int pulseLength = pulseIn(CapteurUltrasonEcho, HIGH);
     int width = pulseLength/58; //d'après la datasheet, permet de convertir en cm
 
     if(width > 100){
          digitalWrite(LedGreen, HIGH);
          digitalWrite(LedOrange, LOW);
          digitalWrite(LedRed, LOW);
     }
 
     else if(width >= 30 && width <= 100){
          digitalWrite(LedGreen, LOW);
          digitalWrite(LedOrange, HIGH);
          digitalWrite(LedRed, LOW);
     }
 
     else {
          digitalWrite(LedGreen, LOW);
          digitalWrite(LedOrange, LOW);
          digitalWrite(LedRed, HIGH);
     }
}

Retrouver la Datasheet du capteur ultrason HC-SR04.

Test du capteur de recul

Après avoir programmé et téléversé le programme dans votre Arduino, nous pouvons le tester.

Voici le résultat !

Capteur de recul + Led

Capteur de recul + Led

(N’ayant pas de Led verte ni orange, j’ai modélisé ça par 3 Led rouge. A gauche censé être la verte, au milieu la orange et à droite la rouge).


Grégoire A.

Image de une tutoriel photorésistance

Apprenez à utiliser une photorésistance

By | Débutant Arduino | One Comment

Bonjour les arduinistes !

Dans ce nouveau tutoriel, nous allons mettre en application à travers un petit projet vos acquis sur l’utilisation des LEDs, de la photodiode et bien évidemment de l’Arduino.

Matériel nécessaire :

  • Une LED
  • Une photodiode
  • Deux résistances, une de 470 Ohm et une de 10 kOhm
  • Un potentiomètre
  • Un écran LCD
  • Un arduino

Voici le schéma du montage que nous allons réaliser.

Je me suis permis d’ajouter un écran LCD afin de visualiser la valeur relevée pas la photodiode. Vous n’êtes pas obligé d’utiliser cet écran pour le fonctionnement du montage.

Schéma de montage d'une photorésistance

Schéma de montage montrant l’application d’une photorésistance dans un projet Arduino

Si vous souhaitez utiliser un écran LCD, n’oubliez pas de câbler le potentiomètre de réglage du contraste de l’écran.

Commençons par regarder la partie 1 du schéma

Qu’est-ce qu’une photorésistance ?
Une photorésistance est une résistance sensible à la lumière. Cela signifie qu’en fonction de la lumière qu’elle perçoit sa résistance va varier. On va donc utiliser cette caractéristique pour réaliser notre montage.

Sur le schéma j’utilise une résistance de 470 Ohm. Lors de mes tests, j’ai utilisé une résistance de 10kOhm. Plus la valeur de la résistance est élevée, plus la sensibilité à la luminosité du capteur sera grande. Mais pas de panique, ça fonctionne très bien avec des résistances plus faibles.

Regardons la partie 2

Il s’agit ici du montage de l’écran LCD, je ne vous apprends rien. Dans mon cas j’ai suivi la datasheet et câblé en 4 bits.

Regardons pour finir la partie 3

Il s’agit du branchement d’une diode. Rien de plus simple ! N’oubliez quand même pas de mettre une résistance pour protéger votre LED.

Passons maintenant au code !

Dans un premier temps, il nous faut déclarer nos variables

1
2
3
4
#include 
//LiquidCrystal(rs, enable, d4, d5, d6, d7);
LiquidCrystal lcd(9, 8, 7, 6, 5, 4);
const int L1 = 12;

Vous pouvez le voir, nous avons besoin d’importer la librairie relative à l’écran LCD.
Ensuite je définis un « LiquidCrystal » que je nomme « lcd » auquel je lui affilie des entrées sur la carte Arduino.

Et enfin je crée une constante pour ma LED.

Une fois les variables définies, nous initialisons notre programme dans le setup.

1
2
3
4
5
6
7
8
9
void setup()
{
//Définition du type d'afficheur
//Ici un 4 lignes de 20 caractères
lcd.begin(20,4);
 
pinMode(A0, INPUT);
pinMode(L1, OUTPUT);
}

La photorésistance est une entrée analogique. Toutes mes entrées étant libre, je décide arbitrairement de me connecter au pin A0.

Et enfin, nous déclarons notre LED comme étant une sortie.

Pour ce qui est du reste du code, ce qui va permettre de gérer la fonction, j’ai créé une fonction afin d’alléger la « loop »

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
void loop()
{
int val = display_lux_tempsExec();
digitalWrite(L1, HIGH);
if (val < 700)
{
digitalWrite(L1, LOW);
}
}
 
int display_lux_tempsExec()
{
int val = analogRead(A0) ;
lcd.setCursor(1, 0);
lcd.print("Valeur lumiere :");
lcd.setCursor(5, 1);
lcd.print(val);
lcd.print(" lux ");
lcd.setCursor(1, 2);
lcd.print("Temps d'execution :");
lcd.setCursor(5, 3);
lcd.print(millis()/1000);
lcd.print (" sec");
return val ;
}

Concentrons-nous sur la fonction display_lux_temps_Exec().
Cette fonction permet d’afficher en temps réel les variations lumineuses ainsi que le temps d’exécution du programme.

Regardons à présent la fonction loop().
Cette fonction tourne à l’infini.
On exécute donc en boucle la fonction d’affichage sur l’écran LCD.

De plus, nous faisons un test de condition qui permet de gérer l’allumage de la LED si la luminosité descend en dessous de 700 dans mon exemple. Vous pouvez modifier cette valeur en fonction de votre environnement intérieur.

 

Voilà, vous savez dès à présent contrôler votre photorésistance à travers ce petit tutoriel.

Les applications sont infinies ! N’hésitez pas à imaginer de nouvelles applications.

Thomas A.

Image de une du tutoriel Entrees Sorties analogiques

Entrées / Sorties analogiques

By | Débutant Arduino | No Comments

1. Introduction

Entrée en rouge et Sorties en vert

numérique en rouge et analogique en vert

Après avoir vu ensemble les entrées et les sorties numériques, c’est à dire en tout ou rien, (soit on envoie une donnée, soit on envoie rien), nous allons voir ensemble comment gérer des composants en envoyant un peu, moyennement ou beaucoup de tension si par exemple on souhaite alimenter un moteur avec une vitesse précise.

Les entrées / sorties analogiques communiquent elles aussi avec les composants qui sont reliés à l’aide de la tension de l’Arduino.

Ces entrées et sorties varient entre 0V et 5V.

En reprenant notre exemple d’introduction avec le moteur, on peut alimenter un moteur avec une tension de 0.5V. Cela permet d’avoir une maîtrise totale de la vitesse.

2. Déclarer une entrée

Comme pour le tutoriel sur les Entrées / Sorties numériques, nous avons besoin de déclarer les entrées. Cela se fait de la même manière que pour les entrées numériques. Cependant, le numéro des « pins » ne sont pas les mêmes. Les « pins » compatibles avec les données analogiques sont « A0, A1, A2, A3, A4, A5 ».

1
int nom_entree = numero_pin;

Ensuite, dans la fonction d’initialisation de l’Arduino « void setup() », on déclare que la variable crée précedement est une entrée :

1
pinMode(nom_entree, INPUT);

Rappel : Ne pas oublier le « ; » à la fin de chaque ligne de code.

3. Déclarer une sortie

Pour déclarer une sortie, on procède de la même manière.
Les « pins » de sorties sont les « pins » avec les symboles « ~ », c’est-à-dire, les numéros « 3, 5, 6, 9, 10, 11 ». Ces « pins » sont des sorties « PWM » (Power Wave Modulation).

Il suffit de remplacer « INPUT » pas « OUTPUT ».

1
2
3
4
5
6
7
8
9
10
11
int mon_entree = A0;
int ma_sortie = 3;
 
void setup() {
     pinMode(mon_entree, INPUT);
     pinMode(ma_sortie, OUTPUT);
}
 
void loop() {
 
}

4. Utilisation d’une entrée

Pour commander une entrée analogique, on envoie une donnée comprise entre 0 et 1023, ce qui nous donne bien 1024 possibilités.

On utilise pour cela la fonction « analogues(var); ».

Cette fonction permet de lire la valeur qui est affectées au pin auquel le composant est relié.

Il est souvent nécessaire de convertir la valeur lue. En effet, la valeur affichée est comprise entre 0 et 1023, ce qui ne donne pas une tension. Il faut alors convertir cette valeur. Comment ? (Vous aller me dire).

Sachant que la valeur 1023 correspond à 5V, alors à l’aide d’un produit en croix, on retrouve facilement la valeur de la tension désirée.

Exemple

Le programme retourne la valeur 429.

On souhaite la valeur en Volt (V) associée ) 429. On obtient :

1
valeur = (429 * 5) / 1023

Soit :

1
valeur = 2.096 V

Ainsi, il suffit de rentrer la formule de conversion dans le programme pour avoir le résultat attendu.

Cependant, il existe une fonction permettant de faire cette conversion de manière automatique. Il s’agit de la fonction :

1
map(var, extreme_base_entree, extreme_haute_entree, extreme_basse_sortie, extreme_haute_sortie);

En reprenant l’exemple ci-dessus, nous avons simplement à inscrire la fonction suivante :

1
map(valeurLue, 0, 1023, 0, 5) //ce qui renverra une valeur en mV

ou :

1
map(valeurLue, 0, 1023, 0, 5000) //ce qui renverra une valeur en V

5. Utilisation d’une sortie

Après avoir appris à commander une entrée, nous allons apprendre à commander une sortie analogique.

Pour effectuer cette action, on utilise la fonction :

1
analogWrite(var, valeur)

ATTENTION : La fonctions « ananlogWrite(var, valeur), s’utilise seulement avec sur les pins PWM.

Grégoire A.

Image de une du tutoriel Entrees Sorties numeriques

Entrées / Sorties numériques

By | Débutant Arduino | No Comments

1. Introduction

Entrée en rouge et Sorties en vert

numérique en rouge et analogique en vert

Retrouvez aujourd’hui un nouveau tutoriel sur l’Arduino. Nous allons voir ensemble, dans ce tutoriel, comment utiliser les pins d’entrées et de sorties de l’Arduino. C’est grâce à ces pins que l’Arduino peut envoyer des données (data) aux programmes que vous développez et permettent de commander les différents capteurs que vous avec ajouté à votre projet ou en les alimentant énergie.

2. Déclarer une entrée

Comment déclarer une entrée sur l’Arduino ?
Afin de déclarer une entrée a l’Arduino, nous allons utiliser un pin. Qu’est-ce qu’un « pin » vous allez dire. Un « pin » est une « broche » dans laquelle nous allons câbler nos entrées, sorties et alimentation pour les composants que nous utiliserons.

Rappel : On donne un nom à la variable utilisée de la manière suivante :

1
int nom_entree = numero_pin;

Ensuite, dans la fonction d’initialisation de l’Arduino « void setup() », on déclare que la variable crée précedement est une entrée :

1
pinMode(nom_entree, INPUT);

ATTENTION : Dans le langage de l’Arduino, n’oubliez jamais le « ; » à la fin de chaque ligne de script. En cas d’oubli, votre programme ne se compilera pas.

3. Déclarer une sortie

Si vous avez compris comment déclarer une entrée, déclarer une sortie n’a plus aucuns secrets pour vous.

Il suffit de remplacer « INPUT » pas « OUTPUT ».

1
2
3
4
5
6
7
8
9
10
11
int mon_entree = 2;
int ma_sortie = 3;
 
void setup() {
     pinMode(mon_entree, INPUT);
     pinMode(ma_sortie, OUTPUT);
}
 
void loop() {
 
}

4. Utilisation d’une entrée

NB : Pour se servir d’une entrée, il faut utiliser la fonction « digitalRead() ». Utilisation de la fonction « digitalRead(numero_pin) » :

  • Indiquer le numero du pin de l’entrée voulue.
1
digitalRead(2) ; //On lit l’entree du pin 2

Faisons un exemple tout simple. Lors d’un appui sur un bouton poussoir, une LED s’allume.

Matériel :

Programme :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int mon_entree = 2;
int ma_sortie = 3;
 
void setup() {
     pinMode(mon_entree, INPUT);
}
 
void loop() {
     if(digitalRead(mon_entree) == 1) {
          digitalWrite(ma_sortie, HIGH);
     }
     else {
          digitalWrite(ma_sortie, LOW);
     }
}

5. Utilisation d’une sortie

NB : Pour utiliser une sortie en tant qu’alimentation d’un composant, il va falloir le spécifier dans la boucle de l’Arduino. Ceci se fait avec la fonction suivante :

1
digitalWrite()

Utilisation de la fonction « digitalWrite(var, état) » :

  • Indiquer le nom de la variable puis l’état de la sortie. « HIGH » si vous voulez que la sortie de l’Arduino envoie une tension sinon mettez « LOW ».
1
digitalWrite(ma_sortie, HIGH);

6. À vous de jouer

Je vous propose de créer votre premier projet Arduino, cette basique, mais constructif. En effet, le but de cet exercice est de vous faire manipuler les fonctions que l’on vient de vois ensemble.

Objectif : Faire clignoter une LED

Ressources : Vous allez avoir besoin d’une fonction que nous n’avons pas encore vu, c’est la fonction « delay() ». Cette fonction a pour but d’ajouter un délai à l’Arduino. C’est-à-dire de le faire attendre pendant X millisecondes.

Matériel :

  • 1 LED
  • 1 résistance
  • 1 Arduino

Consigne : Vous devez allumer une LED pendant 2 secondes puis l’éteindre pendant 2 secondes et ainsi de suite sans arrêt.

Une correction est à votre disposition en dessous pour comparer avec votre programme. (Sachez qu’il n’y a pas un unique programme possible, alors même si le votre n’est pas identique à celui proposé et qu’il fonctionne, ne vous inquiétez pas).

Exemple de correction

1
2
3
4
5
6
7
8
9
10
11
12
int LED = 2;
 
void setup() {
  pinMode(2, OUTPUT);
}
 
void loop() {
  digitalWrite(2, HIGH);
  delay(5000);
  digitalWrite(2, LOW);
  delay(5000);
}

Grégoire A.

Illustration tutoriel boucle Arduino

Les Boucles Arduino

By | Débutant Arduino | One Comment

Bonjour,
le tuto qui va vous être présenté va vous permettre de créer des « boucles ».
Nous allons voir ensemble et pas à pas comment construire une « boucle » et voir les contextes d’utilisations. Les boucles sont différentes des conditions mais peuvent aussi en contenir. Nous verrons deux types de boucles ici: « while » et « for ». Dans un prochain tutoriel, nous aborderons les prises de décisions, autre point fondamental pour lequel il est obligatoire de savoir utiliser les boucles. Commençons notre tutoriel par la définition même des boucles…

 

Qu’est-ce qu’une « boucle » ?

En informatique et plus particulièrement en programmation, une boucle (« loop » en anglais) est un bout de code, une instruction permettant de répéter en partie ou tout un programme.
Pour cela, il existe deux types de « boucles » :

  • La boucle conditionnelle, qui permet de tester une condition et qui exécute le programme tant que la condition testée est vraie.
  • La boucle dite de répétition, qui quant à elle, exécute le programme un nombre de fois défini.

 

  1. La boucle « while »

En anglais, le mot « while » signifie « tant que ». Donc le programme que l’on va écrire, s’exécutera « tant que » la condition sera vraie (ou fausse).

 

Construction de la boucle « while » :

La boucle « while » à une syntaxe extrêmement simple, car elle est de la forme :

1
2
3
4
while( /*condition à tester */) 
{
                //les instructions à répéter tant que la condition est vérifiée
}

 

Faisons ensemble un exemple :
Nous souhaiterions créer un compteur.

1
2
3
4
5
6
int compteur = 0 ;
 
while(compteur != 10) //tant que compteur est différent de 10
{
                compteur ++ ; //On incrémente d’une unité
}

Le programme passera aux actions suivantes une fois la condition vraie.

 

  1. La boucle « for »

En anglais, le mot « for » signifie « pour que ». Cette fonction permet de répéter une action, un bout de programme autant de fois qu’on le souhaite.

La boucle « for » se crée de la façon suivante :

1
2
3
4
for(/*initialisation de la variable*/ ; /*condition de la boucle*/  ; /*instruction à exécuter*/)
{
                // ligne de code à exécuter
}

 

Voyons comment se compose cette fonction :

  • Création de la variable
  • Commande que la boucle doit tester
  • Instruction à exécuter

 

Exemple basique du compteur :

1
2
3
4
for(int compteur = 0 ; compteur < 10 ; compteur++)
{
                // fonction à répéter
}

 

 

 

Voilà pour les boucles en Arduino. N’oubliez pas que ce sont des structures qui ressemblent aux prises de décisions mais qui permettent de boucler une fonction tant que la condition est vraie.

A bientôt sur Simple-Duino
Grégoire A.

Illustration tutoriel servomoteurs Arduino

Les servomoteurs et l’Arduino

By | Débutant Arduino | No Comments

Aujourd’hui, nous allons apprendre ensemble à contrôler un servomoteur de modélisme  à l’aide d’un arduino.

Le matériel nécessaire :

  • Un arduino
  • Un servomoteur
  • Des fils de connexions

 

Câblage du servomoteur à l’arduino.

Les servomoteurs ont 3 fils de connexions :

  • Le + (Généralement rouge)
  • Le – (La masse, généralement noire ou marron)
  • Le fil de l’impulsion de commande (Généralement blanc ou jaune)

Pour relier le servomoteur à l’arduino, vous devez brancher :

  • Le fil + sur le + de votre alimentation externe
  • Le fil noir (la masse), sur le 0V (ou GND « ground » en anglais)
  • Le fil de l’impulsion de commande sur une entrée numérique « digital » PWM

Voici un schéma de branchement :

Montage d'un ServoMoteur

Montage d’un ServoMoteur

Utilisation de la librairie

L’arduino est livré avec toute sorte de librairies (permettant d’invoquer des fonctions).
Pour inclure une librairie dans un programme arduino, rien de plus simple. Il suffit d’entrer la ligne suivante au début du programme :

1
#include <Servo.h>

Cette librairie concentre plusieurs fonctions, au nombre de 6 :

1
attach()
1
write()
1
writeMicroseconds()
1
int read()
1
boolean attached()
1
detach()

Nous allons voir ensemble a quoi correspondent les differentes fonctions ci-dessus.

La fonction « attach() » permet de rattacher le pin dans lequel nous avons branché le fil jaune.

1
2
3
4
5
6
7
8
9
10
11
#include <Servo.h>    // Permet d'inclure la librairie
 
Servo servo;       // Creation d'une variable appelee "servo"
 
void setup() {
 
  servo.attach(0)  // J'attache "servo" au pin A0 de l'arduino
 
}
 
void loop() {}

 

La fonction « write() » permet de donner une consigne au servomoteur.
On utilise généralement la syntaxe suivante : var.write(angle)

Avec « var » le nom de la variable du servo et « angle » la valeur que l’on veut donner au servo.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <Servo.h>   // Permet d'inclure la librairie
 
Servo servo;       // Creation d'une variable appelee "servo"
 
void setup() {
 
  servo.attach(2)  // J'attache "servo" au pin 2 de l'arduino
 
  servo.write(90)  // Positionne le servomoteur à 90°
 
}
 
void loop() {}

 

La fonction « read() » permet de lire la valeur envoyée par la fonction « write() ». La valeur renvoyée est un entier (« integer » en anglais, souvent notée « int » dans les livres ou sur internet).

Illustration tutoriel des variables Arduino

Les variables Arduino

By | Débutant Arduino | No Comments

Nous vous proposons aujourd’hui un cours théorique sur le choix et l’utilisation des variables dans le langage Arduino. On a tous constaté un jour qu’il existait un grand nombre de type de variables dont certaines que nous avions jusqu’ici jamais utilisé. Mais alors pourquoi tant de types de variables ? Parce que choisir un type de variable qui correspond exactement à ce dont vous avez besoin est important pour des raisons de mémoire sur votre Arduino. En optimisant vos scripts, vous pourrez mieux exploiter votre Arduino. Suivez nous dans ce cours théorique plus que tutoriel et découvrez alors les principaux types de variables existants en langage Arduino.

  • Les variables numériques

Les variables numériques sont sans doute les variables les plus utilisé sur Arduino. Elles permettent de stocker des valeurs entières ou décimales qui occuperont plus ou moins d’espace. Ici, nous allons en présenter 8 qu’il nous semble important de connaitre.

Le premier type de variable que nous souhaitons aborder est « byte »
Byte définie une donnée codée sur 8 bits (donc un octet) et qui peut donc  prendre une valeur comprise en 0 et 255.

On peut écrire:

1
byte val = 98; // 98 en décimal

OU

1
byte val = B00101111; // 47 en binaire (le B signifie binaire)

Il nous parait important d’aborder le type « int » qui est sans doute le plus utilisé
Int est codé sur 2 octets, soit 16 bits et peut ainsi prendre une valeur comprise entre -32 768 et +32 768

On peut écrire:

1
int val = -6526;

Conjointement à int, il existe une version non signée, « unsigned int », toujours codée sur 2 octets donc 16 bits mais positif c’est-à-dire qu’il peut prendre une valeur comprise entre 0 et 65535.

On peut écrire:

1
unsigned int val = 34000;

Un autre type de variable, « word » permet de définir une variable avec les mêmes attributs que le type « unsigned int », c’est-à-dire une variable codée sur 2 octets, soit 16 bits, toujours positive et qui prend une valeur comprise entre 0 et 65535.

Dans le même principe, il existe « long » et sa version non signée « unsigned long » qui permet de définir une variable codée sur 4 octets, signée dans le cas de « long » et non-signée dans le cas « unsigned long ».

On peut écrire:

1
long val-15697536;

OU

1
unsigned long val = 15976254;

Enfin, le type de variable « float » est relativement important puisque c’est l’un des seuls qui permet de gérer les nombres à virgules. Comme dans tous les langages, on constatera que la virgule décimale est remplacée par un point…

On peut écrire:

1
float val = 1.76;

Enfin, pour des raisons de cohérence avec le langage C, le type de variable « double » existe en Arduino et permet les mêmes définitions que pour « float ».

Ainsi, on peut écrire:

1
double val = 1.76;
  • Les variables logiques

Les variables logiques, dites « booléennes » sont au nombre de deux cependant nous n’en traiteront qu’une, la seconde étant propre au définition de fonctions que nous aborderons sans doute dans un prochaine tutoriel.

Ainsi, il existe le type de variable « boolean » qui peut prendre deux valeurs: « true » ou « false ». Cette variable occupe un octet de mémoire.

On peut écrire:

1
boolean val = true;

OU

1
Boolean val = false;

Voilà pour ce premier cours théorique sur les variables. Nous espérons que cela vous permettra d’optimiser un peu mieux vos scripts Arduino. Optimiser la mémoire utilisée est un élément important dans la conception d’un système complexe et pouvoir choisir un type de variable qui correspond exactement à votre besoin.

Nous traiterons les variables de textuelles dans un prochain tutoriel car le sujet est vaste et complexe.

Bon développement à tous, merci d’être toujours plus nombreux à nous suivre !

Illustration tutoriel utilisation de flowcode avec Arduino

Simplifier le développement Arduino avec Flowcode

By | Débutant Arduino | No Comments

Flowcode, vous connaissez ? Non ? Pourtant, ce logiciel permet de grandes choses qui vous aiderons certainement à développer vos prochains programmes Arduino. En effet, tout l’intérêt de ce logiciel, du moins dans sa version AVR, est qu’il va permettre de  » coder  » votre programme sous forme d’algorigramme. Ensuite, vous aurez la possibilité de l’uploader tel quel sur votre carte ou de le recoder proprement à la main. Pour ma part, j’opte toujours pour la seconde méthode mais vous allez voir que le logiciel nous simplifie tout de même grandement la tâche…

 

  • Découvrons l’interface de Flowcode AVR

Je vais résumer toute l’interface de Flowcode en une image qui détaille chacun des espaces, chacune des barres, qui composent le logiciel Flowcode.

 

présentation_interface

 

Maintenant, vous avez sans doute un nouveau regard sur le logiciel. Nous allons développer un simple programme qui écrit  » Hello World !  » sur un écran LCD lors de l’appui d’un bouton.

 

  • Ajouts des composants

Avant de développer notre programme, nous allons ajouter les composants nécessaires grâce à la barre d’outils que j’ai nommé  » Réalisation du montage  » sur l’image précédente. Dans sorties, nous allons choisir  » lcd  » et nous ajouterons un bouton (switch) que nous aurons sélectionné dans le menu  » entrées « . Voici ce que vous devriez obtenir à ce moment du tutoriel :

 

réalisation_montage

 

Vous remarquerez que j’ai modifié l’apparence de mon bouton : J’ai simplement fait un clic droit puis  » Propriétés Ext  » et j’ai sélectionné  » Bouton poussoir  » dans le menu  » Type « .

 

  • Création du programme

Bien, notre montage est prêt, nous n’avons rien à relier, c’est là aussi la simplicité de Flowcode…

Désormais, nous allons devoir créer notre programme.

Dans le menu à gauche, nous allons cliquer-glisser sur un bloc « Routine composant » vers le zone de développement. Vous devez déposer ce bloc entre les balises « DEBUT » et « FIN ». Double-cliquez sur ce que vous venons d’ajouter. Vous devriez avoir cette fenêtre devant vous :

 

fenetre_creation_programme

 

Nous allons commencer par initialiser l’afficheur LCD. Sélectionnons  » LCDDisplay(0)  » puis  » Init « , on valide ensuite en appuyant sur « ok ». Voilà, l’écran est initialisé. Sur le même principe, vous aurez besoin de la macro « Curseur » de « LCDDisplay(0) », de la macro « Ecrit_chaine » (LCDDisplay(0) toujours) ainsi que de la macro « Lire_Etat() » de « SWITCH(0) ».

 

Concernant cette macro, voici la manière dont j’ai procédé pour stocker l’état du bouton. J’ai créé une variable PushButton qui prends la valeur 1 si le bouton est appuyé. Pour cela, vous devez cliquer sur la flèche à droite de « Valeur Retour » après sélection de « Lire_Etat ». Une fenêtre va s’ouvrir, vous allez pouvoir double-cliquer sur « Variables » pour en créer une nouvelle. Nommez la « PushButton », mettez 0 en valeur initale et choisissez « octet » en type de variable.

Enfin, je vous propose de vous présenter mon programme complet afin que vous compreniez comment j’ai procédé pour la suite:

 

programme_termine

 

Les points de jonction permettent de « retourner » vers un point d’ancrage. Le premier est le repère vers lequel le second se dirigera si la condition est fausse. En condition, j’ai mis pushButton = 1 car cela signifie que le bouton est appuyé.

 

Voilà pour le programme ! Vous pouvez désormais l’exécuter grâce au symbole symbole_compilation situé dans la « barre de compilation ».

Testez-le en appuyant sur le bouton poussoir et le texte « Hello World » devrait normalement s’afficher comme sur l’exemple suivant:

 

hello_world_flowcode

 

En conclusion de ce tutoriel, nous pourrions rappeler que Flowcode est un logiciel qui possède de grandes qualités avec une large diversité de programme à développer. Ici, je n’ai présenté que le « plus simple » de Flowcode mais il faut savoir qu’il est aussi capable de simuler des modules radiofréquences, des serveurs webs, etc…

Encore un logiciel complet et relativement simple dont vous ne pourrez maintenant plus vous passer.