was successfully added to your cart.
All Posts By

Grégoire Aubret

(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.

Retour sur la MakerFaireParis 2016

By | Non classé | No Comments

Ce week-end la MakerFaireParis à donné rendez-vous aux Makers pour « changer » le monde. Un record de visite a été franchi puisque ce sont 65 000 visiteurs qui ont fait le déplacement, comparé aux 35 000 visites l’année dernière.

Nous y étions afin de vous rencontrer mais aussi pour parler programmation, Arduino et Raspberry.

Stand SimpleDuino MFP16

Stand de Simple-Duino dans le hall Maker Faire de la Foire de Paris 2016 à Paris Expo

Comme vous le savez maintenant, nous venons de terminer le drone. Il est fonctionnel et nous permet de filmer grâce au stabilisateur de GoPro®. Une caméra FPV a été ajoutée afin d’avoir un retour en temps réel et de pouvoir faire des vols en immersion.

Maintenant, il ne nous reste plus qu’à rendre ce drone autonome. Nous avons d’abord pensé réaliser les actions suivantes :

  • Coder la carte de contrôle avec son système de stabilisation
  • Coder un système de positionnement GPS
  • Coder un système de gestion d’obstacle
  • Coder un système de triangulation permettant de déterminer si un sol est suffisamment plat pour se poser
  • Coder un système de gestion de batterie
  • Réaliser une interface web ou un logiciel afin de le commander à distance

Bien évidemment, nous gardons le système de commande actuel afin de pouvoir récupérer la main en cas de problème.

Nous souhaitons rendre open-source ce système afin qu’il puisse être ajouté sur vos propres réalisations.

Nous allons réaliser un tutoriel par capteur et module que nous allons utiliser puis nous expliquerons la mise en commun de tous ces modules afin de répondre au cahier des charges que nous nous sommes imposés.

Bien entendu, la MakerFaireParis a été l’occasion pour nous de vous rencontrer mais aussi de rencontrer des partenaires. Nous avons notamment rencontré les équipes de eMotion Tech, une entreprise Française et toulousaine qui développe et propose à la vente des imprimantes 3D à des prix raisonnables. Nous avons rencontré les responsables du TechShop de Paris, de la créathèque à Nogent sur Oise, des ingénieurs de TxRobotic ou encore des responsables de la communauté Oui Are Makers.

Certains d’entre vous sont venus nous faire part du plaisir qu’ils prenaient à nous lire régulièrement, ces compliments nous vont droit au cœur, nous continuerons ce que nous faisons, cela nous motive encore plus, encore merci !

Rédacteurs et rédactrices de presse papier, nous ne vous oublierons plus ! Vous nous avez fait part de votre déception de voir nos images d’articles être disponibles seulement en 72dpi, la résolution largement répandue sur le web alors que vos formats nécessitaient des images en 300dpi. Sachez que l’équipe Simple-Duino s’appliquera désormais à proposer des « kits presse » en format .zip à la fin de chaque tutoriel. Ces « kits presse » contiendront les images de l’article en 300dpi. Cette mesure n’est pas rétroactive mais vous pourrez cependant demander des images d’articles antérieurs à cette décision en 300dpi en contactant l’équipe via l’adresse [email protected].

La MakerFaireParis nous a permis de présenter nos travaux tant en impression 3D, en modélisme ou en domotique. De nombreuses personnes ont été très étonnées de découvrir la totale gratuité de nos cours, c’est pourtant bel et bien le cas et cela le restera. Certains se sont inquiétés de notre modèle de financement. Pas d’inquiétude ! Si nous sommes là et que nous continuons de l’être, c’est avant tout parce que nous sommes passionnés. SimpleDuino continuera de proposer ses articles en accès libre, gratuit et sans inscription, c’est notre priorité.

L’équipe Simple-Duino s’est déjà remise au travail en préparant les tutoriels que nous avons promis lors de la MakerFaire. Pas plus d’infos pour l’instant, vous découvrirez d’autres nouveautés petit à petit.

Vous avez été nombreux à nous rendre visite et nous tenons tous à vous en remercier.


L’équipe de SimpleDuino

Quadcoptère DIY Open-source

By | Projets

On se retrouve aujourd’hui pour la présentation d’un projet tout juste terminé. Nous allons vous présenter notre drone quadcoptère SD Q4 DIY (Do It Yourself).

Le SD Q4 est un quadcoptère mesurant 50 cm de long sur 40 cm de large pour un poids de 1,5 kg.

Drone quadcopter SD Q4

Drone quadcopter SD Q4

  • Construction du drone

Nous avons modélisé nous même les différentes parties du drone que nous avons mis en téléchargement open source sur GrabCab. Vous pouvez retrouver toutes les pièces nécessaires à la fabrication du quadcoptère au format SolidWorks Version 2016 et au format STL pour une impression directe.

Dans la structure du drone, nous avons fait passer des tiges de carbone afin d’avoir une plus grande rigidité à ce niveau. Toutes les pièces ont été imprimées en 3D par nos propres moyens.

  • Electronique de contrôle

Pour la partie de contrôle du drone, nous avons utilisé les composants suivant:

–  Récepteur Walkera HM-DEVO-RX-1002

–  Contrôleur de vol Naze32

–  4x Variateurs HP SimonK 30A

–  Batterie LiPo 5200mAh 4S 14.8V

–  4x Moteurs DYS Brushless Motor BE2212 1000 Kv

Concernant le coût de ce projet, il nous est revenu à 330€. Des améliorations sont à prévoir, avec l’installation d’un train d’atterrissage et d’une Gimbal pour GoPro.

Licence Creative Commons
Quadcoptère de SimpleDuino est mis à disposition selon les termes de la licence Creative Commons Attribution – Pas d’Utilisation Commerciale – Partage dans les Mêmes Conditions 4.0 International.
Fondé(e) sur une œuvre à https://grabcad.com/library/drone-quadcopter
Les autorisations au-delà du champ de cette licence peuvent être obtenues à http://simple-duino.com.


Grégoire A.

Afficheurs 7 segments et l’Arduino

By | Intermédiaire Arduino | No Comments

Nous nous retrouvons pour un nouveau tutoriel Arduino sur les afficheurs 7 segments.
Vous avez tous déjà vu ou entendu parlé de ces afficheurs.

De quoi s’agit il ? Un afficheur 7 segments est un composant comme celui-ci :

Afficheur 7 Segments

Afficheur 7 Segments

Il est composé de 7 diodes, ici les 7 segments, en forme de « ligne » qui permettent de former des chiffres allant de 0 à 9. Ces afficheurs sont souvent rouges mais on peut en trouver de couleur blanche, bleue, verte …

Pour la réalisation de ce tutoriel, nous allons avoir besoin d’un peu de matériel. Mais comme à notre habitude, je vous transmet une liste de ce dont nous allons utiliser :

Matériel

  • 1 afficheur 7 segments
  • 8 résistances de 330 Ohms
  • 1 carte Arduino

Pour la réalisation de ce tutoriel, je vais utiliser un afficheur à Cathode commune. C’est à dire que l’afficheur possède un GND pour toute les diodes et qu’il suffira d’envoyer 5V dans les pins que nous voulons allumer pour former les chiffres.

Présentation de l’afficheur

L’afficheur que je vais utiliser est similaire à la photo suivante :

Présentation afficheur 7 segments

Présentation afficheur 7 segments

Cet afficheur est composé de 7 segments référencés de A à F de la manière suivante :

Branchements pins

Branchements pins

Références segments

Voici la signification des différents pins :

Significations des pins

Significations des pins

A présent, nous allons réaliser le branchement de l’afficheur. Voici celui que j’ai réalisé :

Schéma de branchement

Schéma de branchement

Vous pouvez voir sur ce schéma que l’on a branché à la masse les pins 3 et 8 et tous les autres pins sont branchés à des sorties de l’Arduino.

Avant de commencer, voici un tableau dans lequel est récapitulé les pins à mettre à l’état 1 pour afficher les caractères suivant :

Caractères

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
int A = 2;
int B = 3;
int C = 4;
int D = 5;
int E = 6;
int F = 7;
int G = 8;
 
void setup(){
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(E, OUTPUT);
  pinMode(F, OUTPUT);
  pinMode(G, OUTPUT);
 
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
    }
 
void loop(){
  zero();
  delay(1000);
  un();
  delay(1000);
  deux();
  delay(1000);
  trois();
  delay(1000);
  quatre();
  delay(1000);
  cinq();
  delay(1000);
  six();
  delay(1000);
  sept();
  delay(1000);
  huit();
  delay(1000);
  neuf();
  delay(1000);
  }
 
void zero(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, LOW);
    }
 
void un(){
  digitalWrite(A, LOW);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, LOW);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, LOW);
    }
 
void deux(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, LOW);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
    }
 
void trois(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH;
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
  }
 
void quatre(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, LOW);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
  }
 
void cinq(){
  digitalWrite(A, HIGH);
  digitalWrite(B, LOW);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  }
 
void six(){
  digitalWrite(A, HIGH);
  digitalWrite(B, LOW);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  }
 
void sept(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, LOW);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, LOW);
  }
 
void huit(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  }
 
void neuf(){
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  }

Voila à quoi vous allez arriver :

Projet final

Projet final

A présent vous savez comment utiliser un afficheurs 7-segments. Vous pouvez combiner plusieurs afficheurs pour réaliser une horloge, un compteur ou encore afficher des mots.

Grégoire A.

Capteur de recul Arduino

By | Débutant Arduino, Projets | 7 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 construction d'une Prusa I2

Suivez la construction d’une RepRap pas à pas

By | Projets | No Comments

Je vous propose aujourd’hui de suivre l’avancement de la construction d’une imprimante Prusa i2 RepRap sur le forum afin que vous puissiez échanger, partager et commenter à propos du projet.

Imprimante 3D Prusa i2

Imprimante 3D Prusa i2

 

  • Qu’est ce que le projet RepRap ?

« RepRap est la première machine autoréplicative de production d’usage général fabriqué par l’homme ».
Ce qui signifie qu’avec une imprimante il est possible d’imprimer les pièces nécessaires à la fabrication d’une seconde imprimante. Ce projet a vu le jour en 2008.
La RepRap est une machine de prototypage rapide à construire soi-même pour réaliser des objets à partir de filaments plastique en PLA et / ou en ABS.
Retrouvez l’ensemble des informations concernant le projet RepRap ici.

  • A quoi peut servir une imprimante 3D ?

Une imprimante 3D permet de réaliser des objets 3D en plastique à partir d’un fichier 3D que l’on a modélisé sur un logiciel de CAO.

  • Quelles sont les contraintes ?

Certaines pièces ne sont pas imprimables en 3D par exemple des petites figurines ayant des niveaux de détails très précis. En effet, nous sommes limités en terme de précision par la buse d’extrusion.
De plus, vous ne pouvez pas imprimer (pour le moment, car la technologie ne le permet pas), des objets avec plusieurs matériaux.

  • Description de la RepRap

Description Prusa i3

Description Prusa i3

1°) Châssis
2°) Plateau
3°) Extrudeur
4°) Moteur
5°) Carte de commande
6°) Courroies

  • Pourquoi fabriquer son imprimante ?

1) Connaître sa machine

Un des nombreux avantages de construire son imprimante soi même de A à Z, est qu’elle n’aura plus aucun secret pour vous. En effet, vous serez capable de détecter et réparer une panne, mais aussi de tenir à jour votre machine afin qu’elle puisse s’adapter aux nouvelles technologies.

Les nouvelles technologies ou les modifications de pièces sont directement accessibles sur internet et « imprimable » via votre imprimante 3D.

De plus, le fait de connaître parfaitement sa machine vous permettra de la modifier comme vous le voulez. Comme par exemple changer la géométrie de l’imprimante, augmenter sa taille pour avoir une plus grande surface d’impression… Libre à votre imagination. N’hésitez pas à partager vos créations et modifications sur notre forum.

2) Logiciel libre (Open Source)

La plupart des imprimantes fabriquées et vendues dans le commerce sont dites « propriétaire », c’est-à-dire que leurs plans, leurs modèles de fonctionnement et leurs informations techniques sont soit brevetés, soit tenues secrets. Il est donc difficile de modifier ou de réparer sa machine.

Qu’est ce que l’open Source ?

« Open source » désigne un logiciel ou le produit dans lequel le code source, les plans sont à la disposition du grand public, et c’est généralement un effort de collaboration où les programmeurs et les concepteurs améliorent ensemble le code source et partagent les changements au sein de la communauté ainsi que d’autres membres peuvent contribuer. (Source Wikipédia)

3) Economique

Bien que fabriquer soi-même son imprimante demande plus de temps, construire sa propre machine est bien souvent plus économique.

En effet, en 2014, les imprimantes 3D les plus accessibles sont de l’ordre des 400€ et peuvent monter jusqu’à 5000€, alors que monter soi-même sa machine revient à 250€ pour le model Prusa i2.

Vous choisissez vous même les composants que vous souhaitez utiliser, vous comparez les prix afin de trouver le juste prix entre Qualité et Economie. De plus, le prix d’un bobine de PLA est d’environ 20€ pour 1kg.

  • Fabrication

Tout d’abord, suivez la construction de la partie mécanique de l’imprimante : montage des pièces, montage des roulements, des axes.
Ensuite, suivez la partie configuration,
Puis la phase de test et première impression.

La partie électronique de l’imprimante se fera grâce au logiciel Open-source « Repetier-Host » téléchargeable gratuitement sur leur site internet et grâce à l’Arduino couplé à une carte de commande RAMPS 1.4. J’ai également décidé, pour un point de vu plus pratique, d’ajouter un écran sur l’Arduino afin de ne plus être obligé de passer par l’ordinateur pour imprimer une pièce.

La partie mécanique de l’imprimante étant terminée, je suis depuis plusieurs semaines en plein dans la programmation de l’imprimante.
J’utilise le logiciel Repetier-Firware. Ce logiciel se présente comme un site internet dans lequel nous devons renseigner les champs utiles.

Je vous laisse le temps de vous y adapter. La prise en main de cette configuration n’est pas très compliquée.

Après avoir configuré le logiciel, on nous propose de le télécharger. Faites le, et chargez le sur votre carte RAMPS 1.4 grâce au logiciel Arduino.

Voici les problèmes que j’ai rencontré :

  • Le moteur de l’extrudeur ne fonctionnait pas : Il y a une sécurité sur ce moteur. En effet, si la buse n’est pas chauffée à 170°C minimum, il est impossible de faire tourner le moteur.
  • Le plateau chauffant et le capteur du plateau n’était pas prit en charge. Pour résoudre ce problème, j’ai procédé de cette manière.
    Dans le fichier « configuration.h », il faut modifier une ligne :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// ############# Heated bed configuration ########################
 
#define HAVE_HEATED_BED 0 ( a mettre a 1)
#define HEATED_BED_MAX_TEMP 120
#define SKIP_M190_IF_WITHIN 3
#define HEATED_BED_SENSOR_TYPE 1
#define HEATED_BED_SENSOR_PIN TEMP_1_PIN
#define HEATED_BED_HEATER_PIN HEATER_1_PIN
#define HEATED_BED_SET_INTERVAL 5000
#define HEATED_BED_HEAT_MANAGER 0
#define HEATED_BED_PID_INTEGRAL_DRIVE_MAX 255
#define HEATED_BED_PID_INTEGRAL_DRIVE_MIN 80
#define HEATED_BED_PID_PGAIN_OR_DEAD_TIME 196
#define HEATED_BED_PID_IGAIN 33
#define HEATED_BED_PID_DGAIN 290
#define HEATED_BED_PID_MAX 255
#define HEATED_BED_DECOUPLE_TEST_PERIOD 300000
#define MIN_EXTRUDER_TEMP 150
#define MAXTEMP 275
#define MIN_DEFECT_TEMPERATURE -10
#define MAX_DEFECT_TEMPERATURE 290

Vous pouvez retrouver toutes les pièces à imprimer sur GitHub.


Suivez l’avancement et partager vos commentaires sur le forum.
Grégoire A.

Image de une du tutoriel Entrees Sorties analogiques

Entrées / Sorties analogiques

By | Débutant Arduino | One Comment

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.

Image de une du tutoriel du plus ou moins

Le jeu du plus ou moins en Python

By | Informatique | No Comments

Vous avez sans doute tous déjà entendu parler du jeu basique en programmation « C’est plus, c’est moins« , et bien aujourd’hui, je vous propose de le développer ensemble.
C’est un jeu basique, que l’on crée lorsque l’on apprend à programmer.

Je vous rappelle les règles :

  • L’ordinateur choisit un nombre entier positif (compris entre 0 et 100 par exemple)
  • Nous devons taper un nombre :
    • Si le nombre tapé est plus grand que le nombre tiré par l’ordinateur, le message « C’est moins » apparaît à l’écran
    • Si le nombre tapé est plus grand que le nombre tiré par l’ordinateur, le message « C’est plus » apparaît à l’écran
    • Si le nombre tapé est égal au nombre tiré par l’ordinateur, un message de félicitation apparaît à l’écran

Après avoir pris connaissance des règles, passons à la partir programmation.
Grace aux règles énoncées si dessus, vous devriez commencer à voir quel type de programme nous allons devoir faire. Nous allons utiliser la boucle « while », ainsi que les conditions.

Tout d’abord, vous aurez besoin d’importer un module pour que l’ordinateur tire aléatoirement un nombre entier.
Pour cela, il suffit d’écrire :

1
import random as rd

Ensuite, nous devons déclarer une variable afin que l’ordinateur tire un nombre au hasard.

1
nombreTire = rd.randint(0, 100)  #La fonction "randint" de la bibliothèque « random » tire un nombre entier

Initialisons une variable qui prendra comme argument le nombre que l’on tapera sur le clavier.

1
nombreTape = 0

Maintenant, il suffit de créer la boucle afin de tester les conditions.

1
2
3
4
5
6
7
8
9
10
11
while nombreTape != nombreTire : 
      print("Tapez un nombre entier :")
      nombreTape = int(input())
      if nombreTape > nombreTire :
            print("c'est moins\n\n")
 
      elif nombreTape < nombreTire:
            print("c'est plus\n\n")
 
      else :
            print("c'est gagné")

 

Capture d'écran du script plus ou moins

Capture du script du jeu plus ou moins sur Python IDLE

 

Résultat du jeu plus ou moins

Capture d’écran de la console Python exécutant le script du plus ou moins

 

Après enregistrement et lancement du jeu, vous devriez avoir une fenêtre comme celle affichée.

Bon jeu.

NB : la balise « \t » permet de créer une tabulation La balise « \n » permet de créer un saut de ligne.
La dernière ligne de code « os.system(« pause ») » permet de stopper le programme et fermer la fenêtre. Elle n’est pas obligatoire. Sans ce bout de code, votre programme se fermera aussi, mais vous noterez une différence. (A vous d’en faire l’expérience).

Gregoire A.

Image de une du tutoriel de connexion SSH sur mac

Connexion SSH sur Mac OS

By | Informatique | No Comments

Bonjour,
Depuis le début, sur notre site, vous pouvez trouver des tutoriels sur l’utilisation des GPIO du raspberry, de capteurs spécifiques pour l’Arduino, etc… Mais nous n’avons jamais vraiment pris la peine de commencer par le début, en présentant simplement la manière de se connecter en ssh sur un ordinateur Mac ou linux afin de prendre le contrôle de votre Raspberry Pi à distance. Sur Windows, nous avons Putty qui nous permet de gérer simplement les connexions ssh. Pour Mac et Linux, l’opération est tout aussi simple mais elle nécessite de connaitre quelques commandes de console pour la mener à bien. Voici donc la marche à suivre.

Pour se connecter en ssh via Mac ou Linux, ouvrez l’application « Terminal » et entrez-y la commande suivante :

1
ssh pi@IpDuRaspberry

si vous vous connectez avec l’utilisateur « pi ».

Si vous avez déjà configuré le profil « root », vous pouvez vous y connecter avec la commande suivante :

1
ssh root@IpDuRaspberry

(Pour activer le profil « root », rendez-vous dans le tutoriel suivant : Mise en place du profil root.)

Vous avez alors la fenêtre suivante. Il faut accepter en entrant « yes », puis tapez sur « Entrée ».

Puis entrez le mot de passe requis.

Demande du mot de passe pour la connexion en ssh

Demande du terminal mac du mot de passe ssh de connexion au Raspberry

Vous êtes à présent connecté à votre raspberry.

Résultat de la connexion en ssh

Résultat obtenu sur le terminal mac une fois que la connexion en ssh est établie

Lors de la prochaine connexion un message d’erreur vous sera peut être affiché. C’est un problème d’identification.

Pour résoudre cela, tapez la commande suivante :

1
ls ~/.ssh

puis tapez la commande afin de supprimer les clés déjà existantes

1
ssh-keygen -R IpDuRaspberry

Reconnectez vous avec la commande :

1
ssh root@IpDuRaspberry

 

Gregoire A.