# data[].attributes.attachment_link.readable_text
Apprenons à réaliser un télémètre à ultrasons grâce à une Arduino et un petit module complémentaire

Lorsque l'on veut mesurer des distances, on utilise en général une règle ou un ruban mètre. Mais comment faire pour avoir une distance numerique en temps réel ?

Une réponse : utiliser la technologie des ultrasons pour réaliser un télémètre.

Bien que peu précis à l'échelle des centimètres, ces derniers sont relativement fiables à l'échelle de la dizaine de centimètres. Les ultrasons étant des ondes sonores se propageant sous la forme d'un cône (ils sont peu directifs), ils font de très bons détecteurs d'obstacles.

Nous allons donc nous lancer dans la réalisation d'un petit télémètre à ultrasons via une Arduino et avec un affichage intégré sur un écran LCD (parce que la voie série, c'est un peu pénible pour se promener ). Voici les prérequis pour suivre ce tutoriel :

savoir se servir d'une Arduino ;

savoir utiliser un écran LCD alphanumérique avec l'Arduino.

À la fin de ce tutoriel, vous serez en mesure de :

utiliser un capteur HC-SR04 ;

comprendre et utiliser une information de type "temps de vol" ;

utiliser la fonction pulseIn() pour mesurer une durée d'état sur une broche.

Faisons un peu de sciences et rappelons ce que sont des ultrasons.

Un ultrason est une onde sonore à haute fréquence. Par haute fréquence j'entends toutes les fréquences sonores inaudibles pour l'oreille humaine, soit celles au-delà de 20 kHz. Elles sont l'opposé des infrasons qui sont les ondes sonores dont la fréquence est inférieure à la plus faible audible pour l'Homme et qui est de 20 Hz.

Bon, c'est bien beau mais cette histoire de fréquence ça ne nous en dit pas beaucoup plus !

Une onde sonore c'est quoi ?

Une onde sonore est un phénomène physique de compression et décompression. Lorsqu'une vibration est produite (par n'importe quel objet qui vibre), l'air subit alors une onde de choc qui se traduit en mouvement des atomes. Il y a alors ce phénomène de compression et décompression (des "trous" dans l'air) que des récepteurs dans nos oreilles convertissent en bruit.

Plus les compressions sont proches et plus la fréquence est élevée. On parle alors de son aigu. Au contraire, plus les compressions sont éloignées et plus la fréquence est faible, on parle d'un son grave. Une fréquence s'exprime en Hertz et traduit la répétition d'un motif d'un phénomène durant une seconde. Par exemple si je cligne des yeux trois fois par seconde, on peut dire que je cligne des yeux à 3 Hz.

Dans le cas des ultrasons, les compressions/décompressions sont très courtes. En effet, le motif se répète plus de 20 000 fois par seconde, donc à plus de 20 kHz. En général, en électronique on utilise un transducteur piézo pour générer cela. C'est une sorte de petit buzzer capable de vibrer très vite. Très souvent, les télémètres à ultrasons vibrent à une fréquence de 40 kHz.

Une dernière caractéristique des ondes sonores est leur capacité à être réfléchie par les obstacles. En effet, les ondes sonores ont tendance à "rebondir" sur les obstacles. On entend alors l'onde de départ et un peu plus tard la même avec un retard et une plus faible intensité. C'est exactement le même phénomène qu'un écho dans une pièce vide ou en montagne. L'onde sonore se déplace, rebondit sur les murs lisses et revient à votre oreille avec un retard entre le moment où vous avez parlé et celui où vous l'entendez (et une puissance sonore plus faible). En général, dans le domaine de l'acoustique et de la musique, on cherche à supprimer cette caractéristique en recouvrant les murs de matériaux spéciaux. Cependant, dans le cas d'une mesure de distance, on va exploiter cet effet.

Principe de la mesure

Comme dit précédemment, on va tirer parti du fait que l'onde sonore rebondit sur les obstacles et revient souvent vers l'expéditeur. On va aussi exploiter une autre chose connue, sa vitesse !

En effet, la vitesse de déplacement d'une onde sonore dans l'air est connue depuis longtemps. Elle est d'environ 340 mètres par seconde à 25 degrés Celsius (plutôt lent comparé à la lumière et ses 300 000 km/s ). À partir de là, si on sait quand l'onde est partie et quand on la reçoit de nouveau (après le rebond), on est en mesure de calculer un temps de vol de l'onde. On a alors une durée, une vitesse, et on peut en déduire une distance !

Comme l'onde fait un aller-retour (le voyage depuis l'émission de l'onde, le rebond, puis le retour sur le récepteur), il faudra diviser le temps de vol par deux pour ne considérer qu'un trajet (l'aller ou le retour). Le calcul sera alors simple. Une vitesse s'exprime par une distance divisée par un temps donc la distance sera la vitesse multipliée par le temps .

Passons un peu à la pratique pour mieux comprendre !

Un capteur à ultrasons

Le télémètre que nous allons utiliser est assez simple. Son nom est HC-SR04 et existe en différentes variations. Découvrons-le et voyons comment le faire fonctionner avec notre Arduino.

Le HC-SR04

Présentation du composant

Le HC-SR04 est ce que l'on appelle communément un "Télémètre à ultrasons". Il est trouvable relativement facilement sur de nombreux sites de fournisseurs de composants électroniques. Les sites livrant depuis la Chine proposent des prix inférieurs à 5 euros en général.

Ce composant possède plusieurs petites choses. Tout d'abord, sur la face avant on peut voir l'émetteur US et son récepteur. Ce sont des petites cellules piézo-électriques qui vont soit vibrer lorsqu'une tension est appliquée (émetteur), soit au contraire produire une tension lorsque une vibration est reçue (récepteur).

Sur la face arrière on trouve plusieurs petits circuits permettant la génération du signal et le traitement de ce dernier. Ainsi, un composant va générer une onde de 40 kHz lors d'un "top départ" et la partie restante s'occupera de la mise en forme de la réception (amplification et filtrage) et de mettre en forme cela proprement sur une broche de sortie. Parlons d'ailleurs des broches. On en trouve 4.

Les premières sont comme toujours VCC et GND qui vont accueillir l'alimentation (respectivement 5V et masse). On trouve ensuite la broche "echo" sur laquelle sera présent le signal de sortie. Enfin, une broche nommée "Trig". Cela signifie "Trigger" soit "déclencheur" ou "gâchette". En mettant cette broche à l'état haut pendant 10µs vous allez déclencher le ping pour la mesure. Un "ping" représente le lancement d'une onde ultrason. Pour reprendre l'exemple de l'écho dans la pièce vide, le ping correspondrait au moment où vous émettez un son en parlant.

Le signal de sortie est assez simple à exploiter. Il est initialement à 0, puis passe à 1 lorsque le ping est envoyé. Il repasse ensuite à 0 quand l'écho est revenu au récepteur OU s'il n'y a pas de retour durant les 30ms après l'envoi (l'onde est alors considérée perdue).

Branchement

Les branchements sont eux-même assez simples. Il suffira de relier 5V et GND à leurs broches respectives sur Arduino et mettre "Trig" et "Echo" sur des I/O numériques (8 et 9 par exemple). Pas la peine d'un schéma pour cela !

Exploitons le capteur avec Arduino

Passons maintenant à la pratique avec Arduino. Le but ici sera d'être capable de faire une mesure de distance puis de l'afficher en millimètres dans la console de la voie série.

Setup

On va comme toujours commencer par le setup. Pour une fois, pas de bibliothèque externe à rajouter, tout sera fait "à la main". Comme vu plus tôt, nous allons utiliser deux broches que je vais très justement nommer "USTrig" et "USEcho", pour le déclencheur (une sortie numérique) et le retour d'informations (une entrée numérique). Je vais ensuite préparer la voie série pour afficher les mesures.

Et c'est tout pour le setup !

Loop

Les choses faciles sont réglées, passons aux choses amusantes et faisons des mesures !

Comme je le disais dans la présentation du composant, il y a une suite d'actions à faire pour mesurer la distance. Schématiquement cela se traduirait par la liste suivante :

1. Un état haut de 10 microsecondes est mis sur la broche "Trig"

2. On remet à l'état bas la broche Trig

3. On lit la durée d'état haut sur la broche "Echo"

4. On divise cette durée par deux pour n'avoir qu'un trajet

5. On calcule la distance avec la formule d=v×t d = v \times t d = v × t

6. On affiche la distance

Toutes ces étapes sont en fait assez simples, à part peut-être la mesure de la durée. Heureusement, une fonction nommée pulseIn() est la pour ça . Cette dernière, qui est bloquante, se chargera de mesurer combien de temps une broche reste dans un état (HIGH or LOW). Elle prend en paramètre le numéro de la broche et l'état à observer.

Voici alors un exemple de programme que l'on obtient :

Si vous voulez obtenir la distance en millimètres, il suffira de multiplier par 1000. Mais soyons malins, nous pouvons aussi optimiser en évitant une opération. Pour cela c'est simple, la ligne calculant le temps en seconde passe de :

float temps = duree/1000000.0;

à

float temps = duree/1000.0;

puisque multiplier la distance par 1000 dans notre situation revient exactement à avoir un temps divisé par le même facteur (pour avoir l'information en centimètres, il aurait fallu utiliser un facteur 100 plutôt que 1000). Je vous laisse poser les maths si vous voulez me croire sur parole .

Si les mesures ne sont pas ultra-précises, essayez de modifier la constante de vitesse. Les ondes sont sensibles à la température ce qui influe sur leur vitesse. Nous verrons cela plus tard .

Tout va bien ? Les échos reviennent ? Alors place à la portabilité ! Dans cette dernière étape nous allons rajouter l'écran à notre nouvel outil.

Pour rajouter l'écran, commençons par vérifier le câblage nécessaire. L'écran nécessite 4 (ou 8 selon vos choix) fils de données (+ 2 de contrôle) et une alimentation. Cette dernière sera prise sur les broches 5V et GND de l'Arduino et les fils de données seront sur les broches 2 à 5. Les fils de contrôle EN et R/W seront sur les broches 6 et 7.

Faire fonctionner l'écran seul

En science, lorsque l'on veut tester quelque chose on l'isole du reste. Ici c'est pareil ! Nous avons pu constater que notre télémètre fonctionne bien en le faisant marcher seul, nous allons faire de même en utilisant l'écran seul. Pour cela, nous allons simplement afficher une ligne de caractères.

On commence logiquement par le setup et ce qui va avec, notamment la bibliothèque LiquidCrystal et un objet du même nom.

Une fois cela fait, on va afficher une simple ligne dans notre programme principal :

{ lcd.clear(); lcd.home(); lcd.print("-+ Eskimetre +-"); delay(10000); }

Si le message s'affiche correctement, alors tout va bien et vous pouvez continuer !

L'écran avec le télémètre

Nous y voilà ! Le moment tant attendu où nous allons afficher les mesures sur l'écran ! Pour cela, commencez par rajouter sur votre montage le télémètre (broche 8 et 9) et fusionner les setup pour n'en faire qu'un sans la voie série. Vous devriez obtenir quelque chose comme ça :

Il faut ensuite fusionner le tout pour faire un affichage sur le LCD. Je vous propose d'exploiter les deux lignes pour afficher :

En haut : la distance en millimètres (int)

En bas : le temps en millisecondes (int)

Il est pas beau ce télémètre  ? Voici ce que ça donne chez moi :

Mon télémètre

Et voici une version sur simulateur https://www.tinkercad.com/embed/3NbcDdiiH1v

!(https://www.tinkercad.com/embed/3NbcDdiiH1v)

Comme je l'ai brièvement mentionné plus tôt, la température a un impact sur la vitesse des ondes (ainsi que la pression et d'autres choses). Une amélioration de notre télémètre serait donc d'avoir une correction de la vitesse via une mesure de la température !

Pour débuter, prenons connaissance des données. Wikipédia nous dit que la vitesse de propagation du son dans l'air suit à peu près le tableau suivant :

Vitesse du son en fonction de la température

Si l'on fait un graphique avec ce tableau, on peut déduire les valeurs de la relation (vitesse en fonction de la température) qui est presque linéaire et donc peut être modélisée par une fonction affine. En faisant le calcul de la variation via les deux points les plus extrêmes du bout de droite, on obtient un coefficient de 0.6 m/s par degrés Celsius (325.4−349.2−10−30 \frac{325.4-349.2}{-10-30} − 1 0 − 3 0 3 2 5 . 4 − 3 4 9 . 2 ​ ). On observe aussi une ordonnée à l'origine (soit à 0 degré) de 331.5 mètres par seconde.
Tout cela nous donne la relation : (avec la vitesse en mètres par seconde et la température en degrés Celsius). vaudra ainsi 0.6 et vaudra 331.5.

Je ne donnerai pas le détail du montage ni le code ici cependant. Je vous le laisse en tant qu'évolution/exercice si vous le souhaitez, en rajoutant un capteur de température au montage (un LM35 par exemple). Voici cependant la logique de code qu'il faudrait suivre pour implémenter cela :

Vous avez maintenant un outil de mesure complètement fonctionnel. Il suffit de fabriquer un boîtier et de rajouter une batterie ou quelques piles pour avoir un module totalement autonome ! On pourrait aussi pousser le vice en utilisant une Arduino mini ou micro pour réduire encore un peu plus la taille du produit final !

# data[].attributes.attachment_link.title
Réaliser un télémètre à ultrasons * Tutoriels * Zeste de Savoir

# data[].attributes.attachment_link.description
Apprenons à réaliser un télémètre à ultrasons grâce à une Arduino et un petit module complémentaire

# data[].attributes.attachment_link.readable_text
Ça y est, on va pouvoir commencer à apprendre des trucs avec notre écran LCD ! Alors, au programme : afficher des variables, des tableaux, déplacer le curseur, etc. Après toutes ces explications, vous serez devenu un pro du LCD, du moins du LCD alphanumérique. Aller, en route ! Après ça vous ferez un petit TP plutôt intéressant, notamment au niveau de l'utilisation pour l'affichage des mesures sans avoir besoin d'un ordinateur. De plus, pensez au fait que vous pouvez vous aider des afficheurs pour déboguer votre programme !

Sommaire

Ecrire du texte sur le LCD

Afficher du texte

Vous vous rappelez quand je vous disais il y a longtemps "Les développeurs Arduino sont des gens sympas, ils font les choses clairement et logiquement !" ? Eh bien, ce constat se reproduit (encore) pour la bibliothèque LiquidCrystal ! En effet, une fois que votre écran LCD est bien paramétré, il nous suffira d'utiliser qu'une seule fonction pour afficher du texte ! Allez je vous laisse 10 secondes pour deviner le nom de la fonction que nous allons utiliser. Un indice, ça a un lien avec la voie série... C'est trouvé ? Félicitations à tous ceux qui auraient dit print(). En effet, une fois de plus nous retrouvons une fonction print() , comme pour l'objet Serial, pour envoyer du texte. Ainsi, pour saluer tous les zesteurs de la terre nous aurons juste à écrire :

lcd.print("Salut ca zeste ?");

et pour code complet avec les déclarations, on obtient :

Oui je sais, mais chaque chose en son temps, on s'occupera du positionnement du texte bientôt, promis !

Afficher une variable

Afficher du texte c'est bien, mais afficher du contenu dynamique c'est mieux ! Nous allons maintenant voir comment afficher une variable sur l'écran. Là encore, rien de difficile. Je ne vais donc pas faire un long discours pour vous dire qu'il n'y a qu'une seule fonction à retenir... le suspens est terrible... OUI évidemment cette fonction c'est print() !Décidément elle est vraiment tout-terrain (et rédacteur du tutoriel Arduino devient un vrai boulot de feignant, je vais finir par me copier-coller à chaque fois !) Allez zou, un petit code, une petite photo et en avant Guingamp !

Combo ! Afficher du texte ET une variable

Bon vous aurez remarqué que notre code possède une certaine faiblesse... On n'affiche au choix qu'un texte ou qu'un nombre, mais pas les deux en même temps ! Nous allons donc voir maintenant une manière d'y remédier.

La fonction solution

La solution se trouve dans les bases du langage C , grâce à une fonction qui s'appelle (aussi appelé "string printf"). Les personnes qui ont fait du C doivent la connaitre, ou connaitre sa cousine "printf". Cette fonction est un peu particulière, car elle ne prend pas un nombre d'arguments fini. En effet, si vous voulez afficher 2 variables vous ne lui donnerez pas autant d'arguments que pour en afficher 4 (ce qui parait logique d'une certaine manière). Pour utiliser cette dernière, il va falloir utiliser un tableau de char qui nous servira de . Ce tableau sera celui dans lequel nous allons écrire notre chaine de caractère. Une fois que nous aurons écrit dedans, il nous suffira de l'envoyer sur l'écran en utilisant... print() !

Son fonctionnement

Comme dit rapidement plus tôt, sprintf() n'a pas un nombre d'arguments fini. Cependant, elle en aura au minimum deux qui sont le tableau de la chaine de caractère et une chaine à écrire. Un exemple simple serait d'écrire :

Au début, le tableau message ne contient rien. Après la fonction sprintf() , il possédera le texte "J'ai 42 ans". Simple non ?

Nous allons maintenant voir comment changer mon âge en le mettant en dynamique dans la chaine grâce à une variable. Pour cela, nous allons utiliser des marqueurs de format . Le plus connu est %d pour indiquer un nombre entier (nous verrons les autres ensuite). Dans le contenu à écrire (le deuxième argument), nous placerons ces marqueurs à chaque endroit où l'on voudra mettre une variable. Nous pouvons en placer autant que nous voulons. Ensuite, il nous suffira de mettre dans le même ordre que les marqueurs les différentes variables en argument de sprintf() . Tout va être plus clair avec un exemple !

Cela affichera :

Les marqueurs

Comme je vous le disais, il existe plusieurs marqueurs. Je vais vous présenter ceux qui vous serviront le plus, et différentes astuces pour les utiliser à bon escient :

%d qui sera remplacé par un int (signé)

%s sera remplacé par une chaine (un tableau de char )

%u pour un entier non signé (similaire à %d)

%% pour afficher le symbole '%'

Malheureusement, Arduino ne les supporte pas tous. En effet, le %f des float ne fonctionne pas. Il vous faudra donc bricoler si vous désirez l'afficher en entier (je vous laisse deviner comment). Si jamais vous désirez forcer l'affichage d'un marqueur sur un certain nombre de caractères, vous pouvez utiliser un indicateur de taille de ce nombre entre le '%' et la lettre du marqueur. Par exemple, utiliser "%3d" forcera l'affichage du nombre en paramètre (quel qu'il soit) sur trois caractères au minimum . La variable ne sera pas tronquée s'il est plus grand que l'emplacement prévu. Ce paramètre prendra donc toujours autant de place au minimum sur l'écran (utile pour maitriser la disposition des caractères). Exemple :

Différents marqueurs de variable pour sprintf

À l'écran, on aura un texte tel que :

On note l'espace avant le 5 grâce au forçage de l'écriture de la variable sur 2 caractères induits par %2d .

Exercice, faire une horloge

Consigne

Afin de conclure cette partie, je vous propose un petit exercice. Comme le titre l'indique, je vous propose de réaliser une petite horloge. Bien entendu elle ne sera pas fiable du tout car nous n'avons aucun repère réel dans le temps, mais ça reste un bon exercice. L'objectif sera donc d'afficher le message suivant : "Il est hh:mm:ss" avec 'hh' pour les heures, 'mm' pour les minutes et 'ss' pour les secondes. Ça vous ira ? Ouais, enfin je ne vois pas pourquoi je pose la question puisque de toute manière vous n'avez pas le choix ! Une dernière chose avant de commencer. Si vous tentez de faire plusieurs affichages successifs, le curseur ne se replacera pas et votre écriture sera vite chaotique. Je vous donne donc rapidement une fonction qui vous permet de revenir à la position en haut à gauche de l'écran : home() . Il vous suffira de faire un lcd.home() pour replacer le curseur en haut à gauche. Nous reparlerons de la position curseur dans le chapitre suivant !

Solution

Je vais directement vous parachuter le code, sans vraiment d'explications car je pense l'avoir suffisamment commenté (et entre nous, l'exercice est sympa et pas trop dur).

Se déplacer sur l'écran

Bon, autant vous prévenir, ce morceau de chapitre ne sera pas digne du nom de "tutoriel". Malheureusement, pour se déplacer sur l'écran (que ce soit le curseur ou du texte) il n'y a pas 36 solutions, juste quelques appels relativement simples à des fonctions. Désolé d'avance pour le "pseudo-listing" de fonctions que je vais faire tout en essayant de le garder intéressant...

Gérer l'affichage

Les premières fonctions que nous allons voir concernent l'écran dans son ensemble. Nous allons apprendre à enlever le texte de l'écran mais le garder dans la mémoire pour le réafficher ensuite. En d'autres termes, vous allez pouvoir faire un mode "invisible" où le texte est bien stocké en mémoire, mais pas affiché sur l'écran. Les deux fonctions permettant ce genre d'action sont les suivantes :

noDisplay() : fait disparaître le texte

display() : fait apparaître le texte (s'il y en a évidemment)

Si vous tapez le code suivant, vous verrez le texte clignoter toutes les secondes :

Utile si vous voulez attirer l'attention de l'utilisateur ! Une autre fonction utile est celle vous permettant de nettoyer l'écran. Contrairement à la précédente, cette fonction va supprimer le texte de manière permanente. Pour le réafficher, il faudra le renvoyer à l'afficheur. Cette fonction au nom évident est : clear() (bien sûr, il faut être un peu anglophone pour s'en douter ). Le code suivant vous permettra ainsi d'afficher un texte puis, au bout de 2 secondes, il disparaitra (pas de loop(), pas nécessaire) :

Cette fonction est très utile lorsque l'on fait des menus sur l'écran, pour pouvoir changer de page. Si on ne fait pas un clear() , il risque d'ailleurs de subsister des caractères de la page précédente. Ce n'est pas très joli.

Gérer le curseur

Se déplacer sur l'écran

Voici maintenant d'autres fonctions que vous attendez certainement, celles permettant de déplacer le curseur sur l'écran. En déplaçant le curseur, vous pourrez écrire à n'importe quel endroit sur l'écran (attention cependant à ce qu'il y ait suffisamment de place pour votre texte). Nous allons commencer par quelque chose de facile que nous avons vu très rapidement dans le chapitre précédent. Je parle bien sûr de la fonction home() ! Souvenez-vous, cette fonction permet de replacer le curseur au début de l'écran.

C'est assez simple, mais il faut être vigilant quand même. Tout d'abord, sachez que les coordonnées s'expriment de la manière suivante . représente les abscisses, donc les pixels horizontaux et les ordonnées, les pixels verticaux. L'origine du repère sera logiquement le pixel le plus en haut à gauche (comme la lecture classique d'un livre, on commence en haut à gauche) et à pour coordonnées ... (0,0) ! Eh oui, on ne commence pas aux pixels (1,1) mais bien (0,0). Quand on y réfléchit, c'est assez logique. Les caractères sont rangés dans des chaines de caractères, donc des tableaux, qui eux sont adressés à partir de la case 0. Il parait donc au final logique que les développeurs aient gardé une cohérence entre les deux.

Puisque nous commençons à 0, un écran de 16x2 caractères pourra donc avoir comme coordonnées de 0 à 15 pour et 0 ou 1 pour . Ceci étant dit, nous pouvons passer à la suite. La prochaine fonction que nous allons voir prend directement en compte ce que je viens de vous dire. Cette fonction nommée setCursor() vous permet de positionner le curseur sur l'écran. On pourra donc faire setCursor(0,0) pour se placer en haut à gauche (équivalent à la fonction "home()") et en faisant setCursor(15,1) on se placera tout en bas à droite (toujours pour un écran de 16x2 caractères). Un exemple :

Animer le curseur

Tout comme nous pouvons faire disparaître le texte, nous pouvons aussi faire disparaître le curseur (comportement par défaut). La fonction noCursor() va donc l'effacer. La fonction antagoniste cursor() de son côté permettra de l'afficher (vous verrez alors un petit trait en bas du carré (5*8 pixels) où il est placé, comme lorsque vous appuyez sur la touche Insér. de votre clavier). Une dernière chose sympa à faire avec le curseur est de le faire clignoter. En anglais clignoter se dit "blink" et donc tout logiquement la fonction à appeler pour activer le clignotement est blink() . Vous verrez alors le curseur remplir le carré concerné en blanc puis s'effacer (juste le trait) et revenir. S'il y a un caractère en dessous, vous verrez alternativement un carré tout blanc puis le caractère. Pour désactiver le clignotement, il suffit de faire appel à la fonction noBlink() .

Jouer avec le texte

Nous allons maintenant nous amuser avec le texte. Ne vous attendez pas non plus à des miracles, il s'agira juste de déplacer le texte automatiquement ou non.

Déplacer le texte à la main

Pour commencer, nous allons déplacer le texte manuellement, vers la droite ou vers la gauche. N'essayez pas de produire l'expérience avec votre main, ce n'est pas un écran tactile, hein ! Le comportement est simple à comprendre. Après avoir écrit du texte sur l'écran, on peut faire appel aux fonctions scrollDisplayRight() et scrollDisplayLeft() vous pourrez déplacer le texte d'un carré vers la droite ou vers la gauche. S'il y a du texte sur chacune des lignes avant de faire appel aux fonctions, c'est le texte de chaque ligne qui sera déplacé par la fonction. Utilisez deux petits boutons poussoirs pour utiliser le code suivant. Vous pourrez déplacer le texte en appuyant sur chacun des poussoirs !

Et la démo sur simulateur :

Déplacer le texte automatiquement

De temps en temps, il peut être utile d'écrire toujours sur le même pixel et de faire en sorte que le texte se décale tout seul (pour faire des effets zolis par exemple). Un couple de fonctions va nous aider dans cette tâche. La première sert à définir la direction du défilement. Elle s'appelle leftToRight() pour aller de la gauche vers la droite et rightToLeft() pour l'autre sens. Ensuite, il suffit d'activer (ou pas si vous voulez arrêter l'effet) avec la fonction autoScroll() (et noAutoScroll() pour l'arrêter). Pour mieux voir cet effet, je vous propose d'essayer le code qui suit. Vous verrez ainsi les chiffres de 0 à 9 apparaitre et se "pousser" les uns après les autres :

Créer un caractère

Dernière partie avant la pratique, on s'accroche vous serez bientôt incollable sur les écrans LCD ! En plus, réjouissez-vous ! je vous ai gardé un petit truc sympa pour la fin. En effet, dans ce dernier morceau, toute votre âme créatrice va pouvoir s'exprimer ! Nous allons créer des caractères !

Principe de la création

Créer un caractère n'est pas très difficile, il suffit d'avoir un peu d'imagination. Sur l'écran, les pixels sont en réalité divisés en grille de 5x8 (5 en largeur et 8 en hauteur). C'est parce que le contrôleur de l'écran connait l'alphabet qu'il peut dessiner sur ces petites grilles les caractères et les chiffres. Comme je viens de le dire, les caractères sont une grille de 5x8. Cette grille sera symbolisée en mémoire par un tableau de huit octets (type byte ). Les 5 bits de poids faible de chaque octet représenteront une ligne du nouveau caractère. Pour faire simple, prenons un exemple. Nous allons dessiner un smiley, avec ses deux yeux et sa bouche pour avoir le rendu suivant :

0 0 0 0 0 X 0 0 0 X 0 0 0 0 0 0 0 0 0 0 X 0 0 0 X 0 X X X 0 0 0 0 0 0 0 0 0 0 0

Ce dessin se traduira en mémoire par un tableau d'octet que l'on pourra coder de la manière suivante :

byte smiley[8] = { B00000, B10001, B00000, B00000, B10001, B01110, B00000, B00000 };

Tableau de représentation d'un smiley

La lettre 'B' avant l'écriture des octets veut dire " Je t'écris la valeur en binaire ". Cela nous permet d'avoir un rendu plus facile et rapide.

Oh le joli smiley !

L'envoyer à l'écran et l'utiliser

Une fois que votre caractère est créé, il faut l'envoyer à l'écran, pour que ce dernier puisse le connaitre, avant toute communication avec l'écran (oui oui avant le begin() ). La fonction pour apprendre notre caractère à l'écran se nomme createChar() signifiant "créer caractère". Cette fonction prend deux paramètres : "l'adresse" du caractère dans la mémoire de l'écran (de 0 à 7) et le tableau de byte représentant le caractère. Ensuite, l'étape de départ de communication avec l'écran peut-être faite (le begin). Ensuite, si vous voulez écrire ce nouveau caractère sur votre bel écran, nous allons utiliser une nouvelle (la dernière fonction) qui s'appelle write() . En paramètre sera passé un int représentant le numéro (adresse) du caractère que l'on veut afficher. Cependant, il y a là une faille dans le code Arduino. En effet, la fonction write() existe aussi dans une librairie standard d'Arduino et prend un pointeur sur un char. Le seul moyen de les différencier pour le compilateur sera donc de regarder le paramètre de la fonction pour savoir ce que vous voulez faire. Dans notre cas, il faut passer un int . On va donc forcer (on dit "caster") le paramètre dans le type "uint8 t" en écrivant la fonction de la manière suivante : `write(uint8 t param)`. Le code complet sera ainsi le suivant :

Désormais, vous savez l'essentiel sur les LCD alphanumériques, vous êtes donc aptes pour passer au TP.

# data[].attributes.attachment_link.description
L'aspect théorique est maîtrisé ? Passons à la pratique en affichant nos premiers textes sur l'écran LCD avec les bonnes fonctions de l'Arduino.

# data[].attributes.attachment_link.readable_text
Descripción

Continuando con la publicación de proyectos olvidados en el cajón...

Os presento Paper3WireLCD. Que simplemente es una placa Stripboard, que facilita el montaje de un display LCD con Arduino utilizando únicamente 3 cables mediante la utilización de un circuito integrado.

Los autores de la idea, programa y esquema originales son: Tomek, David Cuartielles y Philip Warner.

http://arduino.cc/playground/Code/LCD3wires

Aunque posteriormente Francisco Malpartida ha actualizado la biblioteca:
https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/Home

El chip 4094 es un registro de desplazamiento que se controla por los pines 1, 2 y 3

Cada vez que detecte un flanco de subida en el pin 3 (CLK), el chip almacena en un registro de desplazamiento de 8 bits el dato presente en el pin 2 (D). Cuando está completo, al activarse el pin 1 (ST), y si además el pin 15 está a 5v, los datos del registro pasan a los pines de salida.

Tienes una explicación muy buena del funcionamiento del registro de desplazamiento en el video siguiente (aunque para otra aplicación):

No debes preocuparte, todo este proceso lo realiza automáticamente Arduino mediante la librería

(aunque el diseño original lo hice hace mucho tiempo, utilizando la librería 3WireLCD)

(schematic by Philip Warner)

Un IC HEF4094 registro de desplazamiento.

Un potenciómetro de Circuito impreso de 10K.

Tiras de pines Macho y hembra.
Un trozo de stripboard.

El circuito está realizado con Inkscape , y tienes el documento imprimible al final de esta página, en el apartado de descargas.

Una vez descargado y descomprimido el archivo, puedes imprimir el documento PaperStepperChino.pdf (sin aplicar ningún tipo de escala), para ello comprobaremos que la impresión se ha realizado a la escala correcta con la ayuda de la regla impresa situada en el lateral izquierdo de la hoja. Al colocar a su lado un regla en centímetros deberán coincidir las marcas.

En la parte inferior izquierda del documento tienes la PaperEtiqueta:

que puedes recortar y pegar sobre un trozo de stripboard de 16 filas x 9 agujeros.

Una vista del circuito por la parte inferior, te puede servir como referencia a la hora de cortar las pistas:

NOTA:
Este circuito no lo he comprobado, por lo que tal vez contenga algún error. Si descubres alguno, por favor coméntalo para que pueda corregirlo.
Si realizas es circuito, te agradecería que me enviaras imágenes que faciliten la construcción del mismo a nuevos usuarios.
Muchas gracias

Todos los derechos de propiedad intelectual del contenido de Txapuzas eléctronicas, están bajo una licencia Creative Commons Share-Alike, cuyo contenido podéis revisar en
0. Fallos y txapuzas no controladas.
Los circuitos publicados se han comprobado y funcionan correctamente. No obstante en el caso de que en una página se publiquen varios montajes diferentes de un mismo circuito (sobre un stripboard, PCB, ...), pueden existir fallos que no se han detectado en alguno de los montajes, ya que normalmente sólo realizo un montaje. En ese caso por favor notificad el fallo para que pueda corregirlo. muchas gracias.
1. Propiedad intelectual
este enlace.
Por tanto queda permitido copiar, distribuir, comunicar públicamente la obra y hacer obras derivadas de la misma, siempre que se respeten los términos de la licencia arriba reseñada.
3. Actualizaciones y modificaciones de Txapuzas electrónicas
El autor se reserva el derecho a actualizar, modificar o eliminar la información contenida en Txapuzas eléctrónicas, y la configuración o presentación del mismo, en cualquier momento, sin previo aviso, y sin asumir responsabilidad alguna por ello.
4. Indicaciones sobre aspectos técnicos
El autor no asume ninguna responsabilidad que se pueda derivar de problemas técnicos o fallos en los equipos informáticos, que se produzcan a causa de los circuitos e ideas expuestos en el blog de txapuzas electrónicas, así como de los daños que pudieran ocasionar.
El autor se exime de toda responsabilidad ante posibles daños o perjuicios que pueda sufrir el usuario a consecuencia de errores, defectos u omisiones en la información facilitada.

El esquema, circuito impreso, descripción e imágenes están disponibles en el siguiente enlace:

Si tienes problemas con el enlace anterior, aquí puedes descargar todos los archivos de txapuzas

Para la realización de este proyecto se han utilizado los programas: Si encuentras algún fallo, se te ocurre alguna mejora, o simplemente quieres hacer algún comentario, te lo agradeceré: Gracias . Notas
Arduino, Inkscape, :-) Openoffice, Gimp, Picasa, Fritzing

# data[].attributes.attachment_link.description
Descripción Continuando con la publicación de proyectos olvidados en el cajón... Os presento Paper3WireLCD. Que simplemente...

# data[].attributes.attachment_link.title
Make Your Own Arduino RFID Door Lock - Part 2

# data[].attributes.attachment_link.description
In Part 2, we will add an extra feature to our Arduino RFID Door Lock: unlocking the door using your smartphone.

# data[].attributes.attachment_link.readable_text
help i get all this errors

uild options changed, rebuilding all

In file included from /Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino:7:0:

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522Extended.h: In constructor 'MFRC522Extended::MFRC522Extended(uint8_t)':

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522Extended.h:81:44: warning: 'MFRC522::MFRC522(byte)' is deprecated (declared at /Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.h:335): use MFRC522(byte chipSelectPin, byte resetPowerDownPin) [-Wdeprecated-declarations]

MFRC522Extended(uint8_t rst) : MFRC522(rst) {};

^

/Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino: In function 'void loop()':

/Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino:91:44: warning: invalid conversion from 'byte {aka unsigned char}' to 'MFRC522::PICC_Type' [-fpermissive]

lcd.print(mfrc522.PICC_GetTypeName(piccType));

^

In file included from /Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino:6:0:

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.h:400:36: note: initializing argument 1 of 'static const __FlashStringHelper* MFRC522::PICC_GetTypeName(MFRC522::PICC_Type)'

static const __FlashStringHelper *PICC_GetTypeName(PICC_Type type);

^

/Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino:126:43: warning: invalid conversion from 'byte {aka unsigned char}' to 'MFRC522::StatusCode' [-fpermissive]

lcd.print(mfrc522.GetStatusCodeName(status));

^

In file included from /Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino:6:0:

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.h:396:36: note: initializing argument 1 of 'static const __FlashStringHelper* MFRC522::GetStatusCodeName(MFRC522::StatusCode)'

static const __FlashStringHelper *GetStatusCodeName(StatusCode code);

^

/Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino:148:43: warning: invalid conversion from 'byte {aka unsigned char}' to 'MFRC522::StatusCode' [-fpermissive]

lcd.print(mfrc522.GetStatusCodeName(status));}

^

In file included from /Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino:6:0:

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.h:396:36: note: initializing argument 1 of 'static const __FlashStringHelper* MFRC522::GetStatusCodeName(MFRC522::StatusCode)'

static const __FlashStringHelper *GetStatusCodeName(StatusCode code);

^

/Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino:168:45: warning: invalid conversion from 'byte {aka unsigned char}' to 'MFRC522::StatusCode' [-fpermissive]

lcd.println(mfrc522.GetStatusCodeName(status));

^

In file included from /Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino:6:0:

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.h:396:36: note: initializing argument 1 of 'static const __FlashStringHelper* MFRC522::GetStatusCodeName(MFRC522::StatusCode)'

static const __FlashStringHelper *GetStatusCodeName(StatusCode code);

^

/Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino:183:43: warning: invalid conversion from 'byte {aka unsigned char}' to 'MFRC522::StatusCode' [-fpermissive]

lcd.print(mfrc522.GetStatusCodeName(status));}

^

In file included from /Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino:6:0:

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.h:396:36: note: initializing argument 1 of 'static const __FlashStringHelper* MFRC522::GetStatusCodeName(MFRC522::StatusCode)'

static const __FlashStringHelper *GetStatusCodeName(StatusCode code);

^

/Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino:197:45: warning: invalid conversion from 'byte {aka unsigned char}' to 'MFRC522::StatusCode' [-fpermissive]

lcd.println(mfrc522.GetStatusCodeName(status));}

^

In file included from /Users/Henrik/Downloads/FNMUZ5RIGGTW1EG/FNMUZ5RIGGTW1EG.ino:6:0:

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.h:396:36: note: initializing argument 1 of 'static const __FlashStringHelper* MFRC522::GetStatusCodeName(MFRC522::StatusCode)'

static const __FlashStringHelper *GetStatusCodeName(StatusCode code);

^

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.cpp: In member function 'bool MFRC522::MIFARE_SetUid(byte*, byte, bool)':

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.cpp:1818:39: warning: 'bool MFRC522::MIFARE_OpenUidBackdoor(bool)' is deprecated (declared at /Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.cpp:1674): will move to extra class in next version [-Wdeprecated-declarations]

if (!MIFARE_OpenUidBackdoor(logErrors)) {

^

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.cpp: In member function 'bool MFRC522::MIFARE_UnbrickUidSector(bool)':

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.cpp:1847:34: warning: 'bool MFRC522::MIFARE_OpenUidBackdoor(bool)' is deprecated (declared at /Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.cpp:1674): will move to extra class in next version [-Wdeprecated-declarations]

MIFARE_OpenUidBackdoor(logErrors);

^

In file included from /Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522Extended.cpp:8:0:

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522Extended.h: In constructor 'MFRC522Extended::MFRC522Extended(uint8_t)':

/Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522Extended.h:81:44: warning: 'MFRC522::MFRC522(byte)' is deprecated (declared at /Users/Henrik/Documents/Arduino/libraries/MFRC522/src/MFRC522.h:335): use MFRC522(byte chipSelectPin, byte resetPowerDownPin) [-Wdeprecated-declarations]

MFRC522Extended(uint8_t rst) : MFRC522(rst) {};

^

Sketch uses 10296 bytes (31%) of program storage space. Maximum is 32256 bytes.

Global variables use 391 bytes (19%) of dynamic memory, leaving 1657 bytes for local variables. Maximum is 2048 bytes.

# data[].attributes.attachment_link.description
Arduino Rfid Read and Write on Lcd: i will show you how to make arduino rfid read and write on lcd

# data[].attributes.attachment_link.description
Beaucoup de personnes ont des plantes mais oublie régulièrement des les arroser, ou doivent partir pendant quelque jours mais n’ont personne pour v

# data[].attributes.attachment_link.readable_text
Étape 5: Bravo !

Vous avez réussi un Arduino plus " How to " tutoriel et vous apprend comment utiliser le capteur de débit d'eau.

J'espère que ça vous a plu, faites le moi savoir dans les commentaires.

Il y aura plus d'eux, alors assurez-vous de cliquez sur le bouton suivre !

Trouver plus utile Arduino tutoriels ici

# data[].attributes.attachment_link.title
Comment utiliser le capteur de débit de l'eau - Tutorial Arduino / Étape 5: Bravo ! - tubefr.com

# data[].attributes.attachment_link.description
Vous avez réussi un Arduino plus " How to " tutoriel et vous apprend comment utiliser le capteur de débit d'eau. J'espère que ça vous a plu, faites le moi savoir dans les commentaires. Il y aura plus d'eux, alors assurez-vous de cliquez sur le bouton suivre !

# data[].attributes.attachment_link.readable_text
Introduction: How to Setup DigiSprak Attiny85 Board

Hello there Engineers and Hobbyists, we all love Arduino's right! But using an Arduino UNO, NANO or any other Arduino for a small task like displaying a simple message on LCD or just Fading LED would be waste of resource and money, so in this video, we would discover a Cheap and Compact Alternative of Arduino called ATTINY85, so let's get started!

Step 1: Watch the Video

Step 2: Gathering the Requirements

Step 3: Understanding the Board

At Tiny 85 is similar to Arduino, but it is not Arduino,ATTINY 85 is a Micro-Controller chip, which has 6 General Purpose IO pins(GPIO), out of which 5 are PWM enabled, and ATTINY85 also supports the SPI and I2C Communication Protocols, but it has only 8Kb of programming memory, so yes, it is not as capable as Arduino board, but it will work just fine for small projects.

also, this board few other features like

inbuilt 8 bit timers.

inbuilt comparators.

512 Bytes EPROM

512 Bytes SRAM.

here is a complete data sheet for brief knowledge

Step 4: Edit Board URL

we need to add boards (DigiStump's Attiny85) into our Arduino IDE, to do so,

1. First open your Arduino IDE,

2. go to Preference and simply paste the Link " https://raw.githubusercontent.com/digistump/arduino-boards-index/master/package_digistump_index.json " on the Additional Board Management URL,

3. then simply Press okay and Close Preferences.

Step 5: Install DigiStump Board on IDE

to install Attiny Board Settiongs on Arduino IDE,

1. go to board manager, under Tools menu

2. select the Contributed type of boards Option

3. select "DIGISTUMP AVR BOARDS"

4. Click on install it!

Step 6: Install the Drivers

Now, install the drivers on your computer Attached on this Step

1. Unzip the Attached File.

2. click on DPinst64.exe to install the Drivers on your computer.

3. then insert the Attiny85 board into your computer .

Step 7: Troubleshooting (OPTIONAL)

sometimes your drivers are not installed correctly, in such (unusual) case, we will follow these steps

1. Open Device Manager,

2. Click on View Menu and select"Show Hidden option"

3. click on Device called "LIBUSB-win"

4. Right Click on DigiSpark USB device device and Click on Update Device

5. browse the drivers from our computer.

6. select the location of drivers stored on computer

Step 8: Write Test Code

Now, let's run a test code to check our 'Attiny85' board,

we will simply try Blink code, which you can find attached in this step.

<p>/* Blink Code by Akshay Momaya<br> * for Mission Critical Channel
 * ATTINY85 Tutorial for <Mission Critical><mission critical="">
 *  subscribe for more arduino Tuorials and Projects
<a href="https://www.youtube.com/channel/UCM6rbuieQBBLFsxszWA85AQ?sub_confirmation=1">
https://www.youtube.com/channel/UCM6rbuieQBBLFsxs...</a>
 */</mission></p><p>void setup()
 {
  pinMode(1, OUTPUT);
 }</p><p>void loop()
 {
  digitalWrite(1, HIGH);
  delay(1000);
  digitalWrite(1, LOW);
  delay(1000);
 }

</p>

Step 9: Select Proper Board Type

here, Selecting the Proper Code is the deal breaker of this entire Setup. to do so,

we will

1. select "Digispark (Deafult-16.5Mhz)" from Board Menu in Tools.

2. select programmer as "Micronucleus" from Board Menu in Tools.

Step 10: Upload the Code

normally we would compile and Upload the code with our Arduino Connected, but here in Attiny85, we will

1. Compile the code

2. Press UPLOAD button

3. wait for Plug in device now... (will timeout in 60 seconds) this message.

4. Connect the Board Within 60 Seconds .

5. wait for "Micronucleus done. Thank you!" Message From compiler.

6. Enjoy!

Ouput of this code will show blinking LED on Pin 1 on the Board

Step 11: Conclusion / Future Scope

We will do much more projects and Experiments with this board in future,

like Shrinking your Circuit Size, making StandAlone Attiny85 Projects etc.

Don't forget to subscribe to Mission Critical for such Awesome Tutorials and Projects!

# data[].attributes.attachment_link.description
How to Setup DigiSprak Attiny85 Board: Hello there Engineers and Hobbyists, we all love Arduino's right! But using an Arduino UNO, NANO or any other Arduino for a small task like displaying a simple message on LCD or just Fading LED would be waste of resource and money, so in this video,...

# data[].attributes.attachment_link.title
Tinkercad | From mind to design in minutes

# data[].attributes.attachment_link.description
Tinkercad is a free, easy-to-use app for 3D design, electronics, and coding.

# data[].attributes.attachment_link.description
Do you like cookies? 🍪 We use cookies to ensure you get the best experience on our website. Learn more

# data[].attributes.attachment_link.readable_text
Introduction: Ping Pong Ball LED Clock

This awesome LED clock is a quite simple project that nearly everyone can make. It can function as a Clock, can be LED decoration, or it can just be a nice piece of decoration when turned off.
Why I made this project/instructable
Last year I saw quite some great projects from people that used ping pong balls as diffusers for LEDs. This inspired me to make something with ping pong balls as well. After making some sketches and ordering parts I finally finished the project. Since some people were interested in a tutorial, I decided to improve the build and make a new improved version of the ping pong ball clock. With this instructable, I hope to get others excited and inspired to build their own projects.
Design choices
Since the ping pong balls are not oriented in a matrix, I had to come up with a nice way to display digits. The design I settled on uses 12 ping pong balls for each digit. After some sketching, I found that this allowed for the clearest digit representations. The length of the middle row is 20 balls (20*4 = 80cm). This size came to be because I wanted four digits next to each other, with a colon in the middle. I also wanted to have at least one row of balls between the digits to improve readability. Whilst doing this I found out that this way the total amount of balls and LEDs became to be 128.
Improvements over the first version
In the images, you can see the previous version and the new one (the pictures with 2 panels, the top one is the old version). The newer version:

- uses LED strips instead of separately soldered together Neo-Pixels.

- has pixels orientated in a way so it is easier to program.

- has less exposed contacts.

- has a back panel, so you can not see through gaps.

- allows for easier modifications and possible repair.

- looks cleaner, since wires and electronics cannot be seen from the front.

- Is way faster to make, since soldering 128*6 contacts, and stripping the same amount of wires takes some time
note:
For anyone building this: This project requires some repetitive work, I advise to first make a small test version of this project to see how the end result will look like. This allows you to see if the ping pong balls diffuse the light nicely. This could also prevent mistakes that otherwise might occur later on ( like having to much space between balls). I build a small piece of this display (picture) both times I build one of these, and I am glad I did.

Step 1: Materials / Tools:

Materials:
bought locally:
- Mdf plate (80*30 cm)

- Wood for a frame (has to be 5 cm wide and a total length of at least 200 centimeters )

- 128 ping pong balls (white ones preferably milky white)

- A few (4) small nails

- Old USB cable (one that can power the Arduino nano)

- Power cable from old electronics
bought online (China)
- 5V 10A power supply (lower Amperage might also work)

- Arduino nano (clone)

- ws2812b LED strip (5m 30Leds/meter IP30)

- DS3231 RTC

- Wire with 3 cores (2+ meter)
optional
- Female pin connectors

- Resistor (between 300 and 500 Ohm)

Tools:

- Saw that can cut 30-degree angles (miter-saw)

- Hand saw with fine teeth (metal-saw)

- Wire strippers

- Soldering iron

- 12mm drill

- 32mm hole-saw

- Wood-glue

- Hot-glue

- Flashlight

- Sandpaper
note:
Picking the right type of ping pong balls is very important for this project. Ping pong balls generally have a seam where two halves were added together. This in itself is not a problem, since by making a hole in the middle one of those halves the seam will not be visible in the display. However, when the ping pong balls also have a print on one side, it is important that the print on the balls is oriented to the back. This could result in a piece of the seam being visible from the front. When buying ping pong balls, also do not buy balls that shine (reflect light). They will diffuse the light less well and it will look strange ( an example of ping pong balls you should not buy).
summary: preferably use seamless ping pong balls without print that are white and do not reflect light.

Step 2: Making Holes in the Ping Pong Balls.

Each ping pong ball will have its own LED behind it. To get as much light as possible to shine through, a piece of the backside of the ping pong balls needs to be removed, so the light of the LED only has to go through one side of the ball. These holes need to be quite large (approximately 30mm) since the LEDs will not be centered behind the balls.

Making these large holes in the ping pong balls was a bit of a challenge. Since the balls are quite weak on their own, they need some support before holes can be made in them. I did this by drilling some 32mm holes in a piece of MDF. When sawing the balls, I provided pressure with one hand on the ping pong balls to press them against the hole. Since the hole was approximately 8mm smaller in diameter than the balls, the balls would just be pressed against the hole. Whilst providing pressure on one side, I sawed off the top of the ping pong ball on the other side, by just sawing in a straight line against the MDF.

Before sawing them, I made sure that the logo that was printed on the balls, was on the side that I was going to saw off. I also used my flashlight to find the seam where the two halves were added together. I turned the balls a bit more, so the logo was not visible from the front and as little from the seam was visible.
tip: If you have problems with the ping pong balls rotating, adding some double-sided tape inside the hole could help keep the ping pong balls in place note: It does not matter if not all holes are exactly the same size, the size can vary a few mm. This can not be seen from any direction when the build is finished.

Step 3: Gluing All Balls in Rows

After making large holes in all the ping pong balls they need to be glued together in rows (2 rows of (17,18 and 19) and one row of 20). These rows should be as straight as possible and there should be no space between the balls. I used the wood I bought to build the frame to do this. By having the balls supported by the 2 pieces of wood I was certain that they were in one line. After placing a few balls, whilst making sure the holes were facing up and the balls were touching each other, I glued them together. A very little bit of glue is enough to do this. If you use to much glue it will be visible from the front. I used a flashlight again this tone to make sure ping pong balls did not have ugly spots on the front side (some had those since it were cheap balls).

Step 4: Gluing the Rows Together.

To do this I used the wood for the frame to keep 2 rows pressed together. Keep in mind to use small drops of glue, if you use to much it will be visible from the front. After placing glue on around 8 connections at a time, I provided pressure with my hands to make sure the balls were glued tight together.

Step 5: Making the Frame

The frame exists out of 6 pieces. 2 long pieces and 4 short. All the edges of these pieces should have a 60-degree angle. Since the size of my ping pong balls wasn't exactly 40 mm, but (39,5 something), I calculated the approximate length of the frame pieces (this can be done by measuring the height or width of the panel and using a^2 + b^2 = c^2). I calculated that the inside length of the 2 long pieces should be 66.3cm, and the inside of the 4 short pieces should be 14.3cm. Since my saw was not too accurate, I made sure to cut them a bit larger, so they would not be to short.

After cutting all 6, I placed them around the ping pong ball panel, to see if it fitted well. It didn't, so I sawed a few mm of some pieces. I glued everything together around the ping pong ball panel to make sure it was glued in exactly the right shape, this was necessary since the angles were not cut perfectly in 60 degrees but were more likely 59.5 mm.

Step 6: Soldering the LED Strip

The led strip needs to be cut (one piece of 1 led, one piece of 3 LEDs, one piece of 5 LEDs and 17 pieces with 7 LEDs). The pieces of LED strip need to be wired as can be seen in the image ( first a piece of one led, then the 5 LEDs, next 17 pieces with 7 LEDs and finally the piece with 3 LEDs). The wire that connects the shorter pieces of the strip should be longer than the other pieces since it needs to cover a greater distance. I taped the strip on a piece of MDF to see if each led would be behind its own ball. After soldering all the pieces together I tested if all the solder connections were good, by activating each LED one by one (checkIfLedsAreBehindBalls.ino).

Step 7: Cutting the MDF

One the frame was done I placed the frame and the ping pong ball panel over the MDF which had the LEDs taped to it. After making sure each led was after its own ball I removed the ping pong ball panel. Next, I drew along the inside of the frame on the MDF, to get the shape I needed to cut out. I did it this way because the LEDs are not centered behind the balls and this way I have the relative position of the LEDs to the frame. After removing the LEDs that were taped to the board I cut out the shape of the panel and sanded the edges, so it fitted nicely inside the frame.
note: be aware that le LEDs will not be centered behind the ping pong balls, see sketch

Step 8: Adding Holes and LEDs to MDF

As could be seen previously, the wire connecting the LEDs is kinda in the way. The way it is right now, the wire will be visible from the front. I decided to solve this by drilling holes on the end of the location of each vertical strip of LEDs, so the wire can go on the backside. I weaved the led strip through the holes and temporarily taped it down. After making sure that again, each led would be behind its own ping pong ball I removed the tape and connected the LED strip to the board with the glue strip that is already on the LED strip.
note: When drilling holes in MDF, be really careful, you can break the board really easy.

Step 9: Gluing the Balls to the Frame

I placed the panel of ping pong balls upside down in the frame, then I applied glue on every point where the ping pong balls touched ( or barely touched the frame ).

Step 10: Attaching the LED Panel to the Frame

I placed the led panel on top of the backside of the balls. Next, I used 4 small nails to attach the panel to the frame. I did this by placing the nails on the inside of the frame. I chose to do it this way since it allows me to fix something if it ever breaks (It also allows me to double the number of LEDs, since to many lumens does not exist)

Step 11: Electronics

Okay, I have (almost) no experience with Arduino so this might not be perfect. But I tried to do this in an as simple way as possible.

I soldered connectors to the Arduino nano (black things in the image) (not necessary).

I decided to do it this way so everything can be taken apart easily again if I ever want to add Buttons or a Light Dependent Resistor (LDR) or other features to it.

Next, I connected the RTC to the Arduino, just make sure the SDA and SCl of the clock module are connected to the SDA and SCL of the Arduino Nano. Then connect the resistor between pin 9 and the data in of the LED strip.

Finally, wires were connected to the end of the LED strip to also provide power to the end of the LED strip, in order to prevent voltage drop.

Yes, it really is that simple.

To provide everything with power, I cut a USB cable that could connect to the Arduino nano in half and connected the 5V side of the two cables that went to the LED strip and the cut in half USB cable. I did the same with the Other side. This allows me to power the LED strip without supplying power through the Arduino.

A cable from an old lamp was used to connect the 5V 10A power supply with the clock.

I also drilled a hole in the bottom of one side of the frame for the power cable to go through. This allows the clock to be flat against a wall, whilst still being able to stand on a surface if preferred.

The only thing left to do is writing some code.

Step 12: Code

When uploading code, make sure the power supply is off!
Before the clock module knows the current time, the time has to be set on the module. Luckily there is some code available to do this. After only the addition of 4 lines of code and installing the DS1307RTC module, we can run this (SetTime_on_ds3231_nano.ino, link to original code / instructable about how to set the time on a DS3231RTC) code to set the time on the Arduino to the time of the PC.

With the time set, we can start looking at writing some code for this clock. I used 2 libraries in the programs, the FastLED library, and the DS3232RTC library. These two libraries will do almost all the work for you, and allow someone with very little programming experience to write programs.

Underneath here you can see The code that I used in the video on the top of this Instructable, and in most of the pictures. (timeWhiteBackgroundRainbow.ino)

<p>#include <FastLED.h><fastled.h><br>#include <DS3232RTC.h><ds3232rtc.h>
#define LED_PIN     9
#define NUM_LEDS    128
DS3232RTC myRTC(false);
tmElements_t tm;
CRGB leds[NUM_LEDS];
CHSV colour( 0, 255, 180);
int counter=0;
const int Digits[10][10] =
{
  {7,8,10,11,14,18,22,24},
  {14,16,18,22,24},
  {7,8,9,11,14,16,18,24},
  {7,9,11,14,16,18,22,24},
  {9,10,11,16,18,22,24},
  {7,9,10,11,14,16,18,22},
  {7,8,9,14,15,16,18,22},
  {7,11,14,16,17,24},
  {7,8,9,10,11,14,16,18,22,24},
  {7,9,10,11,14,16,17,24},
};
void setup()
{
    pinMode(17, OUTPUT); //ground and v5 for clock module
    pinMode(16, OUTPUT);
    digitalWrite(17, HIGH);
    digitalWrite(16, LOW);
    FastLED.addLeds<</ds3232rtc.h></fastled.h>WS2812, LED_PIN, GRB>(leds, NUM_LEDS);</p><p><fastled.h><ds3232rtc.h><ws2812, led_pin,="" grb="">    myRTC.begin();
}</ws2812,></ds3232rtc.h></fastled.h></p><p>//function that uses the Digit aray to display numbers between 0 and 100
void displaynumber( int place , int number){
  for (int i = 0 ; i < 10 ; i++) {
    if (Digits[number/10][i] != 0) {
      leds[(Digits[number/10][i]+place)] = CRGB(255,255,255);;
    }
    if (Digits[number%10][i] != 0) {
      leds[(Digits[number%10][i]+28+place)] = CRGB(255,255,255);;
    }
  }
}</p><p>void loop(){
  RTC.read(tm);

  //changes the colour of background every 10 cycles
  if (counter<10){
    counter++;
  }else{
    colour.hue = (colour.hue+1)%256;
    counter=0;
  }</p><p>  // sets background to rainbow colours
  for ( int i=0; i< 128;i++){
    colour.hue = (colour.hue+1)%256;
    leds[i]= colour;
  }
  colour.hue = (colour.hue+128)%256;

  displaynumber(0,tm.Hour);
  displaynumber(70,tm.Minute);</p><p>  //display colons
  if ( tm.Second%2 == 0 ){
    leds[64] = CRGB(255,255,255);
    leds[66] = CRGB(255,255,255);
  }
  FastLED.show();
}</p>

I think the Code is relatively short, but it can, of course, be improved. All it does is reading the time from the RTC and displaying that time. The location of the LEDs that should be lit to form a digit is hardcoded in the matrix 'Digits'. For example, Digits[0] contains the location of the LEDs that should be lit to form a zero.

I also provided the other programs I made, they are slight alterations of the program above. The program 'CycleThroughDigits.ino' just counts up to 9999 to demonstrate how all the digits look. The program 'onlyTime.ino' just displays the time in changing colors, with no background color. Finally, 'FastledExampleCode.ino' is some code provided by the FastLED library that demonstrates some simple animations.

Step 13: Add Every Feature You Want

This project can be so much more than a basic clock, you can add buttons, make it change brightness depending on the light, have it display just some colors, make it reactive to music, connect it to wifi with an ESP. It's basically an Arduino connected to a display, everything is possible

# data[].attributes.attachment_link.description
Ping Pong Ball LED Clock: This awesome LED clock is a quite simple project that nearly everyone can make. It can function as a Clock, can be LED decoration, or it can just be a nice piece of decoration when turned off. Why I made this project/instructable Last year I saw qui...

# data[].attributes.attachment_link.description
Découverte du Grove Beginner Kit de SeeedStudio

# data[].attributes.attachment_link.readable_text
Lorsque l'on veut mesurer des distances, on utilise en général une règle ou un ruban mètre. Mais comment faire pour avoir une distance numerique en temps réel ?

Une réponse : utiliser la technologie des ultrasons pour réaliser un télémètre .

Bien que peu précis à l'échelle des centimètres, ces derniers sont relativement fiables à l'échelle de la dizaine de centimètres. Les ultrasons étant des ondes sonores se propageant sous la forme d'un cône (ils sont peu directifs), ils font de très bons détecteurs d'obstacles.

Nous allons donc nous lancer dans la réalisation d'un petit télémètre à ultrasons via une Arduino et avec un affichage intégré sur un écran LCD (parce que la voie série, c'est un peu pénible pour se promener ). Voici les prérequis pour suivre ce tutoriel :

savoir se servir d'une Arduino ;

savoir utiliser un écran LCD alphanumérique avec l'Arduino.

À la fin de ce tutoriel, vous serez en mesure de :

utiliser un capteur HC-SR04 ;

comprendre et utiliser une information de type "temps de vol" ;

utiliser la fonction pulseIn() pour mesurer une durée d'état sur une broche.

Sommaire

Rappel sur les ultrasons

Faisons un peu de sciences et rappelons ce que sont des ultrasons.

Un ultrason est une onde sonore à haute fréquence. Par haute fréquence j'entends toutes les fréquences sonores inaudibles pour l'oreille humaine, soit celles au-delà de 20 kHz. Elles sont l'opposé des infrasons qui sont les ondes sonores dont la fréquence est inférieure à la plus faible audible pour l'Homme et qui est de 20 Hz.

Bon, c'est bien beau mais cette histoire de fréquence ça ne nous en dit pas beaucoup plus !

Une onde sonore c'est quoi ?

Une onde sonore est un phénomène physique de compression et décompression. Lorsqu'une vibration est produite (par n'importe quel objet qui vibre), l'air subit alors une onde de choc qui se traduit en mouvement des atomes. Il y a alors ce phénomène de compression et décompression (des "trous" dans l'air) que des récepteurs dans nos oreilles convertissent en bruit.

Plus les compressions sont proches et plus la fréquence est élevée. On parle alors de son aigu. Au contraire, plus les compressions sont éloignées et plus la fréquence est faible, on parle d'un son grave. Une fréquence s'exprime en Hertz et traduit la répétition d'un motif d'un phénomène durant une seconde. Par exemple si je cligne des yeux trois fois par seconde, on peut dire que je cligne des yeux à 3 Hz.

Dans le cas des ultrasons, les compressions/décompressions sont très courtes. En effet, le motif se répète plus de 20 000 fois par seconde, donc à plus de 20 kHz. En général, en électronique on utilise un transducteur piézo pour générer cela. C'est une sorte de petit buzzer capable de vibrer très vite. Très souvent, les télémètres à ultrasons vibrent à une fréquence de 40 kHz.

Une dernière caractéristique des ondes sonores est leur capacité à être réfléchie par les obstacles. En effet, les ondes sonores ont tendance à "rebondir" sur les obstacles. On entend alors l'onde de départ et un peu plus tard la même avec un retard et une plus faible intensité. C'est exactement le même phénomène qu'un écho dans une pièce vide ou en montagne. L'onde sonore se déplace, rebondit sur les murs lisses et revient à votre oreille avec un retard entre le moment où vous avez parlé et celui où vous l'entendez (et une puissance sonore plus faible). En général, dans le domaine de l'acoustique et de la musique, on cherche à supprimer cette caractéristique en recouvrant les murs de matériaux spéciaux. Cependant, dans le cas d'une mesure de distance, on va exploiter cet effet.

Principe de la mesure

Comme dit précédemment, on va tirer parti du fait que l'onde sonore rebondit sur les obstacles et revient souvent vers l'expéditeur. On va aussi exploiter une autre chose connue, sa vitesse !

En effet, la vitesse de déplacement d'une onde sonore dans l'air est connue depuis longtemps. Elle est d'environ 340 mètres par seconde à 25 degrés Celsius (plutôt lent comparé à la lumière et ses 300 000 km/s ). À partir de là, si on sait quand l'onde est partie et quand on la reçoit de nouveau (après le rebond), on est en mesure de calculer un temps de vol de l'onde. On a alors une durée, une vitesse, et on peut en déduire une distance !

Comme l'onde fait un aller-retour (le voyage depuis l'émission de l'onde, le rebond, puis le retour sur le récepteur), il faudra diviser le temps de vol par deux pour ne considérer qu'un trajet (l'aller ou le retour). Le calcul sera alors simple. Une vitesse s'exprime par une distance divisée par un temps donc la distance sera la vitesse multipliée par le temps .

Passons un peu à la pratique pour mieux comprendre !

Un capteur à ultrasons

Mise en œuvre du télémètre

Le télémètre que nous allons utiliser est assez simple. Son nom est HC-SR04 et existe en différentes variations. Découvrons-le et voyons comment le faire fonctionner avec notre Arduino.

Le HC-SR04

Présentation du composant

Le HC-SR04 est ce que l'on appelle communément un "Télémètre à ultrasons". Il est trouvable relativement facilement sur de nombreux sites de fournisseurs de composants électroniques. Les sites livrant depuis la Chine proposent des prix inférieurs à 5 euros en général.

Ce composant possède plusieurs petites choses. Tout d'abord, sur la face avant on peut voir l'émetteur US et son récepteur. Ce sont des petites cellules piézo-électriques qui vont soit vibrer lorsqu'une tension est appliquée (émetteur), soit au contraire produire une tension lorsque une vibration est reçue (récepteur).

Sur la face arrière on trouve plusieurs petits circuits permettant la génération du signal et le traitement de ce dernier. Ainsi, un composant va générer une onde de 40 kHz lors d'un "top départ" et la partie restante s'occupera de la mise en forme de la réception (amplification et filtrage) et de mettre en forme cela proprement sur une broche de sortie. Parlons d'ailleurs des broches. On en trouve 4.

Les premières sont comme toujours VCC et GND qui vont accueillir l'alimentation (respectivement 5V et masse). On trouve ensuite la broche "echo" sur laquelle sera présent le signal de sortie. Enfin, une broche nommée "Trig". Cela signifie "Trigger" soit "déclencheur" ou "gâchette". En mettant cette broche à l'état haut pendant 10µs vous allez déclencher le ping pour la mesure. Un "ping" représente le lancement d'une onde ultrason. Pour reprendre l'exemple de l'écho dans la pièce vide, le ping correspondrait au moment où vous émettez un son en parlant.

Le signal de sortie est assez simple à exploiter. Il est initialement à 0, puis passe à 1 lorsque le ping est envoyé. Il repasse ensuite à 0 quand l'écho est revenu au récepteur OU s'il n'y a pas de retour durant les 30ms après l'envoi (l'onde est alors considérée perdue).

Branchement

Les branchements sont eux-même assez simples. Il suffira de relier 5V et GND à leurs broches respectives sur Arduino et mettre "Trig" et "Echo" sur des I/O numériques (8 et 9 par exemple). Pas la peine d'un schéma pour cela !

Exploitons le capteur avec Arduino

Passons maintenant à la pratique avec Arduino. Le but ici sera d'être capable de faire une mesure de distance puis de l'afficher en millimètres dans la console de la voie série.

Setup

On va comme toujours commencer par le setup. Pour une fois, pas de bibliothèque externe à rajouter, tout sera fait "à la main". Comme vu plus tôt, nous allons utiliser deux broches que je vais très justement nommer "USTrig" et "USEcho", pour le déclencheur (une sortie numérique) et le retour d'informations (une entrée numérique). Je vais ensuite préparer la voie série pour afficher les mesures.

Et c'est tout pour le setup !

Loop

Les choses faciles sont réglées, passons aux choses amusantes et faisons des mesures !

Comme je le disais dans la présentation du composant, il y a une suite d'actions à faire pour mesurer la distance. Schématiquement cela se traduirait par la liste suivante :

Toutes ces étapes sont en fait assez simples, à part peut-être la mesure de la durée. Heureusement, une fonction nommée pulseIn() est la pour ça . Cette dernière, qui est bloquante , se chargera de mesurer combien de temps une broche reste dans un état (HIGH or LOW). Elle prend en paramètre le numéro de la broche et l'état à observer.

Voici alors un exemple de programme que l'on obtient :

Si vous voulez obtenir la distance en millimètres, il suffira de multiplier par 1000. Mais soyons malins, nous pouvons aussi optimiser en évitant une opération. Pour cela c'est simple, la ligne calculant le temps en seconde passe de :

à

puisque multiplier la distance par 1000 dans notre situation revient exactement à avoir un temps divisé par le même facteur (pour avoir l'information en centimètres, il aurait fallu utiliser un facteur 100 plutôt que 1000). Je vous laisse poser les maths si vous voulez me croire sur parole .

Si les mesures ne sont pas ultra-précises, essayez de modifier la constante de vitesse. Les ondes sont sensibles à la température ce qui influe sur leur vitesse. Nous verrons cela plus tard .

Ajout de l'écran et montage final

Tout va bien ? Les échos reviennent ? Alors place à la portabilité ! Dans cette dernière étape nous allons rajouter l'écran à notre nouvel outil.

Pour rajouter l'écran, commençons par vérifier le câblage nécessaire. L'écran nécessite 4 (ou 8 selon vos choix) fils de données (+ 2 de contrôle) et une alimentation. Cette dernière sera prise sur les broches 5V et GND de l'Arduino et les fils de données seront sur les broches 2 à 5. Les fils de contrôle EN et R/W seront sur les broches 6 et 7.

Faire fonctionner l'écran seul

En science, lorsque l'on veut tester quelque chose on l'isole du reste. Ici c'est pareil ! Nous avons pu constater que notre télémètre fonctionne bien en le faisant marcher seul, nous allons faire de même en utilisant l'écran seul. Pour cela, nous allons simplement afficher une ligne de caractères.

On commence logiquement par le setup et ce qui va avec, notamment la bibliothèque LiquidCrystal et un objet du même nom.

Une fois cela fait, on va afficher une simple ligne dans notre programme principal :

{ lcd.clear(); lcd.home(); lcd.print("-+ Eskimetre +-"); delay(10000); }

Si le message s'affiche correctement, alors tout va bien et vous pouvez continuer !

L'écran avec le télémètre

Nous y voilà ! Le moment tant attendu où nous allons afficher les mesures sur l'écran ! Pour cela, commencez par rajouter sur votre montage le télémètre (broche 8 et 9) et fusionner les setup pour n'en faire qu'un sans la voie série. Vous devriez obtenir quelque chose comme ça :

Il faut ensuite fusionner le tout pour faire un affichage sur le LCD. Je vous propose d'exploiter les deux lignes pour afficher :

En haut : la distance en millimètres ( int )

En bas : le temps en millisecondes ( int )

Il est pas beau ce télémètre ? Voici ce que ça donne chez moi :

Video : Mon télémètre

Et voici une version sur simulateur interactif (cliquez sur le HC-SR04 pour modifier la distance lue) :

Aller plus loin

Comme je l'ai brièvement mentionné plus tôt, la température a un impact sur la vitesse des ondes (ainsi que la pression et d'autres choses). Une amélioration de notre télémètre serait donc d'avoir une correction de la vitesse via une mesure de la température !

Pour débuter, prenons connaissance des données. Wikipédia nous dit que la vitesse de propagation du son dans l'air suit à peu près le tableau suivant :

Vitesse du son en fonction de la température

Si l'on fait un graphique avec ce tableau, on peut déduire les valeurs de la relation (vitesse en fonction de la température) qui est presque linéaire et donc peut être modélisée par une fonction affine. En faisant le calcul de la variation via les deux points les plus extrêmes du bout de droite, on obtient un coefficient de 0.6 m/s par degrés Celsius ( ). On observe aussi une ordonnée à l'origine (soit à 0 degré) de 331.5 mètres par seconde. Tout cela nous donne la relation : (avec la vitesse en mètres par seconde et la température en degrés Celsius). vaudra ainsi 0.6 et vaudra 331.5.

Je ne donnerai pas le détail du montage ni le code ici cependant. Je vous le laisse en tant qu'évolution/exercice si vous le souhaitez, en rajoutant un capteur de température au montage (un LM35 par exemple). Voici cependant la logique de code qu'il faudrait suivre pour implémenter cela :

Vous avez maintenant un outil de mesure complètement fonctionnel. Il suffit de fabriquer un boîtier et de rajouter une batterie ou quelques piles pour avoir un module totalement autonome ! On pourrait aussi pousser le vice en utilisant une Arduino mini ou micro pour réduire encore un peu plus la taille du produit final !

# data[].attributes.attachment_link.description
Apprenons à réaliser un télémètre à ultrasons grâce à une Arduino et un petit module complémentaire

# data[].attributes.attachment_link.title
Programmer un attiny85 - EP03 Projet Dé Electronique

# data[].attributes.attachment_link.title
Souder les composants - EP02 Projet Dé Electronique

# data[].attributes.attachment_link.title
Fabriquer un circuit imprimé - EP01 Projet Dé Electronique

# data[].attributes.attachment_link.description
Le site des Olympiades de Physique France a déménagé, il s'est agrandi, enrichi, et a fusionné avec le site olymphys.fr Vous serez automatiquement redirigé vers olymphys.fr dans 5 secondes Ou bien cliquer sur le bouton ci contre pour rejoindre le nouveau site des OdPF : olymphys.fr

# data[].attributes.attachment_link.title
Initiation à la spectrophotométrie avec Arduino - Activité secondaire

# data[].attributes.attachment_link.description
Initiation à la spectrophotométrie avec Arduino. Construisez un spectrophotomètre simple et apprenez les principes d'absorbance et de couleur complémentaire

# data[].attributes.attachment_link.readable_text
This library allows an Arduino board to control LiquidCrystal displays (LCDs) based on the Hitachi HD44780 (or a compatible) chipset, which is found on most text-based LCDs. The library works with in either 4- or 8-bit mode (i.e. using 4 or 8 data lines in addition to the rs, enable, and, optionally, the rw control lines).

LiquidCrystal - "Hello World!"

The LiquidCrystal library allows you to control LCD displays that are compatible with the Hitachi HD44780 driver. There are many of them out there, and you can usually tell them by the 16-pin interface.

This example sketch prints "Hello World!" to the LCD and shows the time in seconds since the Arduino was reset.

output of the sketch on a 2x16 LCD

The LCDs have a parallel interface, meaning that the microcontroller has to manipulate several interface pins at once to control the display. The interface consists of the following pins:

A register select (RS) pin that controls where in the LCD's memory you're writing data to. You can select either the data register, which holds what goes on the screen, or an instruction register, which is where the LCD's controller looks for instructions on what to do next.

A Read/Write (R/W) pin that selects reading mode or writing mode

An Enable pin that enables writing to the registers 8 data pins (D0 -D7). The states of these pins (high or low) are the bits that you're writing to a register when you write, or the values you're reading when you read.

There's also a display constrast pin (Vo),

power supply pins (+5V and Gnd) and

LED Backlight (Bklt+ and BKlt-) pins that you can use to power the LCD, control the display contrast, and turn on and off the LED backlight, respectively.

The process of controlling the display involves putting the data that form the image of what you want to display into the data registers, then putting instructions in the instruction register. The LiquidCrystal Library simplifies this for you so you don't need to know the low-level instructions.

The Hitachi-compatible LCDs can be controlled in two modes: 4-bit or 8-bit. The 4-bit mode requires seven I/O pins from the Arduino, while the 8-bit mode requires 11 pins. For displaying text on the screen, you can do most everything in 4-bit mode, so example shows how to control a 2x16 LCD in 4-bit mode.

LiquidCrystal - Text Direction (leftToRight() and rightToLeft()

The Liquid Crystal Library allows you to control LCD displays that are compatible with the Hitachi HD44780 driver. There are many of them out there, and you can usually tell them by the 16-pin interface. This example sketch shows how to use the leftToRight() and rightToLeft() methods. These methods control which way text flows from the cursor. rightToLeft() causes text to flow to the left from the cursor, as if the display is right-justified. leftToRight() causes text to flow to the right from the cursor, as if the display is left-justified. This sketch prints a through l right to left, then m through r left to right, then s through z right to left again. Hardware Required

Arduino Board LCD Screen (compatible with Hitachi HD44780 driver) pin headers to solder to the LCD display pins 10k Potentiometer breadboard hook-up wire Circuit

Before wiring the LCD screen to your Arduino we suggest to solder a pin header strip to the 14 (or 16) pin count connector of the LCD screen, as you can see in the image above. To wire your LCD screen to your Arduino, connect the following pins: LCD RS pin to digital pin 12 LCD Enable pin to digital pin 11 LCD D4 pin to digital pin 5 LCD D5 pin to digital pin 4 LCD D6 pin to digital pin 3 LCD D7 pin to digital pin 2 Additionally, wire a 10K pot to +5V and GND, with it's wiper (output) to LCD screens VO pin (pin3). click the images to enlarge

image developed using Fritzing. For more circuit examples, see the Fritzing project page

Code

// include the library code: #include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

int thisChar - 'a';

void setup() {

// set up the LCD's number of columns and rows: lcd.begin(16, 2); // turn on the cursor: lcd.cursor();

}

void loop() {

// reverse directions at 'm': if (thisChar - 'm') {

// go right for the next letter lcd.rightToLeft();

} // reverse again at 's': if (thisChar - 's') {

// go left for the next letter lcd.leftToRight();

} // reset at 'z': if (thisChar > 'z') {

// go to (0,0): lcd.home(); // start again at 0 thisChar - 'a';

} // print the character lcd.write(thisChar); // wait a second: delay(1000); // increment the letter: thisChar++;

} [Get Code] See Also:

lcd.begin() lcd.print() lcd.rightToLeft() lcd.leftToRight() lcd.home() Liquid Crystal Library Blink: control of the block-style cursor. Cursor: control of the underscore-style cursor. Display: quickly blank the display without losing what's on it. Scroll: scroll text left and right. Serial input: accepts serial input, displays it. SetCursor: set the cursor position. Autoscroll: shift text right and left.

LiquidCrystal - Serial Input

The Liquid Crystal Library allows you to control LCD displays that are compatible with the Hitachi HD44780 driver. There are many of them out there, and you can usually tell them by the 16-pin interface. This example sketch accepts serial input from a host computer and displays it on the LCD. To use it, upload the sketch, then open the Serial Monitor and type some characters and click Send. The text will appear on your LCD. Hardware Required

LiquidCrystal - setCursor()

The Liquid Crystal Library allows you to control LCD displays that are compatible with the Hitachi HD44780 driver. There are many of them out there, and you can usually tell them by the 16-pin interface. This example sketch shows how to use the setCursor() method to reposition the cursor. To move the cursor, just call setCursor() with a row and column position. For example, for a 2x16 display: lcd.setCursor(0, 0); // top left lcd.setCursor(15, 0); // top right lcd.setCursor(0, 1); // bottom left lcd.setCursor(15, 1); // bottom right

Hardware Required

Arduino Board LCD Screen (compatible with Hitachi HD44780 driver) pin headers to solder to the LCD display pins 10k Potentiometer breadboard hook-up wire Circuit

Before wiring the LCD screen to your Arduino we suggest to solder a pin header strip to the 14 (or 16) pin count connector of the LCD screen, as you can see in the image above. To wire your LCD screen to your Arduino, connect the following pins: LCD RS pin to digital pin 12 LCD Enable pin to digital pin 11 LCD D4 pin to digital pin 5 LCD D5 pin to digital pin 4 LCD D6 pin to digital pin 3 LCD D7 pin to digital pin 2 Additionally, wire a 10K pot to +5V and GND, with it's wiper (output) to LCD screens VO pin (pin3). click the images to enlarge

image developed using Fritzing. For more circuit examples, see the Fritzing project page

Code

/*

LiquidCrystal Library - setCursor

Demonstrates the use a 16x2 LCD display. The LiquidCrystal library works with all LCD displays that are compatible with the Hitachi HD44780 driver. There are many of them out there, and you can usually tell them by the 16-pin interface.

This sketch prints to all the positions of the LCD using the setCursor(0 method:

LCD RS pin to digital pin 12

LCD Enable pin to digital pin 11

LCD D4 pin to digital pin 5

LCD D5 pin to digital pin 4

LCD D6 pin to digital pin 3

LCD D7 pin to digital pin 2

LCD R/W pin to ground

10K resistor:

ends to +5V and ground

wiper to LCD VO pin (pin 3)

Library originally added 18 Apr 2008 by David A. Mellis library modified 5 Jul 2009 by Limor Fried ( http://www.ladyada.net) example added 9 Jul 2009 by Tom Igoe modified 22 Nov 2010 by Tom Igoe

This example code is in the public domain.
http://arduino.cc/en/Tutorial/LiquidCrystalSetCursor

// include the library code: #include <LiquidCrystal.h>

// these constants won't change. But you can change the size of // your LCD using them: const int numRows - 2; const int numCols - 16;

// initialize the library with the numbers of the interface pins LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {

// set up the LCD's number of columns and rows: lcd.begin(numCols,numRows);

}

void loop() {

// loop from ASCII 'a' to ASCII 'z': for (int thisLetter - 'a'; thisLetter <- 'z'; thisLetter++) {

// loop over the columns: for (int thisCol - 0; thisCol < numRows; thisCol++) {

// loop over the rows: for (int thisRow - 0; thisRow < numCols; thisRow++) {

// set the cursor position: lcd.setCursor(thisRow,thisCol); // print the letter: lcd.write(thisLetter); delay(200);

}

}

}

} [Get Code] See Also:

lcd.begin() lcd.print() lcd.setCursor() for() Liquid Crystal Library Blink: control of the block-style cursor. Cursor: control of the underscore-style cursor. Display: quickly blank the display without losing what's on it. TextDirection: control which way text flows from the cursor. Scroll: scroll text left and right. Serial input: accepts serial input, displays it. Autoscroll: shift text right and left.

# data[].attributes.attachment_link.title
LiquidCrystal Library - liquidcrystal 0.0.0 documentation

# data[].attributes.attachment_link.description
This library allows an Arduino board to control LiquidCrystal displays (LCDs) based on the Hitachi HD44780 (or a compatible) chipset, which is found on most text-based LCDs. The library works with in either 4- or 8-bit mode (i.e. using 4 or 8 data lines in addition to the rs, enable, and, optionally, the rw control lines).

# data[].attributes.attachment_link.description
If you're here, it's because you want to learn how to build and make stuff with electronics! These guides will help you get started with the wonderful world of Arduino.

# data[].attributes.attachment_link.title
Arduino Lesson 12. LCD Displays - Part 2

# data[].attributes.attachment_link.description
This is Lesson 11 in the Learn Arduino Adafruit series. In this lesson, you will build on what we have learned in lesson 11 and use an LCD display to show the temperature and light intensity.

# data[].attributes.attachment_link.readable_text
Welcome to my collection of Arduino projects. As a maker, techie and mechatronics engineer I've been using Arduino for more then 8 years. Arduino is an incredibly versatile microcontroller with limitless possibilities for developing electronics applications and prototypes.

We can use Arduino for simple tasks such as controlling LEDs and DC motors, to controlling real CNC machines and robots. That's right, in the following list I will share my Arduino experience with you. You will find Arduino projects for beginners and more advanced projects for Arduino enthusiast.

Even if you are just getting started with Arduino, you don't have to worry about that. Each of the following DIY Arduino projects is covered with detailed step by step tutorial on how to do it yourself and includes circuit schematics, source codes and videos.

Using the comments section below, you can also suggest your ideas, as well as discuss anything related to these Arduino projects. I will continuously update this article with all new stuff that I make. Last update: February 2022.

Robotic Arduino Projects

As an Arduino enthusiast, I found making robots with Arduino to be most fun for me. There is so much to learn from them as a maker and an engineer. So, here are my Arduino projects related to robotics so you can learn too.

Arduino Robot Arm

When it comes to automated manufacturing, robot arms play big role with so many applications. They are often used for welding, assembling, packing, painting, pick and place tasks and much more. This Arduino project is actually a robotic arm made out of 3D printed parts, servo motors joints and controlled using an Arduino Nano. What's even cooler we can control the robot arm wirelessly via a smartphone and a custom build Android application.

The robot arm has 5 degrees of freedom, so we need 5 servo motors, plus an additional servo for the gripper mechanism. For the communication with the smartphone we use the HC-05 Bluetooth module.

Difficulty: Intermediate

Link: DIY Arduino Robot Arm with Smartphone Control

Mecanum Wheels Robot

The following project is one of the coolest Arduino project in this list. It's an Arduino robot car which instead of normal wheels, it employs omnidirectional wheels or mecanum wheels which enable to robot to move in any direction.

The wheels are attached on four stepper motors which are individually control. By rotating the wheels in certain pattern, they exert diagonal forces due the diagonally positioned rollers on the circumference of the wheels, and so they can move in any direction. The robot car can be remotely controlled either vie Bluetooth communication and an custom build Android application. Also, we can control it using an DIY RC transmitter with the help of the NRF24L01 transceiver module.

Difficulty: Advanced

Link: Arduino Mecanum Wheels Robot

Arduino Robot Arm and Mecanum Wheels Platform Automatic Operation

Here's an upgraded version of the previous mecanum wheels robot project. On top of the platform I added the DIY Arduino Robot Arm project mentioned above and now they can work together.

As the robot uses stepper motors for the wheels and servo motors for the robot arm, we can precisely control them using the custom build Android application. What's even cooler, we can record the movements of the robot and then the robot can automatically repeat them.

Of course, as for any of my Arduino projects, the Arduino code, the custom build Android application, as well as the 3D model files can be found and downloaded from the particular project article.

Difficulty: Advanced

Link: Arduino Robot Arm and Mecanum Wheels Platform Automatic Operation

See also: What are the Best Arduino Starter Kits in 2022?

SCARA Robot - 3D Printed

SCARA robot or Selective Compliance Articulated Robot Arm is the most common and suitable option, when it comes to pick and place and small assembly applications, which require moving a part from point A to point B.

This Arduino based SCARA robot is a step-up big compared to the previous projects in every aspect. It has a better and more robust design with precisely controlled stepper motors and custom build GUI for controlling it.

As a controller it has an Arduino UNO board, combined with a CNC shield and four A4988 stepper drivers. It has 4 DOF, driven by four NEMA 17 stepper motors.

Difficulty: Advanced

Link: SCARA Robot | How To Build Your Own Arduino Based Robot

Laser Engraving Robot

This and extension of the previous project or I converted my 3D Printed SCARA robot to work as a laser engraver robot. Instead of the gripper mechanism, here we are using a Laser module for engraving.

For controlling the robot we are using an Arduino Mega board in combination with a RAMPs board. This a popular combination used for 3D printing and it can be used for laser engraving machines as well. As for a firmware, we are using the Marlin 3D Printer firmware and the Repetier control software.

Difficulty: Advanced

Link: Laser Engraving with DIY Arduino SCARA Robot

DIY Mars Perseverance Rover Replica

Inspired by the NASA Mars 2020 mission and the successful landing of the Mars Perseverance Rover on the plant Mars, I build a 3D printed functional replica of it. I designed this DIY 3D Printed Mars Rover in a way that it can be easily recreated by following the instructions in the tutorial.

The rover features a rocker-bogie suspension which allows the rover to run smoothly on uneven terrain, just like the real rover. It has six independently controlled DC motors for driving and four servos for steering, and it's controlled using an Arduino MEGA board. There's also an FPV camera located in the cameras unit of the rover which can by used for controlling the rover remotely. The remote control is done with the help of a cheap commercial RC transmitter and receiver.

Difficulty: Advanced

Link: DIY Mars Perseverance Rover Replica - Arduino based Project

Arduino Hexapod Robot

Making biologically inspired robots is very popular among engineering students. This Arduino project is all about it, we will build a hexapod robot which features six legs, a tail or abdomen, a head, antennas, mandibles and even functional eyes. All of this makes the robot look like an ant.

Each leg have three joints, and for each joint we need a servo motor. That means that we need total of 18 servos for this project, and additionally 3 servos for the head movements and 1 servo for the tail. The brain of the robot is an Arduino Mega. We need MEGA because it's the only board that can control more than 12 servos using the Servo library.

I also designed a custom PCB which acts as an Arduino Mega Shield so we can easily attach all servo connects. We can control the ant robot via Bluetooth and a smartphone, or radio communication. The ant also has built-in ultrasonic sensor in the head. With that it can detect objects in front, and it can even strike if the object is present if front of it.

Difficulty: Advanced

Link: Arduino Ant Hexapod Robot

CNC Machines Arduino Projects

The following projects show how capable Arduino is. A CNC or Computer Numerical Control is an automated control of machines, like mills, lathes, plasma cutters, 3D printers and etc. So, using the Arduino as a controller we are actually able to build any of these CNC machines.

DIY Laser Engraving CNC Machine

For the project my goal was to build the simplest CNC machine with minimum parts possible and by using just a single power tool. On top of that, I wanted to use common materials or avoid 3D printers so I used MDF board for building the base frame.

The CNC machine is composed of just two linear rails which are secured to a base frame made of 8mm MDF board. For controlling it we are using an Arduino UNO board in combination with a CNC shield and two DRV8825 stepper drivers. As a tool it has an laser module attached so this machine is actually a CNC laser engraver.

Difficulty: Intermediate

Link: Simplest CNC Machine with Minimum Parts Possible - DIY Laser Engraver

DIY Pen Plotter with Automatic Tool Changer

A CNC drawing machine or a pen plotter based with automatic tool changer. An awesome way to draw anything in any color.

The idea for this Arduino project was similar to the previous one, to build a CNC machine using minimum parts possible. Here I used 3D several printed parts, and just two MGN15H linear rails for the main construction of the machine.

Difficulty: Intermediate

Link: DIY Pen Plotter with Automatic Tool Changer | CNC Drawing Machine

Arduino CNC Foam Cutting Machine

Building your own CNC machine might seem like a big challenge for many of you, but the following Arduino CNC Machine project shows that building a CNC machine is actually not that hard.

This CNC machine is actually a foam cutting machine. Instead of bits or lasers, the main tool of this CNC machine is a hot wire. It's a special type of resistance wire, which gets really hot when current passes through it.

The hot wire melts the foam when passing through, and so we can precisely make any shape out the styrofoam.

Difficulty: Advanced

Link: Arduino CNC Foam Cutting Machine

Arduino Wire Bending Machine

Controlling stepper motors using Arduino is without a doubt one of most satisfying thing for an Arduino enthusiast. There so many machines based on this motors, like CNC machines, 3D printers, various automation machines etc. This Arduino project is all about that. It describes how you can build such a machine. It's a machine for bending wire, where with the help of stepper motors we can precisely bend wire and make various shapes and forms out of it.

The machine features three stepper motors. With the first stepper we feed the wire to the bending mechanism. Here we have another stepper motor used for the bending the wire at the right angle. There's also another stepper, for controlling the Z-axis. This stepper enables the machine to create three dimensional shapes. With this project we can also see how useful 3D printers are for Arduino projects of this type or for prototyping.

Difficulty: Advanced

Link: Arduino 3D Wire Bending Machine

Radio Control (RC) Arduino Projects

Controlling Arduino projects using radio devices is quite useful and fun at the same time. I have made several radio based projects.

DIY Arduino based RC Transmitter

Many Arduino projects that I make require wireless control and that's why I build this Arduino based wireless radio controller. With this RC transmitter I can wirelessly control pretty much with a range up to 700m in open space. It features 14 channels, 6 of which are analog and 8 digital inputs.

The brain of this Arduino project is an Arduino Pro Mini board which is the smallest Arduino board. The radio communication is based on the NRF24L01 module, it has 2 joysticks, 2 potentiometers and 4 momentary push buttons. Also an accelerometer and gyro module which can be used for controlling things with just moving around or tilting the controller. I mounted all electronic components on a custom design PCB and made a cover out of transparent acrylic.

Difficulty: Intermediate

Link: DIY Arduino RC Transmitter

DIY Arduino RC Receiver for RC Models and Arduino Projects

This is a follow up project of the above one. Just like DIY RC Transmitter, this DIY Arduino RC Receiver can be used for many application. We can easily pair the two projects together and control anything wirelessly. Among others, I made an example of controlling a commercial RC car model using these DIY transmitter and receiver.

The custom PCB that I made uses the same NRF24L01 module for the radio communication. The controller is an Arduino Pro Mini and it features input/ output 9 channels.

Difficulty: Intermediate

Link: DIY Arduino RC Receiver for RC Models and Arduino Projects

DIY Arduino based RC Hovercraft

The following Arduino project is a great example of utilizing the DIY RC transmitter from above. It's a 3D printed hovercraft which I entirely designed on my own, and of course, the 3D printing files are available for downloading. The hovercraft uses two brushless motors, one for creating an air cushion for the lift, and the other for generating thrust or moving forward.

For the wireless control we are using the NRF24L01 module, which accepts the data coming from the RC transmitter. Then using the Arduino and two ESCs (Electronic Speed Controler) we control the BLDC motors speed. On the back side of the hovercraft there is also a servo for controlling the rudders, or for controlling the steering. I must say that driving this DIY hovercraft is so fun.

Difficulty: Advanced

Link: DIY Arduino based RC Hovercraft

Arduino RC Airplane

Anyone who had a chance of playing around with some RC airplanes knows how cool and fun it is. It's even cooler and more satisfying if you build the RC airplane on your own. The following project steps the satisfaction up even further, because here I will show you how to build your own RC airplane which is 100% DIY build. Also, we have a 100% DIY radio control system based on the Arduino.

The airplane is entirely made out of Styrofoam and what's cooler, the shapes are made with the help of my DIY Arduino CNC Foam Cutting Machine, a project already mention above. The radio communication is based on the NRF24L01 transceiver modules. For that purpose, I used my DIY Arduino RC Transmitter and DIY Arduino RC Receiver.

Difficulty: Advanced

Link: Arduino RC Airplane | 100% DIY

Arduino Robot Car Wireless Control

This Arduino project is an extension to the previous one, and here we will learn how to wirelessly control the Arduino robot car.

You can choose one of the three different methods of wireless control explained in this project, or that's the HC-05 Blueooth module, the NRF24L01 transceiver module and the HC-12 long range wireless module. Additionally you can learn how to make your own Android app for controlling the Arduino robot car.

Difficulty: Intermediate

Link: Arduino Robot Car Wireless Control using HC-05 Bluetooth, NRF24L01 and HC-12 Transceiver Modules

Arduino Wireless Weather Station

This Arduino project idea is rather practical because it features indoor and outdoor temperature and humidity measurement. It is based on the DHT11/ DHT22 sensor, the NRF24L01 transceiver module for the wireless communication and the DS3231 RTC. For the display we can either use 16×2 character LCD or a 3.2 inches TFT touch screen.

The outdoor unit can be powered with batteries and the indoor unit with an AC adapter. The outdoor unit measures the temperature and the humidity and sends the values to the main indoor unit. Here these values are printed on the LCD along with the data and time values from the DS3231 RTC module.

Additionally, we can use SD Card module for storing the data onto Micro SD card.

Difficulty: Intermediate

Link: Arduino Wireless Weather Station Project

Motors Control Arduino Projects

Controlling motors using Arduino is actually quite easy, and there are some many interesting projects with can make with Arduino and motors.

Arduino Camera Slider with Pan and Tilt Mechanism

Camera slider are great for capturing cinematic shots, and having pan and tilt system on top of it even further increase the possibility to capture better shots. In this project I will show you how you can build your own one, which costs way less then one found in the stores and still you can get great and super-smooth shots.

The slider has three NEMA 17 stepper motors controlled via the A4988 stepper drivers and the Arduino Nano board. Using a joystick we can control the pan and tilt movements and using a potentiometer we can control the sliding movement. With this DIY camera slider we can use the Set button to set two different IN and OUT points. Then the camera can automatically move from one to the other point.

Difficulty: Advanced

Link: DIY Camera Slider with Pan and Tilt Head - Arduino Based Project

DIY Vending Machine

If you are interested in building something more complex with Arduino then this project is the one for you. Although complex, you could easily recreate it as there is a detailed step by step explanation on how everything works, including circuit schematics and source codes.

The structure of the machine is made out of MDF. For discharging the items I used continuous rotation servo motors, while for the carrier system I used two NEMA17 stepper motors. For detecting the coins the machine uses an infrared proximity sensor.

Difficulty: Advanced

Link: DIY Vending Machine - Arduino based Mechatronics Project

DIY Arduino Gimbal / Self-Stabilizing Platform

The following Arduino project is a simple gimbal or a self-stabilizing platform. It can be used for keeping objects or the top platform level. The project is rather simple with just several electronic components.

Based on the MPU6050 orientation and its fused accelerometer and gyroscope data, we can control the 3 axes or servos that keep the platform level.

Difficulty: Intermediate

Link: DIY Arduino Gimbal | Self-Stabilizing Platform

Arduino Robot Car

The combination of DC motors and Arduino is always fun, and so is this project. Here we will build our own robot car from scratch. The car will be powered with Li-ion batteries and two 12V DC motors, and controlled using the L298N driver and an analog Joystick.

Through this project we will also learn how H-Bridge and PWM motor control work.

Difficulty: Intermediate

Link: L298N Motor Driver - Arduino Interface, How It Works, Codes, Schematics

Arduino Projects for Beginners

If you found the above projects a bit hard to start with, you can try the following projects which are good for beginners.

Arduino Radar (Sonar)

This is one of my most popular project and it's really fun to build. The radar can detect objects in front of it and map them on PC screen using the Processing IDE.

For this project you just need two components along with an Arduino board, and that's an ultrasonic sensor and small servo motor. The range of the radar can be adjusted to up to 4 meters with 180 degrees rotation.

Difficulty: Easy

Link: Arduino Radar Project

Range Measurer and Digital Spirit Level

Here's another project utilizing the HC-SR04 ultrasonic sensor. This time we will use it to make an distance meter which can measure distances up to 4 meters, as well as, measure square area.

The project also includes and accelerometer which is used for the digital spirit level function or for measuring angle. The results are displayed on 16×2 LCD and all components are attached on a custom design PCB.

Difficulty: Intermediate

Link: Arduino Range Measurer and Digital Spirit Level Project

Arduino Color Sorter

Sorting out objects or products by their color has an important real world application. These types of machines are often used for sorting fruits, seeds, plastics etc. The working concept of these machines is rather simple. All you need is a color detecting sensor and of course a system that feeds the object to the sensor and then sort it out.

In this project we will learn how to use a color detecting sensor along with the Arduino. We are going to be sorting out colored skittles but you can use the same sensor and method for sorting out anything else.

Difficulty: Intermediate

Link: Arduino Color Sorter Project

RFID Access Control System

RFID technology has wide range of applications and access control is one of them. We often encounter this in hotels for accessing our room or at work for checking in or accessing restricted areas.

In this project we will learn how to use the Arduino to make an RFID controlled door lock. The system consists of an MFRC522 RFID reader and RFID tags/ cards that are based on the MIFARE protocol.

Difficulty: Intermediate

Link: How RFID Works and How To Make an Arduino based RFID Door Lock

Arduino Alarm System

If you ever thought of making your own security system then this project is a great starting point. Here we will utilize an ultrasonic sensor for detecting movement.

If a human or object passes in front of the sensor, the alarm will be activated. For deactivating the alarm you will have to enter a password using a keypad.

Difficulty: Intermediate

Link: Arduino Security and Alarm System Project

Arduino LED Matrix Scrolling Text

In this project we will control LED Matrices using the MAX7219 driver. This driver can control up to 64 individual LEDs while using only three wires. Also we can connect up to 8 drivers in series and still using the same wires.

To make this project more interesting I also added an example where you can update the text on the LED matrixes through your smartphone using a custom-made Android app.

Difficulty: Intermediate

Link: 8×8 LED Matrix MAX7219 Tutorial with Scrolling Text & Android Control via Bluetooth

Arduino Game Project

This game project is based on the popular Flappy Bird game for smartphones. Using the touch screen we control the bird while trying to avoid the pillars.

For this project we need a 3.2 inches TFT Touch screen, an TFT Mega shield adapter and an Arduino Mega board. The code is a bit longer but everything is explained in details.

Difficulty: Advanced

Link: Arduino Game Project - Replica of Flappy Bird for Arduino

Arduino Music Player and Alarm Clock with Touch Screen

In this project we will learn how to build our own music player. It features a touch screen, MP3 player, a temperature sensor and an alarm clock.

The code behind this project is a bit more complex with around 550 lines but everything is explained in details with comments for each lines. There is also a detailed video explanation for it.

Difficulty: Advanced

Link: Arduino Touch Screen Music Player and Alarm Clock Project

More Arduino Projects

Arduino Based Interactive LED Coffee Table

At first glance this table looks like a normal coffee table but once you turn on the power on it gets to a whole new level. The table has 45 sections which can glow in any color we want, plus it reacts on objects placed on top of it.

The heart of the table is an Arduino which controls the 45 WS2812B Addressable LEDs. The objects on top of the table are detected using infrared proximity sensors. What's even cooler it has built-in Bluetooth module which enables interaction with a smartphone for selecting the LEDs colors.

Difficulty: Advanced

Link: Arduino Based Interactive LED Coffee Table

DIY Air Quality Monitor

Monitoring the indoor air quality is very important as it can affect us in many way. If we have a poor air quality in the room we are staying, it can lead to tiredness, headaches, loss of concentration, increased heart rate and so on.

In this Arduino project we are building an Air Quality Monitor which can measure several important air quality parameters such as PM2.5, CO2, VOC, Ozone, as well as temperature and humidity. I designed a custom PCB on which we can easily attach the sensors we need and show the results on a 2.8 inches touch display. The device can also keep track of the sensors values from the last 24 hours.

Difficulty: Advanced

Link: DIY Air Quality Monitor - PM2.5, CO2, VOC, Ozone, Temp & Hum Arduino Meter

Arduino Projects Ideas

The following section of this article contains Arduino projects ideas based on my detailed tutorials on various sensors and modules, as well as your suggestions from the comments section below.

For each project idea I will point out the required components as well as the particular tutorial for each of them.

6-Axis Arduino Robot Arm with Cycloidal or Harmonic Drives as Joints

Building more robust Arduino based Robot arm which will employ either Cycloidal or Harmonic drives as joints.

Using my detailed tutorials how a cycloidal and a harmonic gearboxes work we can develop robotic joints which will have high torque and efficiency.

Cycloidal Drive working principle:

Harmonic Drive working principle:

We can use NEMA 17 or 23 stepper motors in combination with these drivers which provide high speed reduction ratios. As for controller we could use an Arduino Uno or Arduino MEGA board.

Difficulty: Advanced

Android Smartphone Controlled Power Outlet Using Arduino

Controlling your home power outlets via a smartphone is the first step in home automation. You can easily make your own Arduino controlled power outlets utilizing the knowledge you can get from my Arduino tutorials.

For this project you just need two components along with the Arduino board. An HC-05 Bluetooth module and a 5V Relay module for which I already have detailed tutorials. For powering the Arduino and the relay you can use 220/ 110V AC to 5V DC converter.

Using your smartphone you can connect and control your power outlet via Bluetooth. You can either use some already made apps for controlling Arduino from the Play Store or create your own custom made app. In this way we can also control the power outlets through voice control commands.

Difficulty: Advanced

Home Automation Arduino Projects

Home automation is one of the most popular Arduino projects nowadays. The goal of this project is to remotely control anything in your house like lights, appliances, temperature, security devices and so on, with a single device or your smartphone.

In order to make such a project we need decent amount of knowledge in Arduino. The following home automation concept that I suggest is based on my detailed Arduino tutorials for various sensors and modules.

So the idea here is to have a master unit which includes a touch display, and several slave units which will execute commands coming from the master. As for the wireless communication we can use the NRF24L01 radio frequency modules. Each slave unit can have various functions like, temperature monitoring, power outlet control, lights control, security alarm and so on.

Of course, there are endless possibilities and combinations for building a home automation system using the Arduino board. You can always change and add more devices. You can also make a Bluetooth communication so you can control all of this using your smartphone etc.

Difficulty: Advanced

Arduino Gesture Control

The idea for this project is to remotely control an Arduino project using hand gestures. Let's say we want to control the Arduino Robot Car that we mentioned above. So instead of the joystick we will use an MEMS module for the control.

We can use the GY-80 module which features an accelerometer, a gyroscope and a magnetometer. Then the data we are getting from these sensors to control the steering of the robot car. As for the wireless communication we can use the NRF24L01 transceiver modules.

You can also check my Mechatronics Final Year Project where I used a similar method for controlling a 3D model in Matab Simulink.

Difficulty: Advanced

Feel free to ask any question in the comments section below and don't forget to suggest some more Arduino projects.

# data[].attributes.attachment_link.title
The Best Arduino Projects - Robots, Sensors, RC, CNC and more

# data[].attributes.attachment_link.description
Arduino Projects with detailed step by step instructions including circuit diagrams, codes and 3D models. Robots, CNC Machines, RC and more.

# data[].attributes.attachment_link.readable_text
In this Arduino tutorial we will learn how to connect and use an LCD (Liquid Crystal Display) with Arduino. LCD displays like these are very popular and broadly used in many electronics projects because they are great for displaying simple information, like sensors data, while being very affordable.

I've already used them in several of my Arduino projects, and you can check them out here:

You can watch the following video or read the written tutorial below. It includes everything you need to know about using an LCD character display with Arduino, such as, LCD pinout, wiring diagram and several example codes.

What is LCD Character Display?

An LCD character display is a unique type of display that can only output individual ASCII characters with fixed size. Using these individual characters then we can form a text.

If we take a closer look at the display we can notice that there are small rectangular areas composed of 5×8 pixels grid. Each pixel can light up individually, and so we can generate characters within each grid.

The number of the rectangular areas define the size of the LCD. The most popular LCD is the 16×2 LCD, which has two rows with 16 rectangular areas or characters. Of course, there are other sizes like 16×1, 16×4, 20×4 and so on, but they all work on the same principle. Also, these LCDs can have different background and text color.

16×2 LCD Pinout

It has 16 pins and the first one from left to right is the pin. The second pin is the which we connect the 5 volts pin on the Arduino Board. Next is the Vo pin on which we can attach a potentiometer for controlling the contrast of the display.

Next, The RS pin or register select pin is used for selecting whether we will send commands or data to the LCD. For example if the RS pin is set on low state or zero volts, then we are sending commands to the LCD like: set the cursor to a specific location, clear the display, turn off the display and so on. And when RS pin is set on High state or 5 volts we are sending data or characters to the LCD.

Next comes the R/W pin which selects the mode whether we will read or write to the LCD. Here the write mode is obvious and it is used for writing or sending commands and data to the LCD. The read mode is used by the LCD itself when executing the program which we don't have a need to discuss about it in this tutorial.

Next is the pin which enables the writing to the registers, or the next 8 data pins from D0 to D7. So through this pins we are sending the 8 bits data when we are writing to the registers or for example if we want to see the latter uppercase A on the display we will send 0100 0001 to the registers according to the ASCII table. The last two pins and , or anode and cathode are for the LED back light.

After all we don't have to worry much about how the LCD works, as the Liquid Crystal Library takes care for almost everything. From the Arduino's official website you can find and see the functions of the library which enable easy use of the LCD. We can use the Library in 4 or 8 bit mode. In this tutorial we will use it in 4 bit mode, or we will just use 4 of the 8 data pins.

How to Connect Arduino to LCD - Wiring Diagram

Here's how we need to connect the 16×2 LCD display to an Arduino board.

We will use just 6 digital input pins from the Arduino Board. The LCD's registers from will be connected to Arduino's digital pins from 4 to 7. The pin will be connected to pin number 2 and the pin will be connected to pin number 1. The pin will be connected to Ground and the pin will be connected to the potentiometer middle pin.

You can get these components from any of the sites below:
Disclosure: These are affiliate links. As an Amazon Associate I earn from qualifying purchases.
Adjusting the contrast of the LCD

We can adjust the contrast of the LCD by adjusting the voltage input at the Vo pin. We are using a potentiometer because in that way we can easily fine tune the contrast, by adjusting input voltage from 0 to 5V.

Can I use the LCD without Potentiometer?

Yes, in case we don't have a potentiometer, we can still adjust the LCD contrast by using a voltage divider made out of two resistors. Using the voltage divider we need to set the voltage value between 0 and 5V in order to get a good contrast on the display. I found that voltage of around 1V worked worked great for my LCD. I used 1K and 220 ohm resistor to get a good contrast.

There's also another way of adjusting the LCD contrast, and that's by supplying a PWM signal from the Arduino to the pin of the LCD. We can connect the pin to any Arduino PWM capable pin, and in the setup section, we can use the following line of code:

It will generate PWM signal at pin D11, with value of 100 out of 255, which translated into voltage from 0 to 5V, it will be around 2V input at the Vo LCD pin.

LCD Arduino Code

Here's a simple code through which we can explain the working principle of the Liquid Crystal library. This is the code of the first example from the video:
Code description:
First thing we need to do is it insert the Liquid Crystal Library. We can do that like this: Sketch > Include Library > Liquid Crystal. Then we have to create an LC object. The parameters of this object should be the numbers of the Digital Input pins of the Arduino Board respectively to the LCD's pins as follow: (RS, Enable, D4, D5, D6, D7). In the setup we have to initialize the interface to the LCD and specify the dimensions of the display using the begin() function.

In the loop we write our main program. Using the print() function we print on the LCD.

The setCursor() function is used for setting the location at which subsequent text written to the LCD will be displayed.

The blink() function is used for displaying a blinking cursor and the noBlink() function for turning off.

The cursor() function is used for displaying underscore cursor and the noCursor() function for turning off. Using the clear() function we can clear the LCD screen.

Scrolling text example on 16×2 LCD and Arduino

In case we have a text with length greater than 16 characters, we can scroll the text using the scrollDisplayLeft() or scrollDisplayRight() function from the LiquidCrystal library.

Here's an example code:

We can choose whether the text will scroll left or right, using the scrollDisplayLeft() or scrollDisplayRight() functions. With the function we can set the scrolling speed.

If you want more control over how the text is scrolling, you could also make the scrolling on your own using a "for" loop. Here's an example:

How to Generate and Display Custom Characters on the LCD

In addition to the ASCII characters, with the LiquidCrystal library it is also possible to generate and display custom characters on the LCD.

We can specify the appearance of each character by an array of 8 bytes. Here's an example code:

We can notice how we can specify the appearance of the character by changing the 0s into 1s within the 5×8 pixels grid.

In the setup we have to create the custom character using the createChar() function.

The first parameter in this function is a number between 0 and 7, or we have to reserve one of the 8 supported custom characters. The second parameter is the name of the array of bytes.

We write the custom character to the display using the write() function and as a parameter we use the number of the character.

See also: Arduino Touch Screen Tutorial | TFT LCD

Conclusion

So, we have covered pretty much everything we need to know about using an LCD with Arduino. These LCD Character displays are really handy for displaying information for many electronics project. In the examples above I used 16×2 LCD, but the same working principle applies for any other size of these character displays.

I hope you enjoyed this tutorial and learned something new. Feel free to ask any question in the comments section below and don't forget to check out my full collection of 30+ Arduino Projects.

# data[].attributes.attachment_link.title
Arduino 16x2 LCD Tutorial - Everything You Need to Know

# data[].attributes.attachment_link.description
In this Arduino LCD Tutorial we will learn how to connect an LCD (Liquid Crystal Display) to the Arduino board. LCDs like these are...

# data[].attributes.attachment_link.provider_name
theoryCIRCUIT - Do It Yourself Electronics Projects

# data[].attributes.attachment_link.readable_text
UV - Ultraviolet light radiation occurs from 10nm to 400nm wavelength in electromagnetic spectrum, to get effective output in accordance with UV light the ML8511 sensor from lapis semiconductor helps a lot. This sensor comes in surface mount type package hence better to use in breakout board.

The ML8511 UV sensor detects 280nm - 390nm light in a better way, this wavelength is categorized as part of the UVB-burning rays spectrum and most of the UVA-tanning rays spectrum.
Block Diagram
The sensor ML8511 has a UV photodiode and Internal Amplifier which will converts photo current to voltage output depending on the UV light intensity.

Through the voltage output it is easy to interface with external micro controllers and ADC.

ML8511 Breakout Board

The sensor ML8511 is very handy to use in breakout board and it requires 3.3V with low supply current 300μA, and gives output in Analog signal variation. This breakout board can be easily interfaced with all kind of micro controllers(which having ADC) and Arduino boards.
UV characteristics
The characteristics drawn between output Voltage from the sensor with respect to UV intensity (mW/cm²) at constant VDD supply. The curves in different color represents sensor operation in different temperature range.

Arduino Hookup with ML8511

Connect the breakout board with Arduino board as illustrated, Made connection between 3.3V and A1 (analog input 1) of Arduino board for reference. This example hookup considered to have sensor out in A0. Don't provide Vdd more than 3.3V, it may damage the device due to its low voltage and low current character.
Arduino UV sensor Code Reference uv sensor ml8511 Datasheet

# data[].attributes.attachment_link.description
UV - Ultraviolet light radiation occurs from 10nm to 400nm wavelength in electromagnetic spectrum, to get effective output in accordance with UV light the ML8511 sensor from lapis semiconductor...

# data[].attributes.attachment_link.readable_text
https://www.youtube.com/watch?v=R-o1q9Vmtk4

*GitHub : https://github.com/rdiot/rdiot-s083.git

The ML8511 breakout is an easy to use ultraviolet light sensor. The MP8511 UV (ultraviolet) Sensor works by outputing an analog signal in relation to the amount of UV light that's detected.
This breakout can be very handy in creating devices that warn the user of sunburn or detect the UV index as it relates to weather conditions.
This sensor detects 280-390nm light most effectively.
This is categorized as part of the UVB (burning rays) spectrum and most of the UVA (tanning rays) spectrum.
It outputs a analog voltage that is linearly related to the measured UV intensity (mW/cm2).
If your microcontroller can do an analog to digital signal conversion then you can detect the level of UV!

- Key Code
int UVOUT = A0; //Output from the sensor
int REF_3V3 = A1; //3.3V power on the Arduino board

int uvLevel = averageAnalogRead(UVOUT);
int refLevel = averageAnalogRead(REF_3V3);

//Use the 3.3V power pin as a reference to get a very accurate output value from sensor
float outputVoltage = 3.3 / refLevel * uvLevel;
float uvIntensity = mapfloat(outputVoltage, 0.99, 2.9, 0.0, 15.0);

lcd.print("uv=" + (String)uvIntensity + "(mW/cm^2)");

//The Arduino Map function but for floats
float mapfloat(float x, float in_min, float in_max, float out_min, float out_max)
{
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

# data[].attributes.attachment_link.description
ML8511 UV Sensor (GYML8511) [S083] https://www.youtube.com/watch?v=R-o1q9Vmtk4 *GitHub : https://github.com/rdiot/rdiot-s083.git * Specs The ML8511 breakout is an easy to use ultraviolet light sensor. The MP8511 UV (ultraviolet) Sensor works by outputing an analog signal in relation to the amount of UV light that's detected. This breakout can be very handy in creating devices that warn the user ..

# data[].attributes.attachment_link.description
Programming ATtiny85 in 10 steps #arduSerie 29

# data[].attributes.attachment_link.readable_text
Introduction: Arduino Class: What You'll Learn

Arduino Class Table of Contents:

Have you ever wanted to tinker with technology? Arduino exists to help creative people and techno-beginners build projects with electronics. As a platform, it fast-tracks users to success by helping ease the setup burden and learning curve usually associated with electrical engineering and computer science.

Arduino is the best way to get started with microcontroller programming and building your own circuits that sense and react to the world around them. In this class, we'll get creative with electronics and get comfortable with the concepts you'll use to launch your long and fruitful Arduino journey.

The name Arduino defines several layers of your experience:

software - used to compose your programs and communicate with the hardware, called an integrated development environment (Arduino IDE)

hardware - refers to the boards themselves (e.g. Arduino Uno)

programming language - the Arduino programming language is based on C

trademark - Other brands may manufacture Arduino-compatible hardware, but only some boards are official, and owning their trademark provides some unique protections. For instance, it allows the hardware and software to remain open source.

Arduino is also a huge global community, which means you'll find vast quantities of inspirational projects, sample code, and solutions to your problems online.

The following lessons are designed to build your skills in Arduino incrementally over time, leaving you with enough basic knowledge to go out and create projects from your imagination.

Early on, you'll do breadboard experiments to increase your familiarity with key concepts of electricity, components, and coding in the Arduino language.

Adding interactivity will be your next challenge. While you level up your hardware skills to add buttons and knobs to control your circuits, you'll also learn more programming concepts.

Then you'll acquire a variety of skills for building and programming, including soldering, understanding the power requirements of your Arduino projects, installing code libraries, and controlling a strip of addressable LEDs. You will graduate with the confidence to take on infinite Arduino projects in the future!

Add Tip Ask Question Download

Step 1: Tools and Materials for Arduino

This lesson is a complete list of the supplies you'll need to complete this class. To make it a bit easier to get everything at once, I've created an Adafruit wishlist containing most of the components and tools. To get started with the bare minimum, you can complete most of the core exercises with the contents of the Adafruit Arduino Uno Budget Pack. If you're using a different kit, some of the components may differ from those shown in the photos throughout this class. You may also complete this entire class virtually, for free, using Tinkercad Circuits!

For the basic exercises:

To complete the Skills Infusion lesson (here's a great toolkit with almost everything you need):

Recommended vendors for Arduino components & accessories:

Add Tip Ask Question Download

Step 2: Understanding the Tools

Arduino Uno - This board is built around the Atmega328 microcontroller, with supporting components to make it easy to connect up your own circuits. The Uno connects to your computer with a USB A to B cable, which is commonly used for printers (boxy connector). For this class, it is acceptable to use a compatible stand-in for the Arduino Uno, such as a Sparkfun RedBoard or Seeeduino V4.2, just make sure you have the right USB cable.

Solderless breadboard - This device has strips of metal inside and many holes that allow you to connect components quickly and easily. A mounting plate is recommended, to keep the breadboard and Arduino Uno together. You'll connect to the Arduino with wires ( breadboard wires are great but you can also use solid core hookup wire).

Electronic components - You'll create circuits by plugging LEDs and other components into your breadboard. This class introduces each new component with a basic exercise showing you how to wire it up and write an appropriate Arduino program. Components used: 5mm LEDs, resistors, a pushbutton switch, a potentiometer, and a small DC motor (with its own diode and transistor). Lessons cover the basics with an emphasis on writing code to interact with the components. For more in-depth information beyond what's covered here, please check out Randy Sarafan's Electronics class or LEDs & Lighting class.

Soldering tools - The Skills Infusion lesson teaches you how to connect wires to LED strip with a soldering iron, which heats the components enough to flow solder (an easy melting alloy) between them. Any basic iron will do! Wire strippers remove insulation to expose the conductor inside, pliers and tweezers help you position components, and a third hand tool helps keep everything steady. Flush snips do a great job trimming excess wires and component leads after soldering. Wear protective eyewear when soldering and clipping wires, and solder in a well-ventilated area.

RGBW NeoPixel strip - This digitally addressable strip contains WS2812b chips controlling compound LEDs in red, green, blue, and white. NeoPixel is the Adafruit brand name but you can also find this strip by searching for "WS2812b RGBW strip" on your favorite supplier's site. The sample code provided in this class will not work with RGB (no white) strip, analog LED strip, or with any other kind of digital control chip (like APA104 aka DotStar).

Add Tip Ask Question Download

Step 3: Software Setup

The Arduino IDE (software for composing code and sending it to your board) runs on Windows, Mac OS X, and Linux. Head to the download page and click the option that best describes your system. While the software is downloading, connect your Arduino board to your computer with a USB A to B cable (flat to boxy, typically used for printers). The green LED next to the label ON should turn on, and the orange LED next to the label L should begin blinking.

Depending on your operating system, your software installation procedure will vary. On Windows, run the installer, which will also install the necessary drivers (provided your Arduino board is plugged in). On OS X, drag the Arduino app into your Applications folder (no drivers necessary). For more help with Windows if the installation doesn't go smoothly, refer to Arduino's detailed instructions. If you prefer not to download software, most of the class can also be completed using the Arduino Web Editor.

Open the Arduino application and load up the first code example by selecting File -> Examples -> 01.Basics -> Blink.

Next it's time to tell the software what kind of Arduino board we intend to program. Select Tools -> Board -> Arduino/Genuino Uno.

Then we need to select the communication port connected to the Arduino board. Select Tools -> Port, then whichever port name is labeled "(Arduino/Genuino Uno)." If none of your ports are labeled, try unplugging your board, checking the Ports menu, then replugging your board and checking the Ports menu again. Whichever port name disappears then reappears is likely to be your Arduino board. On Windows your port will likely be called "COM3" (or higher numbers) and on OS X it's likely to be something like "/dev/cu.usbmodem1461."

Now click the Upload button to transfer the Blink example code to the Arduino board. The LEDs labeled RX and TX will flash, and the software will show a message "Done uploading." Moments later the LED labeled L will begin blinking as it did when you first plugged it in.

Congratulations, you're ready to begin the next lesson, where we'll dig into the code you just uploaded, as well as build your first few LED circuits and discover how to control them using basic Arduino programming concepts.

If your port doesn't appear, or you get an error when trying to upload, refer to Arduino's detailed troubleshooting guide, which covers many other common issues.

Add Tip Ask Question Download

Step 4: Arduino History

The origin story of Arduino is long and complicated, with more characters than Game of Thrones. I'll attempt to summarize it here, with a focus on the evolution of the hardware and community.

In the early 2000s, students and professors at the Interaction Design Institute Ivrea (IDII) in Italy developed a new microcontroller board for use specifically by artists and designers. They held workshops and seminars using the boards throughout different iterations, which were programmed using Wiring, a creative coding platform developed by Hernando Barragán. Wiring easily allowed creators to program microcontrollers by providing a supportive software environment, a bootloader for easily uploading programs to the board, and a comprehensive online reference including add-on libraries and forums.

Some other members of IDII partnered with a manufacturer to develop a version of the hardware that used an Atmega8 microcontroller, and Arduino was born. The original Arduino team members' names can be found on the Arduino NG board pictured above: Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, and David Mellis.

The Arduino Uno we'll use in this class is the flagship development board of the Arduino brand, and it is the latest iteration in a long line of boards with a mission to make it easier for non-engineers to use.

Features accrued over time, and DIY upgrade tutorials also were published, when applicable. I recall hand-soldering a capacitor to two pads on my Arduino NG in order to take advantage of a new Diecimila update. The pin layout was consistent between boards (with some more pins added in later models) so that add-on shields could be backwards compatible. There's a full chronology about the board that became the Uno on the Arduino site.

Other boards with specialized functions have been released in the Arduino product line. Need more inputs and outputs? Use an Arduino Mega. Want a smaller circuit board and USB keyboard functionality? Use an Arduino Micro. And so forth. Official Arduino boards are all natively supported by the Arduino software.

For the enthusiast, it's possible to develop your own hardware that works with the Arduino software, too. Because Arduino is an ecosystem of open source hardware and software, it's possible to develop your own hardware that works with the Arduino software. It is also possible to build on the circuit to create a version to suit a more specific function, and manufacture and sell those designs. Because the plans have been freely available online, you'll see hundreds of Arduino-compatible boards designed by corporations and individuals alike, ranging wildly in function and complexity. Some are designed to be pin-compatible with the Arduino Uno, like the Sparkfun Redboard or Adafruit Metro. More compact boards for building tidy small circuits like the Pro Trinket and Pro Mini make it easy to translate your breadboard prototype to a finished project. Complex boards like the Huzzah (wifi), Touch Board (capacitive touch + audio playback), and Circuit Playground (beginner lessons baked into the board) empower beginners to accomplish very sophisticated projects with ease.

Arduino Class Table of Contents:

Add Tip Ask Question Download

# data[].attributes.attachment_link.description
Arduino Class: What You'll Learn: Arduino Class Table of Contents: What You'll Learn (you are here) Your First Experiments Input/Output Skills Infusion & Going Further Have you ever wanted to tinker with technology? Arduino exists to help creative people and techno-beginners b...

# data[].attributes.attachment_link.title
ATtiny85 Arduino Board: How to Flash the Arduino Bootloader and Run A Simple Sketch — Maker Portal

# data[].attributes.attachment_link.description
The ATtiny family is a series of tiny microcontrollers capable of utilizing many of the libraries available on the Arduino platform. The ATtiny85 is used here because of its small profile and widespread availability. It is an 8-pin, 8-bit, AVR microcontroller that can run the Arduino bootloader with

# data[].attributes.attachment_link.title
Arduino ATtiny85 Programmer Shield on PCB [ATtinyShield]

# data[].attributes.attachment_link.description
Arduino ATtiny85 Programmer Shield on PCB [ATtinyShield]:      Arduino projects are very popular but also big and expensive. There are many times that we don’t need so many input or output pins. As a matter of fact, most projects could be accomplished with only 2 or 3 input…

# data[].attributes.attachment_link.title
Kit électronique pour débutant avec arduino uno

# data[].attributes.attachment_link.description
Kit économique contenant l'Arduino Uno et les composants pour débuter facilement. Ce kit permet de suivre les tome 1 et 2 de notre collection .

# data[].attributes.attachment_link.authors[].name
Tutoriels Arduino 0 Commentaires Vues (6363)

# data[].attributes.attachment_link.description
Le blog de l’équipe de Robot Maker vous permet de vous plonger dans l’univers des Makers. Au travers de différents articles découvrez de nombreux tutoriels Arduino, des fiches pratiques et bien d’autres goodies.

# data[].attributes.attachment_link.title
U=RI | Arduino Ep.12 - Comment utiliser un capteur à ultrasons?

# data[].attributes.attachment_link.title
Using the HC-SR04 Ultrasonic Distance Sensor with Arduino - Everything you need to know!

# data[].attributes.attachment_link.title
Ultrasonic Sensor HC-SR04 and Arduino Tutorial

# data[].attributes.attachment_link.title
Arduino Light Sensor Tutorial: Learn to Setup a Photoresistor

# data[].attributes.attachment_link.provider_name
éduscol | Ministère de l'Éducation nationale et de la Jeunesse - Direction générale de l'enseignement scolaire

# data[].attributes.attachment_link.readable_text
Les ressources proposées sur cette page ont pour vocation d'explorer et de promouvoir des pratiques renouvelées dans l'enseignement de la physique-chimie au collège et au lycée. Elles ont été produites par le groupe de recherche et d'innovation pour l'enseignement des sciences physiques (GRIESP).

Présentation des thématiques

Pour l'année scolaire 2021-2022, le GRIESP aborde la transmission des valeurs de la République en physique-chimie par la pratique pédagogique (exemple : développer la sensibilisation à l'égalité filles-garçons), les démarches scientifiques (exemple : distinguer savoirs scientifiques et croyances) et l'intégration aux concepts de physique-chimie (exemple : produire de l'énergie propre).

Pour l'année scolaire 2020-2021, le GRIESP aborde la thématique de la prolongation hors du temps scolaire de la formation expérimentale des élèves. Il s'agit de montrer comment il est possible de renforcer les compétences expérimentales des élèves par une articulation entre le temps de formation expérimentale indispensable en classe et une activité, en amont ou en aval, réalisée à distance par les élèves.

Le GRIESP propose des séquences pédagogiques pour le collège, avec un accent mis sur le changement climatique et le développement durable, pour le lycée général et technologique et le lycée professionnel, en lien avec les nouveaux programmes de lycée.

Les travaux du GRIESP de 2019-2020 étudient une notion, une loi à partir d'un contexte historique à même de motiver les élèves, et font de l'histoire de ce concept un outil pour renforcer les apprentissages, en acceptant que le cheminement proposé ne reproduise pas forcément le déroulé historique. C'est aussi l'occasion de discuter la notion de modèle, telle qu'on l'entend en physique-chimie et qui apparaît comme un marqueur fort des nouveaux programmes.

Les ressources élaborées par le GRIESP ont essentiellement pour but de proposer sans dogmatisme excessif une initiation aux enjeux des incertitudes de mesure sans rentrer dans les détails mathématiques qui seront éventuellement développés dans l'enseignement supérieur.
Ces ressources permettent de sensibiliser les élèves, à partir d'exemples simples, démonstratifs et attrayants à la variabilité des valeurs obtenues lors de séries de mesures. Celles-ci, obtenues par exemple dans le cadre d'expériences collectives de classe et dans des contextes disciplinaires authentiques, pourront être exploitées et analysées par les élèves.
La progressivité des apprentissages du cycle 4 à la classe de terminale est mise en avant, permettant la réactivation des connaissances travaillées antérieurement.

Ces ressources préparées en 2017-2018 explorent l'intérêt de la programmation dans l'enseignement de la physique-chimie. Leur objectif n'est pas la formation des élèves à l'informatique, mais l'utilisation de leurs compétences dans ce domaine pour l'acquisition de connaissances et de compétences en physique-chimie. Des fiches synthétiques sur les différents environnements logiciels utilisés présentent leurs intérêts et leurs spécificités, proposent des liens de téléchargement et vers des ressources pour se former. Des fiches thématiques explorent des pistes d'activités accompagnées d'exemples de programmation et déclinées dans différents environnements logiciels.

Cette série de ressources produites en 2016-2017 permet de travailler sur des difficultés identifiées chez les élèves en mécanique du cycle 3 au lycée. Des éléments didactiques y sont proposés, ainsi que des pistes d'évaluations (diagnostiques et formatives), d'activités et de séquences pédagogiques. Des retours d'expérimentations en classe sont également fournis. Chaque problématique est déclinée par cycle ou par niveau de classe.

Les ressources produites par le GRIESP peuvent être téléchargées depuis le tableau ci-dessous.

Vous pouvez réduire l'affichage en sélectionnant une thématique, un thème de programme ou bien un niveau d'enseignement. Si vous sélectionnez des valeurs dans plusieurs filtres, seules les ressources correspondant à l'ensemble des critères resteront affichées.

Consulter les ressources proposées par les sites Culture Sciences Physique et Culture Sciences Chimie, des sites pour la formation des enseignants issus d'un partenariat entre la Dgesco, l'ENS de Lyon et l'ENS - PSL.

# data[].attributes.attachment_link.title
Recherche et innovation pour l'enseignement des sciences physiques

# data[].attributes.attachment_link.readable_text
Yahoo refuse tous les emails du site. Si vous avez une adresse chez un autre prestataire, c'est le moment de l'utiliser

En cas de soucis, n'hésitez pas à aller faire un tour sur la page de contact en bas de page.

# data[].attributes.attachment_link.title
Code d'exemple pour un capteur à ultrasons HC-SR04

# data[].attributes.attachment_link.description
Code d'exemple pour un capteur à ultrasons HC-SR04.

# data[].attributes.attachment_link.readable_text
English version
Récupération de données captées par l'Arduino avec Python via USB
Télécharger le code Python Télécharger le code Arduino Site de Pyserial (en anglais)
Détails et explications

Principe

La carte Arduino permet d'acquerir des données par l'intermédiaire de capteur et d'un CAN (Convertisseur Analogique Numérique). Ensuite ces données numériques sont déposées à intervalles réguliers sur un "bus", une zone d'échange. De manière synchronisée l'ordinateur avec Python va lire le contenu de ce "bus". C'est pour que la synchronisation soit bien faite qu'il est important d'utiliser le même "Baudrate" dans l'Arduino et dans le programme Python.

Résultat

Voici un exemple de courbe que l'on peut obtenir en utilisant matplotlib pour tracer les données dont nous avons fait l'acquisition.

import matplotlib.pyplot as plt
cleandata=clean(rawdata)

def write(L):
file=open("data.txt",mode='w')
for i in range(len(L)):
file.write(L[i]+'\n')
file.close()

write(cleandata)

vals,temps=np.loadtxt('data.txt',delimiter=';',unpack=True)
plt.plot(temps,vals)
plt.show()

Conclusion

Cette façon de faire permet de s'affranchir d'une shield pour écrire sur une carte SD tout en effectuant un travail équivalent. J'ai aussi remarqué que l'écriture sur une carte SD est plus lente que l'écriture dans le port série ce qui peut être gênant pour certaines applications très gourmandes en ressources

# data[].attributes.attachment_link.description
English version Récupération de données captées par l'Arduino avec Python via USB Télécharger le code Python Télécharger le code Arduino Site de Pyserial (en anglais) Détails et explications Principe La carte Arduino permet d'acquerir des données par l'intermédiaire de capteur et d'un CAN (Convertisseur Analogique Numérique).

# data[].attributes.attachment_link.readable_text
Pour commencer ce chapitre sur les capteurs, j'ai rassemblé un petit nombre de capteurs qui sont très utilisés en robotique et en domotique. Vous pourrez ainsi comprendre certains concepts généraux tout en ayant accès à une base de connaissance qui puisse vous aider lorsque vous aurez besoin de mettre en place vos projets personnels. On va commencer en douceur avec les capteurs logiques, aussi appelés Tout Ou Rien (TOR). Puis on continuera vers les capteurs utilisant des transducteurs à résistance de sortie variable. On verra ensuite des capteurs un peu particuliers puis pour finir des capteurs un peu compliqués. C'est parti !

Sommaire

Tout Ou Rien, un capteur qui sait ce qu'il veut

On va donc commencer par voir quelques capteurs dont la sortie est un état logique qui indique un état : Ouvert ou Fermé . Ces capteurs sont appelés des capteur Tout Ou Rien, capteurs logiques ou encore capteurs à rupture de tension .

Deux états

Schéma d'un capteur normalement ouvert

Schéma d'un capteur normalement fermé

Lorsque le capteur est dit ouvert (ou open en anglais), le courant ne passe pas entre ses bornes.

S'il s'agit de la position de repos , c'est à dire lorsque le capteur ne capte pas la grandeur qu'il doit capter, on dit alors que le capteur a un contact de type Normalement Ouvert (ou Normally Open en anglais). Tandis que si le capteur est dit fermé (ou close en anglais), le courant peut passer entre ses bornes. S'il s'agit cette fois de sa position de repos, alors on dit qu'il possède un contact Normalement Fermé (ou Normally Closed ).

Le capteur ILS ou Interrupteur à Lames Souples

Le principe du TOR

Une question qui vous est peut-être passée par la tête : mais comment ce capteur peut mesurer une grandeur physique avec seulement deux états en sortie ? C'est assez facile à comprendre.

Imaginons, dans le cadre d'un de vos projets personnels, que vous ayez l'intention de faire descendre les volets électriques lorsqu'il fait nuit. Vous allez alors avoir recours à un capteur de luminosité qui vous donnera une image, par une autre grandeur physique, de l'intensité lumineuse mesurée. Hors, vous ne voulez pas que ce capteur vous dise s'il fait un peu jour ou un peu nuit, ou entre les deux... Non, il vous faut une réponse qui soit OUI ou NON il fait nuit. Vous aurez donc besoin d'un capteur TOR. Alors, il en existe qui sont capables de donner une réponse TOR, mais lorsque l'on utilisera un transducteur, on devra gérer ça nous même avec Arduino et un peu d'électronique.

Champ magnétique

Ne prenez pas peur, je vais simplement vous présenter le capteur ILS qui utilise le champ magnétique pour fonctionner. En effet, ce capteur, est un capteur TOR qui détecte la présence de champ magnétique. Il est composé de deux lames métalliques souples et sensibles au champ magnétique.

Lorsqu'un champ magnétique est proche du capteur, par exemple un aimant, eh bien les deux lames se mettent en contact et laissent alors passer le courant électrique. D'une façon beaucoup plus simple, c'est relativement semblable à un interrupteur mais qui est actionné par un champ magnétique. Photo d'un interrupteur ILS et image, extraites du site Wikipédia :

Interrupteur à lames souples (reed) - (CC-BY-SA, Timothée Cognard )

Action de l'aimant sur l'interrupteur - (CC-0)

Dès que l'on approche un aimant, à partir d'un certain seuil de champ magnétique, le capteur agit. Il devient alors un contact fermé et reprend sa position de repos, contact NO, dès que l'on retire le champ magnétique. Ce type de capteur est très utilisé en sécurité dans les alarmes de maison. On les trouve essentiellement au niveau des portes et fenêtres pour détecter leur ouverture.

Câblage

Le câblage de ce capteur peut être procédé de différentes manières. On peut en effet l'utiliser de façon à ce que le courant ne passe pas lorsque rien ne se passe, ou bien qu'il ne passe pas lorsqu'il est actionné.

Représentation schématique

Représentation schématique

1. Dans le premier cas, la sortie vaut HIGH quand l'ILS est au repos et LOW lorsqu'il est actionné par un champ magnétique.

2. Sur la deuxième image, le câblage est différent et fait en sorte que la sortie soit à LOW lorsque le contact ILS est au repos et passe à HIGH dès qu'il est actionné par un champ magnétique.

Un petit programme tout simple qui permet de voir si l'ILS est actionné ou non, selon le schéma utilisé :

Capteur logique prêt à l'emploi

Bon, là ça va être très très court, puisque vous savez déjà faire ! Les capteurs tout prêts que l'on peut acheter dans le commerce et qui fournissent un état de sortie logique (LOW ou HIGH) sont utilisables tels quels.

Il suffit de connecter la sortie du capteur sur une entrée numérique de la carte Arduino et de lire dans le programme l'état sur cette broche. Vous saurez donc en un rien de temps ce que le capteur indique. On peut citer pour exemple les capteurs de mouvements.

Capteurs à résistance de sortie variable

La photo-résistance

Nous y voilà, on va enfin voir le transducteur dont j'arrête pas de vous parler depuis tout à l'heure : la photo-résistance ! Je vois que vous commenciez à être impatients.

Petit aperçu

La photo-résistance est un composant électronique qui est de type transducteur. Il est donc capable de donner une image de la grandeur physique mesurée, la lumière ou précisément la luminosité, grâce à une autre grandeur physique, la résistance.

Une photorésistance - (CC-0)

On trouve généralement ce composant en utilisation domotique, pour... devinez quoi ?! ... faire monter ou descendre les volets électriques d'une habitation !

Mais on peut également le retrouver en robotique, par exemple pour créer un robot suiveur de ligne noire. Enfin on le trouve aussi dans beaucoup d'autres applications, vous saurez trouver vous-mêmes où est-ce que vous l'utiliserez, je vous fais confiance de ce point de vue là.

Propriété

La photo-résistance suit une relation toute simple entre sa résistance et la luminosité :

Plus l'intensité lumineuse est élevée, plus la résistance diminue. À l'inverse, plus il fait sombre, plus la résistance augmente.

Malheureusement, les photo-résistances ne sont pas des transducteurs très précis. Ils ont notamment des problèmes de linéarité, un temps de réponse qui peut être élevé et une grande tolérance au niveau de la résistance. Nous les utiliserons donc pour des applications qui ne demandent que peu de rigueur. Ce qui ira bien pour ce qu'on veut en faire.

Symbole de la photorésistance

Une photorésistance est une résistance qui possède une valeur de base en Ohm. C'est à dire qu'elle est calibrée pour avoir une valeur, par exemple 47 kOhm, à un certain seuil de luminosité. À ce seuil on peut donc mesurer cette valeur, suivant la tolérance qu'affiche la photo-résistance. Si la luminosité augmente, la résistance de base n'est plus vraie et chute. En revanche, dans le noir, la résistance augmente bien au delà de la résistance de base.

Génial !! J'en veux, j'en veux ! Comment on l'utilise ?

La photorésistance est principalement utilisée dans un montage en pont diviseur de tension. Vous le connaissez ce montage, c'est exactement le même principe de fonctionnement que le potentiomètre. Sauf que ce ne sera pas vous qui allez modifier le curseur mais la photorésistance qui, selon la luminosité, va donner une valeur ohmique différente. Ce qui aura pour effet d'avoir une influence sur la tension en sortie du pont diviseur.

Rappel sur le pont diviseur de tension

Je vous rappelle le montage d'un pont diviseur de tension :

Pont diviseur de tension

La formule associée est la suivante :

Reprenons le tableau présentant quelques exemples :

Vous allez donc maintenant comprendre pourquoi je vais vous donner deux montages pour une utilisation différente de la photorésistance...

Utilisation n°1

Ce premier montage, va être le premier capteur que vous allez créer ! Facile, puisque je vous fais tout le travail. Le principe de ce montage réside sur l'utilisation que l'on va faire de la photo-résistance.

Comme je vous le disais à l'instant, on va l'utiliser dans un pont diviseur de tension. Exactement comme lorsque l'on utilise un potentiomètre. Sauf que dans ce cas, c'est l'intensité lumineuse qui va faire varier la tension en sortie. Voyez plutôt :

Branchement n°1

Montage n°1

On calibre le pont diviseur de tension de manière à ce qu'il soit "équitable" et divise la tension d'alimentation par 2 en sa sortie. Ainsi, lorsque la luminosité fluctuera, on pourra mesurer ces variations avec la carte Arduino. Avec ce montage, plus l'intensité lumineuse est élevée, plus la tension en sortie du pont sera élevée à son tour. Et inversement, plus il fais sombre, moins la tension est élevée.

Utilisation n°2

Tandis que là, c'est l'effet inverse qui va se produire : plus il y aura de lumière, moins il y aura de tension en sortie du pont . Et plus il fera sombre, plus la tension sera élevée.

Branchement n°2

Montage n°2

Rien de bien sorcier. Il suffit de bien comprendre l'intérêt du pont diviseur de tension.

Un peu de programmation

Et si vous aviez un réveil, qui ne vous donne pas l'heure ? Fort utile, n'est-ce pas ! Non, sérieusement, il va vous réveiller dès que le jour se lève... ce qui fait que vous dormirez plus longtemps en hiver. C'est vos profs qui vont pas être contents ! Vous n'aurez qu'à dire que c'est de ma faute.

Bon allez, un peu de tenue quand même, je ne voudrais pas être la cause de votre échec scolaire. Cette fois, vraiment sérieusement, nous allons faire un tout petit programme qui va simplement détecter la présence ou l'absence de lumière. Lorsque la tension en sortie du pont diviseur de tension créée avec la photorésistance et la résistance fixe chute, c'est que la luminosité augmente. À vous de choisir le schéma correspondant suivant les deux présentés précédemment. Pour commencer, on va initialiser les variables et tout le tralala qui va avec.

Qu'allons-nous retrouver dans la fonction loop() ? Eh bien avant tout il va falloir lire la valeur présente en entrée de la broche analogique A0. Puis, on va calculer la tension correspondante à la valeur lue. Enfin, on va la comparer au seuil préalablement défini qui indique le niveau pour lequel l'absence de lumière fait loi.

Exemple interactif :

Un programme plus évolué

Après tant de difficulté ( ), voici un nouveau programme qui vous sera peut-être plus intéressant à faire. En fait ça le deviendra dès que je vous aurais dit l'application qui en est prévue...

Préparation

Cette fois, je vais vous demander d'avoir deux photorésistances identiques. Le principe est simple on va faire une comparaison entre les deux valeurs retournées par les deux capteurs (deux fois le montage précédent).

Branchement papillon de lumière

Montage papillon de lumière

Si la valeur à droite est plus forte, on allumera une LED en broche 2. Sinon, on allume en broche 3. Si la différence est faible, on allume les deux. Dans tous les cas, il n'y a pas de cas intermédiaire. C'est soit à gauche, soit à droite (selon la disposition des photorésistances).

Ce principe pourrait être appliqué à un petit robot mobile avec un comportement de papillon de nuit. Il cherche la source de lumière la plus intense à proximité.

Le programme

Il parle de lui même, pas besoin d'en dire plus.

J'en parlais donc brièvement, ce petit programme peut servir de cerveau à un petit robot mobile qui cherchera alors la source de lumière la plus intense à ses "yeux". Vous n'aurez plus qu'à remplacer les LED par une commande de moteur (que l'on verra dans la prochaine partie sur les moteurs) et alimenter le tout sur batterie pour voir votre robot circuler entre vos pattes. Bien entendu ce programme pourrait largement être amélioré !

Voici un exemple de résultat sur simulateur :

Un autre petit robot mobile

On peut renverser la situation pour faire en sorte que le robot suive une ligne noire tracée au sol. C'est un robot suiveur de ligne. Le principe est de "coller" les deux "yeux" du robot au sol.

L'état initial va être d'avoir un œil de chaque côté de la ligne noire. Le robot avance tant qu'il voit du blanc (car la ligne noire est sur une surface claire, blanche en général). Dès qu'il va voir du noir (lorsque la luminosité aura diminué), il va alors arrêter de faire tourner le moteur opposé à l'œil qui a vu la ligne noire. Ainsi, le robot va modifier sa trajectoire et va continuer en suivant la ligne.

À partir de cela, je vous laisse réfléchir à tout ce que vous pouvez faire. Non pas de programme donné tout frais, je viens de définir un cahier des charges, somme toute, assez simple. Vous n'avez donc plus qu'à le suivre pour arriver à vos fins.

Capteurs à tension de sortie variable

Passons à un capteur un petit peu plus amusant et plus étonnant, dont les applications sont très variées !

L'élément piézoélectrique

Sous ce nom peu commun se cache un phénomène physique très intéressant. L'élément piézoélectrique, que l'on retrouve dans divers objets du quotidien (montres, certains briquets, raquettes de tennis, ...) présente en effet toute une panoplie de caractéristiques utilisées dans des dizaines voire centaines de domaines. Nous allons voir tout ça en détail. Nous, ce qui va nous intéresser pour le moment, c'est sa propriété à capter des sons.

Éléments piézoélectriques de montre - (CC-BY-SA, FDominec )

Allumeur de briquet - (CC-0)

Constitution

Avant de parler de son fonctionnement, voyons un peu sa constitution.

Prenons les éléments piézoélectriques de la première image, à gauche. On observe qu'ils se trouvent sous une forme de pastille composée de plusieurs couches. Généralement c'est une pastille de céramique qui est montée sur une pastille métallique. La fabrication de ces éléments étant très complexe, nous en resterons à ce niveau d'approche.

Propriété

J'ai trouvé amusant de voir sur internet que l'on parlait de sa propriété principale comme étant analogue à celle d'une éponge. Je ne vous épargnerais donc pas cet exemple.

Dès qu'on met une éponge en contact avec de l'eau, elle l'absorbe. Tandis que lorsqu'on la presse, elle se vide de l'eau qu'elle a absorbée. Le rapport avec l'élément piézoélectrique ? Eh bien il agit un peu de la même manière.

Un élément piézoélectrique, lui, subit un phénomène semblable : dès qu'on lui admet une contrainte mécanique, il génère une tension électrique. En revanche, dès qu'on lui administre une tension électrique, il génère alors une contrainte mécanique, restituée par exemple sous forme sonore.

Génération d'une tension électrique par un élément piézoélectrique sous l'action d'une contrainte mécanique - (CC-BY-SA, Tizeff )

Un exemple d'utilisation dont vous ne vous doutez certainement pas, c'est l'utilisation de cette propriété dans certaines raquettes de tennis. L'élément piézoélectrique se trouve dans le manche de la raquette. Lorsqu'une balle frappe la raquette, elle génère une contrainte mécanique sur l'élément piézoélectrique qui en retour génère une tension électrique. Cette tension est récupérée et injectée à nouveau dans l'élément piézoélectrique qui génère alors une contrainte mécanique opposée à celle générée par la balle. Vous me suivez ? L'intérêt ? Réduire les vibrations causées par le choc et ainsi améliorer la stabilité de la raquette (et de la frappe) tout en réduisant le "stress" provoqué sur le poignet du joueur. Dingue non ?

Utilisation

L'utilisation que nous allons faire de cet élément va nous permettre de capter un choc. Cela peut être un "toc" sur une porte, une déformation de surface, voire même une onde sonore un peu puissante. Ce capteur délivre directement une tension proportionnelle à la contrainte mécanique qu'on lui applique. Il s'agit donc d'un capteur actif. Nous pouvons donc l'utiliser sans rien en le connectant directement avec Arduino.

Montage

Vous allez procéder au montage suivant en respectant le schéma de câblage :

Branchement du piezo

Montage du piezo

La résistance de en parallèle de l'élément piézoélectrique permet d'éviter les courants trop forts qui peuvent être générés par l'élément piézoélectrique.

Il est accompagné par une diode un peu particulière que l'on appelle une diode zener. Cette dernière sert à éviter les surtensions. Si jamais la tension générée par le piezo dépasse son seuil (4.7V en l'occurence), elle deviendra passante et le courant ira donc vers la masse plutôt que dans le microcontrôleur (évitant ainsi de griller l'entrée analogique). Cette dernière n'est pas indispensable mais fortement conseillée.

Programme

Le programme que nous allons associer à ce montage, et qui va être contenu dans la carte Arduino, va exploiter la tension générée par l'élément piézoélectrique, lorsqu'on lui administrera une contrainte mécanique, pour allumer ou éteindre une LED présente en broche 2 de la carte Arduino. On pourra s'en servir pour détecter un événement sonore tel que le toc sur une porte.

La condition pour que l'élément piézoélectrique capte correctement le toc d'une porte est qu'il doit être positionné sur la porte de façon à ce que sa surface soit bien plaquée contre elle. Aussi nous utiliserons la liaison série pour indiquer la tension produite par l'élément piézoélectrique.

C'est un petit plus, par forcément utile mais qui vous donnera une idée de la force qu'il faut pour générer une tension particulière. Vous en trouverez certainement une application utile. Allez, un peu de programmation !

Fonction setup()

Au début du programme nous déclarons quelques variables que nous utiliserons par la suite. Aussi nous amorçons l'utilisation de la liaison série et des broches utilisées de la carte Arduino.

Petite parenthèse par rapport au seuil. Ici il est configuré de façon à être comparé à la lecture directe de la valeur en broche analogique (comprise entre 0 et 1023). Mais on peut aussi le définir pour qu'il soit comparé au calcul de la tension en sortie du capteur (par exemple le mettre à 1, pour 1V).

Initialisation du micro contrôleur pour piloter la LED

Fonction principale

Étant donné que le code est plutôt court et simple, nous le laisserons dans la seule fonction loop() plutôt que de le découper en plusieurs petites fonctions. Cependant libre à vous de l'agencer autrement selon vos besoins.

Seuil de tension

Comme je le disais, il est aussi possible et non pas idiot de changer le seuil pour qu'il soit comparé en tant que tension et non valeur "abstraite" comprise entre 0 et 1023. Cela relève de la simplicité extrême, voyez plutôt :

Je n'ai modifié que le type de la variable seuil_detection .

La réversibilité de l'élément piézoélectrique

Tout à l'heure je vous disais que l'élément piézoélectrique était capable de transformer une contrainte mécanique en une tension électrique. Je vous ai également parlé du "phénomène éponge" en vous disant que l'on pouvait aussi bien absorber que restituer non pas de l'eau comme l'éponge mais une contrainte mécanique à partir d'une tension électrique. On va donc s'amuser à créer du son avec l'élément piézoélectrique !

Faire vibrer l'élément piézoélectrique !

Tout d'abord, il vous faudra brancher l'élément piézoélectrique. Pour cela, mettez son fil noir à la masse et son fil rouge à une broche numérique, n'importe laquelle. Pas besoin de résistance cette fois-ci. Et voilà les branchements sont faits ! Il ne reste plus qu'à générer un signal pour faire vibrer l'élément piézoélectrique. Selon la fréquence du signal, la vibration générée par l'élément piézoélectrique sera plus ou moins grave ou aiguë. Essayons simplement avec ce petit programme de rien du tout (je ne vous donne que la fonction loop(), vous savez déjà tout faire ) :

Ce code va générer un signal carré d'une période de 10ms, soit une fréquence de 100Hz. C'est un son plutôt grave. Vous pouvez aisément changer la valeur contenue dans les délais pour écouter les différents sons que vous allez produire. Essayez de générer un signal avec la PWM et soyez attentif au résultat en changeant la valeur de la PWM avec un potentiomètre par exemple.

Une fonction encore toute prête

Maintenant, si vous souhaitez générer ce signal et en même temps faire d'autres traitements, cela va devenir plus compliqué, car le temps sera plus difficile à maîtriser (et les délais ne sont pas toujours les bienvenus ). Pour contrer cela, nous allons confier la génération du signal à une fonction d'Arduino qui s'appelle tone() .

Cette fonction prend en argument la broche sur laquelle vous voulez appliquer le signal ainsi que la fréquence dudit signal à réaliser. Si par exemple je veux émettre un signal de 440Hz (qui correspond au "la" des téléphones) je ferais : tone(piezo, 440); . Le son va alors devenir permanent, c'est pourquoi, si vous voulez l'arrêter, il vous suffit d'appeler la fonction qui va alors arrêter la génération du son sur la broche spécifiée en argument.

Pour les plus motivés d'entre vous, vous pouvez essayer de jouer une petite mélodie avec l'élément piézoélectrique. Ah les joies nostalgiques de l'époque des sonneries monophoniques .

La tension comme image du courant avec les photodiodes et phototransistors

Étalonner son capteur

Faisons une petite pause dans notre découverte des capteurs pour parler d'un problème qui peut arriver à tout le monde... Comment faites-vous si vous possédez un capteur mais ne possédez pas sa caractéristique exacte ? Comment feriez-vous pour faire correspondre une valeur analogique lue avec une donnée physique réelle ?

Par exemple, si je vous donne un composant en vous disant "Hey, te voilà un capteur de température, je sais qu'il s'alimente en 5V sur telle et telle broches, je sais que le signal de sortie est une tension en fonction de la température mais je suis incapable de te dire quelle est la caractéristique (la courbe tension en fonction de la température)".

Nous allons maintenant voir comment résoudre ce problème en voyant une méthode pour étalonner son capteur. Nous allons ainsi nous même déterminer la courbe caractéristique du capteur et déterminer son coefficient liant la température et la tension. À la fin, je vous donnerais la vraie courbe constructeur et nous pourrons comparer nos résultats pratiques avec ceux de référence .

Le capteur utilisé

Pour étudier la méthode que je vous propose ici, nous allons utiliser un capteur de température assez répandu qui se nomme "LM35". Il existe dans différents boîtiers que voici :

Boîtier du LM35

Vous aurez deviné le branchement, il est assez simple. Il suffit de relier +VS au 5V et GND à la masse. Le signal sera ensuite lu sur la broche Vout.

La méthode

La méthode pour caractériser le capteur est assez simple. À l'aide d'une multitude de mesures et d'un appareil témoin, nous allons pouvoir créer un tableau qui nous servira à calculer la courbe (à l'aide d'un logiciel comme Excel par exemple). Pour cela, en plus de votre capteur vous aurez besoin d'un appareil de mesure "témoin" qui vous servira de référence. Par exemple le bon vieux thermomètre qui traîne accroché à votre fenêtre fera parfaitement l'affaire .

Prise de mesures

Vous êtes prêts, alors allons-y, commençons à travailler. Reliez le capteur à l'Arduino et l'Arduino à l'ordinateur, de la manière la plus simple possible, comme ceci par exemple :

LM35

Ensuite, nous devons récupérer les données envoyées par le capteur de manière régulière (ou rajoutez un bouton et faite des envois lors de l'appui ). Pour cela, voici un petit programme sans difficulté qui vous enverra les valeurs brutes ou converties en volts toutes les demi-secondes.

Maintenant que tout est prêt, il nous faut un banc de test. Pour cela, préparez une casserole avec de l'eau contenant plein de glaçons (l'eau doit être la plus froide possible). Faites une première mesure avec votre capteur plongé dedans (attention, les broches doivent être isolées électriquement ou alors mettez l'ensemble dans un petit sac plastique pour éviter que l'eau n'aille faire un court-circuit). Faites en même temps une mesure de la température réelle observée à l'aide du thermomètre. Une fois cela fait, relevez ces mesures dans un tableau qui possédera les colonnes suivantes :

Température réelle (en °C)

Tension selon Arduino (en V)

Valeur brute selon Arduino

Quand la première mesure est faite, commencez à faire réchauffer l'eau (en la plaçant sur une plaque de cuisson par exemple). Continuez à faire des mesures à intervalle régulier (tous les 5 degrés voire moins par exemple). Plus vous faites de mesure, plus l'élaboration de la courbe finale sera précise. Voici à titre d'exemple le tableau que j'ai obtenu :

Réalisation de la caractéristique

Lorsque vous avez fini de prendre toutes vos valeurs, vous allez pouvoir passer à l'étape suivante qui est :

Calculer la caractéristique de votre courbe !! Sortez vos cahiers, votre calculatrice et en avant ! ... Non je blague (encore que ça ferait un super TP), on va continuer à utiliser notre logiciel tableur pour faire le travail pour nous ! On va donc commencer par regarder un peu l'allure de la courbe.

Je vais en faire deux, une symbolisant les valeurs brutes de la conversion du CAN (entre 0 et 1023) en rouge et l'autre qui sera l'image de la tension en fonction de la température en bleu. Nous pourrons alors déterminer deux caractéristiques, selon ce qui vous arrange le plus.

Valeurs CAN en fonction de la température

Tension en fonction de la température

Une fois cela fait, il ne reste plus qu'à demander gentiment au logiciel de graphique de nous donner la courbe de tendance réalisée par ces points. Sous Excel, il suffit de cliquer sur un des points du graphique et choisir ensuite l'option "Ajouter une courbe de tendance...".

Vous aurez alors le choix entre différents types de courbe (linéaire, exponentielle...). Ici, on voit que les points sont alignés, il s'agit donc d'une équation de courbe linéaire, de type . Cochez la case "Afficher l'équation sur le graphique" pour pouvoir voir et exploiter cette dernière ensuite.

Options de la courbe de tendance

Voici alors ce que l'on obtient lorsque l'on rajoute notre équation :

Ajout de la courbe de tendance

Ajout de la courbe de tendance

Grâce à l'équation, nous pouvons déterminer la relation liant la température et la tension (ou les valeurs du CAN). Ici nous obtenons :

(pour la tension)

(pour les valeurs du CAN)

Le coefficient constant (-0.003 ou -0.0707) peut ici être ignoré. En effet, il est faible (on dit négligeable ) comparé aux valeurs étudiées. Dans les équations, représente la température et représente la tension ou les valeurs du CAN. On lit donc l'équation de la manière suivante : Tension en Volt égale 0,01 fois la température en degrés Celsius. Ce qui signifie que dorénavant, en ayant une mesure du CAN ou une mesure de tension, on est capable de déterminer la température en degrés Celsius Super non ? Par exemple, si nous avons une tension de 300mV, avec la formule trouvée précédemment on déterminera que l'on a , ce qui équivaut à . On peut aisément le confirmer via le graphique

Maintenant j'ai trois nouvelles, deux bonnes et une mauvaise... La bonne c'est que vous êtes capable de déterminer la caractéristique d'un capteur. La deuxième bonne nouvelle, c'est que l'équation que l'on a trouvé est correcte... ... parce qu'elle est marquée dans la documentation technique qui est super facile à trouver (ça c'était la mauvaise nouvelle, on a travaillé pour rien !! ) Mais comme c'est pas toujours le cas, c'est toujours bien de savoir comment faire

Adaptation dans le code

Puisque nous savons mesurer les valeurs de notre capteur et que nous avons une équation caractéristique, nous pouvons faire le lien en temps réel dans notre application pour faire une utilisation de la grandeur physique de notre mesure. Par exemple, s'il fait 50°C nous allumons le ventilateur. En effet, souvenez-vous, avant nous n'avions qu'une valeur entre 0 et 1023 qui ne signifiait physiquement pas grand chose. Maintenant nous sommes en mesure (oh oh oh ) de faire la conversion. Il faudra pour commencer récupérer la valeur du signal. Prenons l'exemple de la lecture d'une tension analogique du capteur précédent :

int valeur = analogRead(monCapteur);

Nous avons ensuite deux choix, soit nous le transformons en tension puis ensuite en valeur physique grâce à la caractéristique du graphique bleu ci-dessus, soit nous transformons directement en valeur physique avec la caractéristique rouge. Comme je suis fainéant, je vais chercher à économiser une instruction en prenant la dernière solution. Pour rappel, la formule obtenue était : . Nous avions aussi dit que le facteur constant était négligeable, on a donc de manière simplifiée soit "la température est égale à la valeur lue divisé par 2.056 ( ). Nous n'avons plus qu'à faire la conversion dans notre programme !

Et voilà ! Si l'on voulait écrire un programme plus complet, on aurait :

Eh bien prenons un exemple ! Admettons qu'on obtienne la caractéristique suivante : . On pourrait lire ça comme "ma valeur lue par le CAN est égale à 10 fois la valeur physique plus 22". Si on manipule l'équation pour avoir en fonction de , on aurait :

Dans le code, cela nous donnerait :

{ valeur = analogRead(monCapteur); temperature = (valeur-22)/10; Serial.println(temperature); delay(500); }

Cas d'une constante non négligeable

# data[].attributes.attachment_link.description
Dans ce chapitre, nous allons parler mesure pour les capteurs simples. Mesure de tension, de résistance ou d'état logique.

# data[].attributes.attachment_link.provider_name
MCHobby - Vente de Raspberry Pi, Arduino, ODROID, Adafruit

# data[].attributes.attachment_link.readable_text
Un kit d'apprentissage et découverte autour de MicroPython

Intéressé par la création d'objets et projets intelligents avec un MicroPython PyBoard mais vous ne savez pas par où commencer?

Ce pack de composant inclus les pièces pour réaliser 10 montages différents et dispose d'une documentation Française en ligne incluant schéma de montage, code d'exemple, conseil et tout ce dont vous avez besoin pour commencer à jouer avec votre PyBoard dès les premières minutes. Et sans besoin de souder !

Il s'agit d'un kit incluant une carte PyBoard + Connecteur PyBoard DEJA SOUDE ainsi qu'un ensemble de composants.

Grâce au pack de composants, vous pourrez apprendre à contrôler les entrées/sorties de votre PyBoard, utiliser des senseurs analogiques en lisant la température et détection de lumière, commander un relais et un moteur, créer des couleurs avec une LED RGB... et bien d'autres choses.

PyBoard ayant été développé par Damien pour réaliser des projets robotiques, nous avons également inclus un pont-H dans les composants, de quoi vous permettre de découvrir les bases du pilotage de moteurs continu pour plateforme robotique (commande de deux moteurs dans les deux sens :-) ).

Qu'est ce que MicroPython

Micro Python est une version rapide, optimisée et allégée du langage de programmation Python 3 pour système embarqué.

PyBoard, la carte MicroPython est une petite carte électronique qui exécute MicroPython en "" et vous offre un système d'exploitation Python bas niveau permettant de contrôler toute sorte de projets électroniques.
En ouvrant la gamme Micro Python, MCHobby entame son 4ième projet de documentation sur son wiki.

Python est un langage de scripting vraiment très facile à apprendre, très expressif, vraiment très puissant et disposant d'une gigantesque communauté.

Venez découvrir la fiche produit de la carte MicroPython PyBoard.

Les tutoriels attachés au kit

Notre Wiki regorge de tutoriel pour MicroPython Pyboard, de quoi vous familiariser avec son son environnement et ses possibilités avant de vous lancer des les premiers montages électroniques.

Parmi nos 35+ tutoriels, nous avons créés des tutoriels de hacking électronique spécialement édités pour ce kit.

Cliquez ici pour accéder aux tutoriels PyBoard Discovery Kit.

1 LED externe
Branchez votre première LED sur la PyBoard et contrôlez là.

8 LEDs
Contrôlez plusieurs LED pour réaliser un chenillard.

Bouton
Branchez un bouton sur votre Pyboard.

Servo Moteur
Contrôlez des servo moteurs en Micro Python. Quelques commandes pour positionner un axe sur un angle donné.

Luminosité d'une LED
Contrôlez la luminosité d'une LED ou la faire pulser avec un signal PMW.

Déparasitage d'entrée
Tutoriel qui pourquoi les boutons poussoirs parasitent vos entrées et comment y remédier.

Lecture Analogique
Réaliser une lecture analogique sur votre Pyboard pour lire la tension d'un potentiomètre.

Lire la température avec un TMP36
Mettez en pratique ce que vous avez appris sur la lecture analogique pour lire la température d'un senseur de température TMP36.

Photo-résistance
Détectez la présence ou l'absence de lumière à l'aide d'une photorésistance. Mise en pratique de la lecture analogique.

Moteur
Apprenez à utiliser un transistor P2N2222 pour commander un périphérique énergivore comme un moteur continu.

Relais
Seconde application du transistor pour commander un relais. Avec un relais, vous pourrez commander des périphériques beaucoup plus puissant.

LED RGB
Apprenez à créer des couleurs à l'aide d'une LED RGB (rouge, vert, bleu) et du signal PWM.

Piezo Buzzer
Produire des sons et des mélodies avec MicroPython PyBoard.

Contenu du kit

Le kit contient:

# data[].attributes.attachment_link.title
Kit Découverte MicroPython (PyBoard Inclus)

# data[].attributes.attachment_link.description
Kit d'apprentissage et expérimentation MicroPython PyBoard - Très complet avec documentation en ligne disponible en français. Un must pour découvrir MicroPython PyBoard.

# data[].attributes.attachment_link.description
Grâce à ce MOOC, vous pourrez rapidement programmer et construire un objet interactif après avoir acquis les connaissances de base en électronique et en développement informatique. Vous serez capable de programmer un Arduino, un petit ordinateur utilisé dans les FabLabs pour rendre les objets intelligents.

# data[].attributes.attachment_link.title
Les tutoriels du Kit ARDX accessible sur le Wiki de MCHobby

# data[].attributes.attachment_link.description
Blog sur le Raspberry Pi, Arduino, Micro-Python, la programmation et les objets connectés (IOT)

# data[].attributes.attachment_link.readable_text
MCHobby investit du temps et de l'argent dans la réalisation de traduction et/ou documentation. C'est un travail long et fastidieux réalisé dans l'esprit Open-Source... donc gratuit et librement accessible.
SI vous aimez nos traductions et documentations ALORS aidez nous à en produire plus en achetant vos produits chez MCHobby.

Introduction

Micro Python est une version rapide, optimisée et allégée du langage de programmation Python 3 ( Python.org) pour système embarqué.

PyBoard, la carte Micro Python est une petite carte électronique qui exécute Micro Python en et vous offre un système d'exploitation Python bas niveau permettant de contrôler toute sorte de projets électroniques.

Grâce au lancement de Micro Python en KickStarter, il a été possible de concevoir la carte en y incluant:

Le support de connexion Wi-Fi à l'aide du module CC3000. Micro Python incluera une bibliothèque permettant vous permettant de vous connecter via Wi-Fi. Il est donc possible d'ajouter un module CC3000. Ce module se connecte via les broches du bus SPI sur la carte Micro Python.

Le support Ethernet à l'aide d'un module WIZ820io module. Similaire au module CC3000, le module WIZ820io se branche également sur la carte micro Python via le module le bus SPI et une bibliothèque développée dans ce but.

Le support de communication sans-fil basse consommation avec le NRF24L01+ (et une bibliothèque adéquate).

Micro Python est un projet logiciel open-source (sous licence MIT) que vous pouvez utiliser dans vos propres projets.

Crédit: MicroPython micropython.org

Python est une langage de scripting vraiment très facile à apprendre, très expressif, vraiment très puissant et disposant d'une gigantesque communauté. En fonctionnant sur un microcontroleur, Micro Python permet de faire clignoter des LEDs sans aucun effort, lire des tensions, faire bouger des moteurs et servo moteurs, jouer du son, écrire/lire des données sur la carte micro SD, établir des communications sans fils (avec un module complémentaire) et devenir ce cerveau que votre robot attend désespérément. Il y a tant d'autres d'opportunité accessible à PyBoard et MicroPyhton.... c'est un choix parfait pour votre prochain projet!

Lors de la conception d'un projet électronique, tel qu'un détecteur d'intrusion or a robot intelligent, le microcontroleur est utilisé en tant que "cerveau" et prend toutes les décisions d'action et de vérifications. Un microcontroleur a typiquement besoin de faire deux choses: (1) il doit être capable d'agir au niveau matériel (dit " low level") pour commander des lumières, écran LCD, moteurs, être très réactif, etc, (2) ainsi que des opération de haut niveau (dit " high level") comme comme lire et écrire des données, images, communiquer sans fil ou disposer d'une "intelligence artificiel".

Micro Python à ceci d'extraordinaire qu'il permet le contrôle low-level et high-level en agrémentant le language Python avec de l'assembleur inline et des types natifs (comme présenté ci-dessous).

La carte Micro Python est flashée (pré-installée) avec Micro Python pour le rendre instantanément accessible aussi bien au néophyte, au débutant, développeur curieux, maker qu'à l'expert, ingénieur ou roboticien. La carte ne requière aucune installation/configuration, pas de compilateur, pas de soudure et si vous ne connaissez pas Python vous le découvrirez qu'il est très facile à apprendre.

Vous branchez votre carte PyBoard sur votre ordinateur (fonctionne sur Windows, Mac et Linux) en utilisant un cable USB. PyBoard se comporte alors comme un lecteur Flash USB.

Contrôler des servo moteurs est aussi simple que d'écrire les quelques lignes de code suivantes:

pyb.servo(1, 45) # mettre le servo 1 a 45 degres
pyb.servo(2, 90) # set servo 2 a 90 degres

Placez ce code dans un fichier texte puis copier le sur le lecteur Flash de Micro Python. Presser le bouton " Reset" (réinitialisation) de la carte et il fonctionnera! Vous pouvez également ouvrir un terminal émulateur (disponible gratuitement pour Windows, Mac et Linux) pour vous connecter sur la carte via USB et tapez ces commandes directement sur la carte (la ligne de commande Python est vraiment pratique), le moteur bougera immédiatement après que vous ayez pressé la touche Return/Entrée/Retour clavier.

Pour faire clignoter une LED une fois par seconde, vous pouvez utiliser le code suivant:

while True:  # Faire une boucle infinie
     pyb.led( True )  # allumer la LED
     pyb.delay(1000)  # Attendre 1000 millisecondes (1 seconde)
     pyb.led( False ) # eteindre la LED
     pyb.delay(1000)

Lire l'accéléromètre et afficher la valeur de l'axe-x:

accel = pyb.mma() # obtenir les donnees de l accelerometre
print( accel[0] ) # afficher la donnee de l axe-X

Vous avez à votre disposition un langage de programmation Python complet. Vous pouvez écrire des fonctions et des classes, faire créer des listes et dictionnaires, faire du traitement de chaine de caractère (les string), lire et écrire des fichiers (sur la carte SD ou la flash de stockage interne). Micro Python dispose même de fonctionnalités avancées tels que les générateurs, les closures (programiz.com), les comprehension list (fgallaire.flext.net) et gestion d'exception. Les possibilités de programmation sont infinies!

La carte dispose de nombreuses broches d'entrées/sorties que vous pouvez connecter sur d'autres circuits et vous pouvez y souder des fils pour inclure Micro Python dans vos propres projets.

La carte peut fonctionner sans PC, pour autant qu'elle soit connectée sur une source d'alimentation/accu fournissant une tension entre 3.6V et 10V.

Dans l'attente de la constitution/traduction de tutoriel en Français, vous pouvez trouver des instructions en ligne sur le site MicroPython.org ( anglais) incluant exemples et projets. Même avec la seule carte Micro Python vous pouvez déjà réaliser de chouette choses, tels que faire un enregistrement des données de l'accéléromètre, réaliser une souris USB en Python et utiliser la ligne de commande via USB série.

PyBoard et les autres cartes

Comment Micro Python se positionne t'il par rapport aux autres cartes?

Comparé à Arduino

La carte Micro Python est nettement plus puissante et plus facile à programmer. Vous n'avez pas besoin de complilateur sur votre PC.

Comparé à Raspberry-Pi

La Micro Python est moins cher, plus petite, plus simple (vous pouvez même en faire une vous même, ou modifier la conception de la carte pour qu'elle rencontre vos besoins) et PyBoard utilise moins de puissance.

Comparé à d'autres cartes

La plupart des autres cartes sont programmées en C. Le C est un langage de bas niveau et peut-être difficile à programmer correctement.

D'autre part, Python est un langage de très haut niveau, ce qui signifie que Python est plus simple, nécessite moins de code pour réaliser des tâches identique à celle programmée en C.

Logiciel Micro Python

Micro Python est évidemment une ré-écriture complète (en partant de rien) du langage de programmation Python. Il est écrit en C ANSI, proprement et inclus un parser complet, compilateur byte-code Python, une machine virtuelle, un environnement d'exécution, un garbage collector (dit 'ramasse miette' en France) et support de bibliothèque... le tout fonctionnant sur le microcontrolleur. Le compilateur peu générer du byte code ou du code machine natif (configurable par fonction en utilisant un décorateur Python). Micro Python supporte également l' inline assembler. Toutes les taches de compilations sont effectuées sur le microcontroleur... pas besoin de logiciel sur le PC.

Micro Python supporte actuellement les processeurs ARM 32-bits avec le jeu d'instruction Thumb v2, comme c'est le cas pour la gamme des microcontrôleurs Cortex-M. Micro Python a été testé sur la puce STM32F405.

Micro Python dispose des fonctionnalités suivantes:

Implémentation complète de la grammaire de Python 3 (mais pas encore toutes les bibliothèques standard de Python).

Implémentation d'un lexer (analyse syntaxique), parser, compilateur, machine virtuelle et environnement d'exécution.

Peut exécuter des fichier et dispose également d'une interface en ligne de commande (REPL ou read-evaluate-print-loop boucle-lire-évaluer-imprimer).

Le code Python est ompilé en un byte code compressé qui fonctionne sur la machine virtuelle intégrée à PyBoard.

L'utilisation de la mémoire est minimiser en stockant les objets de manière efficace. Les entiers qui tiennent sur 31-bits n'allouent pas un objet sur la heap (le tas), et ne nécessite, par conséquent, de la mémoire que sur la stack (la pile).

En utilisant les décorateurs Python, vous pouvez éventuellement compiler une fonction en core machine natif. Le code natif nécessite plus de mémoire mais fonctionne 2 fois plus vite que du byte code. De telles fonctions implémente toujours le langage Python complet.

Une fonction peu éventuellement être compilée pour utiliser des entiers natif (native integer) comme nombre à la place d'objet Python. Une telle fonction s'exécute presque aussi vite que la fonction équivalent en C et peut toujours être appelée depuis Python (et appelé du code Python). Ces fonctions peuvent être utilisées pour exécuter des procédures time-critical (dont le temps nécessaire à sont exécution est un élément critique). Ce type de fonction est bien adapté aux interruption.

Une implémentation assembleur inline permet d'avoir un accès complet sur la machine sous-jacente. Les fonctions assembleurs peuvent être appelées depuis Python comme si elles étaient des fonctions normales.

La mémoire est gérée en utilisant un garbage collector (ramasse miette) simple et rapide (fast mark-sweep). Une collecte complete nécessite moins de 4ms. De nombreuses fonction peuvent être écrites pour ne pas utiliser de mémoire sur la heap (le tas) et permettant ainsi d'éviter l'usage du Garbage Collector.

PyBoard, la carte Micro Python

La carte Micro Python (PyBoard pour les intimes) est une carte de développement électronique basée sur un microcontroleur STM32F405 qui exécute Micro Python. Ce microcontroleur est un des plus puissant disponible sur le marché et à été spécialement sélectionné parce qu'il permettrait à Micro Python de fonctionner à son plein potentiel.

Le microcontroleur est cadencé à 168MHz (fréquence d'horloge), dispose de 1Mb de Flash et de 192Kb de RAM, un très large espace mémoire pour écrire de complexes scripts Python. La carte mesure 33x40 mm comme présenté sur l'image ci-dessous.

Crédit: MicroPython micropython.org

La carte intègre une interface USB qui se présente comme un périphérique série (CDC VCP) ainsi que comme un périphérique de stockage USB amovible (MSC, l'équivalent de votre clé USB). Lorsque PyBoard est connecté sur un PC, vous pouvez ouvrir un programme de communication série (terminal telnet/minicom ou Putty) et interagir la carte par l'intermédiaire d'une ligne de commande Python. Vous pouvez également afficher des message (fonction print) et saisir des entrées puisque le périphérique série agit en tant que stdin et stdout (entrée et sortie console, standard simple hérité du monde Unix). La carte se comporte également comme un périphérique de stockage (un lecteur Flash USB) vous permettant de facilement copier vos scripts sur le système de fichier de la carte ou de la carte SD. Ces fichiers peuvent être exécutés indépendamment du PC.

Alimenté par une pile/accu, la carte est capable de compiler et exécuter des scripts Python sans besoin d'une connexion PC. Il y a un connecteur carte Micro SD pour stocker de grandes quantités de donnée, 4 LEDs, des boutons poussoirs, une horloge temps réel, un accéléromètre et 30 broches d'entrée/sortie (dite GPIO ou 'I/O'. Les broche d'I/O inclus: 5 USART (pour Port Série), 2 bus SPI, 2 bus I2C, 14 broches ADC (convertisseur Analogique->digital), 2 broches DAC (convertisseur Digital->Analogique) ainsi que 4 port pour Servo Moteurs (avec alimentation).

Il y a une broche spéciale BOOT0, qui est utilisée pour reprogrammer le microcontroleur. En connectant BOOT0 sur 3.3V (la broche juste à côté) et en réinitialisant ( reset) la carte, vous placez la carte en mode DFU " device firmware upgrade". C'est le mode USB standard qui vous permet de faire une mise-à-jour de Micro Python sur le microcontroleur en utilisant des logiciel librement disponible pour Windows, Mac et Linux). Elle vous permet également de téléverser votre propre version de Micro Python si vous désirez la modifier, voire téléverser vos propres programmes écrit directement en C.

La carte Micro Python est adapté pour tous, peu importe le niveau de connaissance en programmation ou éléectronique. Avec quelques lignes de code Python dans un fichier texte, le bédutant pourra faire clignoter les LEDs et réagir en fonction des données de l'accéléromètre, le tout sans soudure, ni connexion de composant, ni installation de logiciel sur votre l'ordinateur.

PyBoard c'est de nombreuses broches aux fonctionnalités multiples. Avec PyBoard vous avez sous la main:

30 GPIO - Broches d'entrées/sorties pouvant servir à de nombreuses applications. Avec un GPIO, vous pouvez commander des LEDs, des relais (via transistor ou UNL2803), des moteurs (via L293). Lire l'état de boutons et senseurs. Commander des périphériques tels que des écrans LCD, afficheurs graphiques, des cartes d'extension, etc.

2 bus I2C - Pour commander des périphériques à l'aide de 3 fils.

2 bus SPI

2 bus CAN

5 UARTs - Un port série c'est un outil de communication très utile... en avoir 5 c'est absolument génial.

20 PWMs - Permettant de produire des signaux permettant de contrôler des servo-moteurs ou la puissance d'une LED (voyez "[AdaFruit_PWM_Driver#C.27est_quoi_PWM c'est quoi PWM]" dans cet autre tutoriel)

16 ADC - Convertisseur Analogique->Digital permettant de lire une tension analogie (pratique pour utiliser des senseurs flex, photo-résistance, potentiomètre, etc).

2 DAC - Très rares sur les cartes de prototypages, les convertisseurs Digital->Analogique permettent de produire des tensions analogiques en sortie. Grâce à cela, vous pouvez produire divers types de signaux (en dent de scie, sinusoide, ... et même du son).

13 timers - Les timers permettent de mesurer des durées et d'exécuter du code/fonction à intervalle régulier. C'est un élément de synchronisation important lorsque l'on désire écrire des applications avancées.

16 ext int - Les interruptions externes permettent d'interrompre le programme principal pour exécuter du code (fonction d'interruption) lorsqu'une broche change d'état. Cela permet d'écrire des programmes réagissant instantanément à changement de conditions physique autour du la carte. Exemple: arrêter immédiatement des moteurs si l'arrêt d'urgence est activé.

1 RTC - L'horloge temps réel vous permet de connaître l'heure, de mesurer des laps de temps assez grand, de créer des exécutions basées sur un calendrier, de réaliser des horloges. Le RTC est un élément utile qui manque souvent dans les plateformes de prototypage (comme c'est la cas pour Raspberry, Arduino ou encore de Spark Core où le RTC n'est pas exploitée)

4 LEDs - Les LEDs/DELs sont bien pratiques pour informer l'utilisateur sur l'état du programme. En avoir sur la carte permet de tester/prototyper rapidement du code sans avoir besoin de faire des raccordements.

1 Accéléromètre - PyBoard fut conçue avec la robotique comme finalité. Du coup, Damien à intégrer un accéléromètre à même la carte. Un tel dispositif permet de mesurer les accélération (cas pratique: un smartphone qui tombe) mais surtout l'accélération terrestre G sur les 3 axes. Cette accélération terrestre responsable de la gravité est dirigée vers le centre de la terre, en mesurant cette accélération sur 3 axes, il est donc possible de déterminer la position/orientation 3D de la carte par rapport au sol (cas pratique: la rotation automatique des écrans sur un smartphone, tenue d'équilibre pour un robot bipède).

Pour les friands de détails

PyBoard sous le capot

Microcontroleur STM32F405RG (fiche technique)

CPU Cortex-M4 cadencé 168 MHz avec unité de calcul flottant à 32-bit.

1 Mb de mémoire Flash pour le stockage, 192 Kb de RAM.

Connecteur USB microB avec support logiciel USB Série, périphérique de stockage de masse USB, et USB HID (souris, clavier).

connecteur pour carte micro SD.

Accéléromètre 3-axes MMA7660 FreeScale (fiche technique). Jusqu'à 64 échantillonnages 6-bit par seconde par axe.

4 LEDs, 1 bouton Reset, un bouton utilisateur.

Un régulateur 3.3V LDO (à faible perte) de 300mA. Alimenté depuis le connecteur USB ou alimentation externe entre 3.6V et 10V.

Horloge Temps Réel (RTC) avec date et heure.

30 broches d'entrée/sortie GPIO, 28 sont tolérantes 5V (excepté en mode ADC / Analogique->Digital).

14x entrées analogiques avec résolution 12-bit, Valeur entre 0 et 4095 (ADC, Analogic to Digital Converter).

2x sorties analogiques (DAC, Digital to Analogic Converter).

Dimension de la carte: 33 x 40mm.

Poids de la carte: 6 grammes.

Connexion sur la carte: 46 trous avec empattement standard de 2.54mm.

Crédit: MicroPython micropython.org

L'interpréteur Micro Python

Micro Python est une ré-écriture complète d'un interpréteur Python spécialement, ré-écriture conduite pour fonctionner sur des systèmes MicroControleur ayant une mémoire RAM et Flash limitée. Lorsque des décisions de conceptions se présentait, la première priorité était celles permettant de minimiser l'utilisation de la RAM, puis minimisation de la taille du code, et finalement celle permettant d'augmenter la vitesse d'exécution.

Certaines caractéristiques importantes de l'implémentation de Python son reprise ci-dessous.

Suivre la grammaire de Python 3.3 ainsi que la sémantique du langage. Cela signifie que Micro Python produit un byte code équivalent (jusqu'à l'optimisation) à va version 3.3 CPython officiel.

La taille du binaire optimisé (en code machine Thumb v2) fait environ 60Kb.
Cela inclus le parser, compilateur, environnement d'exécution et garbage collector MAIS exclus tous les autre code comme le système de fichier et bibliothèques spécifiques au microcontroleur. Cette taille augmente si vous ajoutez plus de bibliothèques.

La taille de tout le code, incluant le support FAT, carte SD, USB série, périphérique de stockage USB, USB HID, Bluetooth, LCD, servo, timer fait environ 110 Kb.

La taille minimale de la RAM requise pour compiler et exécuter "print('hello world')" est d'environ 4 Kb.

La mémoire est gérée en utilisant un garbage collector (ramasse miette') rapide, non-precise, mark-sweep. Cela élimine la surcharge de code provoquée par une implémentation en "reference counting" (compteur de référence) en mémoire Flash. La taille des objet en RAM diminue par la même occasion. Avec un CPU rapide et une petite quantité de RAM, la processus de collection (garbage collection) prend moins de 4ms. La surcharge de RAM du garbage collector est de 2 bits par 32 bytes soit 1 Kb pour 128Kb de mémoire RAM utilisable.

Taille des objets int (entier): 4 bytes, stocké sur la stack (pile) ou directement dans un tuple/list/dictionnaire.

Taille des autres objets: 32 bytes, plus extra pour, par exemple, les éléments d'une liste.

Limite sur le nombre d'objets: aucune, pour autant qu'il y a assez de RAM.

La grammaire est encodée dans une table compacte en utilisant EBNF qui permet de faire une interprétation à la volée pendant la phase de parsin.

La RAM est minimisée durant la compilation en effectuant 3 passes séparée sur les mêmes structures de données.

Il y a 4 types de générateur de code (code emitters), sélectionnable à l'aide de décorateur de fonction Python:

byte code (compressé),

code natif avec type natif,

code natif avec support du langage python,

Assembleur inline assembler.

Exécution du code:

Le byte code est exécuté sur une machine virtuelle, similaire à CPython.

Le code natif ou chaque byte code est décompressé en sont équivalent 'code machine' et supporte pleinement le langage Python. Cela consomme 2 à 3 fois plus de RAM mais s'exécute aussi 2 à 3 fois plus vite que du byte code.

Le code natif avec type natif vois sont byte code décomposé en code machine et suppose que les entiers font moins de de 31 bits (ce qui permet d'utiliser des instructions machines simples pour des opérations sur les entiers et les pointeurs). Vous pouvez penser à cela comme "syntaxe Python, sémantique C". Pour les boucles effectuant des opération arithmétiques et manipulations de bit, l'exécution est presque aussi rapide qu'un programme en C.

L'emission d'assembleur inline utilise la grammaire Python mais interprète une liste d'instruction code machine. L'assembleur Inline peut être appelé depuis un code Python normal avec des entiers et pointeurs comme arguments.

Les exceptions Python sont gérées en utilisant une variante de setjmp/longjmp. Cela réduit la quantité mémoire Flash et RAM nécessaire pour implémenter les exceptions.

Une fonction (byte code, native ou assembleur inline) peut être appelé sur une interruption pour autant qu'il n'alloue pas de mémoire sur la heap (le Tas, étant donné qu'une interruption ne peut pas être appelée durant une phase de collecte garbage collecteur). Dans la pratique, cela ne représente pas une grande restriction étant donné qu'il est possible beaucoup de choses uniquement en utilisant la mémoire accessible sur la stack (la pile). Par exemple, vous pouvez faire des boucles avec while/for, réaliser des opérations arithmétiques entière et manipulations booléennes (mais pas des grands nombres), appeler d'autres fonctions, accéder et écraser des éléments d'une collection tels que bytearrays (mais pas en créer un nouveau).

Micro Python sur PC

Le langage Micro Python peut aussi être exécuté sur un PC (il a été développé sous Linux avec une machine 64-bit) et peut être utilisé comme une version légère de Python où l'économie de mémoire est important. La version PC de Micro Python (compilant du byte code) fonctionne plus rapidement que CPython dans différents benchmarks testé par Damien George, et l'option de compilation native rend Micro Python significativement plus rapide que CPython.

Vous trouverez cette version PC sur le GitHub de Micro Python.

Séquence de Boot Micro Python

Vous pouvez voir Micro Python comme un "mini système d'exploitation Python" et le processus de démarrage fonctionne comme suit:

Mise sous tension ou Reset (réinitialisation matérielle).
SI le connecteur DFU (device firmware upgrade) est actif (BOOT0 sur 3.3V) ALORS le périphérique rentre en mode DFU et vous permet ainsi de faire des mise-à-jour du binaire Micro Python ou téléverser vos propres programmes C/C++.

SINON la carte entre en mode "boot" et la LED boot s'allume.

Le mode Boot...

Vérifie la présence d'un système de fichier dans la mémoire Flash.
SI non existante ou corrompue ALORS crée un nouveau système de fichier est créé.

Vérifie la présence de /boot.py.
SI non existant ALORS un tout nouveau fichier est boot.py est créé.

Exécute /boot.py pour configuration USB et autres paramètres de bas-niveau qui ne peuvent pas être modifiés sans un Reset.

Initialise l'interface USB, en fonction de la configuration de boot.py. Par défaut, c'est un CDC VCP (virtual communications port, pour rediriger stdio) et MSD (mass storage device, périphérique de stockage de masse pour la Flash et carte SD).
Le MSD permet à un PC Linux/Mac/Windows d'accéder au système de fichier de la Flash et de la carte SD comme s'il s'agissait d'un lecteur USB. De cette façon, vous pouvez facilement copier des scripts Python sur la carte... ou placer et récupérer des fichiers.

La séquence de Boot terminée avec succès, la LED boot s'éteint.

Après la séquence de boot:

Le script Python principal (nommé "main" en anglais) est exécuté s'il existe.
Par défaut, c'est le fichier /src/main.py. Il s'agit de votre programme Python principal et il peut faire tout ce que vous voulez!

SI le script principal n'existe pas (ou s'il est terminé)
ALORS la carte rentre en mode REPL (read-evaluate-print-loop, boucle-lecture-evaluation-affichage). Cela vous offre un Interpréteur Python Standard via la connexion USB série.
Sortir de ce mode exécutera une reset logiciel (soft-reset) de la carte.

Licence Micro Python

Micro Python rst sous licence MIT.

J'ai repris le texte de licence tel que disponible sur le site MicroPython.org ( docs.micropython.org/en/latest/license.html)

The MIT License (MIT)

Copyright (c) 2013, 2014 Damien P. George, and others

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the
Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Vous pouvez vous procurer une carte Micro Python PyBoard chez MCHobby (vendus uniquement sur stock)!
Source: Micro Python Python for microcontrollers écrit par/written by Damien P.George
Traduit par Meurisse D. pour MCHobby.be - Translated by Meurisse D. for MCHobby.be

Traduit avec l'autorisation de micropython.org - Translated with the authorisation of micropython.org
Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : " Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants " avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.
L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.

# data[].attributes.attachment_link.description
MCHobby investit du temps et de l'argent dans la réalisation de traduction et/ou documentation. C'est un travail long et fastidieux réalisé dans l'esprit Open-Source... donc gratuit et librement accessible. SI vous aimez nos traductions et documentations ALORS aidez nous à en produire plus en achetant vos produits chez MCHobby.

# data[].attributes.attachment_link.description
Description 37 modules inclus 36 leçons dans le manuel de l’utilisateur de 100 pages Un schéma de chaque module est offert afin que vous puissiez comprendre en profondeur le fonctionnement du module Arduino Nano non inclus Ce Kit 37 Capteurs pour Arduino v2 est une révision qui se base sur la versio…

# data[].attributes.attachment_link.readable_text
Partie 1 : Le code et le schéma

Comme d'habitude, je vais commencer par donner les indications pour réaliser tout de suite le circuit, les explications viendront dans un deuxième temps !

#include <Servo.h> //On commence par inclure la bibliothèque de commande des servo

const int potentiometre = 0; // Initialisation du potentiomètre
Servo monServo; // Initialisation du servo-moteur

void setup()
{
    monServo.attach(9); // on va commander l'angle du servo-moteur avec la pin 9
    monServo.write(0); // on place le servo à 0 degré au demarrage

}

void loop()
{
    int val = analogRead(potentiometre); // lecture de la valeur du potentiometre, comprise entre 0 et 1024
    int angle = val / 5.7; // On converti cette valeur en degrés entre 0 et 180.
    monServo.write(angle); // On envoi la commande de l'angle au servo-moteur
    delay(100); // petit temps de pause pour laisser le moteur respirer
}

Et voici le schéma correspondant :

Dans la vraie vie, ça donne ça :

Si votre servo-moteur fait n'importe quoi, il se peut que l'Arduino ne puisse pas fournir assez de courant pour l'alimenter.
Une première solution consiste à ajouter une capacité (470uF ou plus) entre les ports GND et 5V de la breadboard (avec la branche la plus longue sur le 5V). Cette capacité va servir de réservoir d'energie pour le moteur.
Si cela ne fonctionne toujours pas, il serait bon d'envisager une alimentation externe car le régulateur de l'Arduino n'est pas fait pour délivrer trop de courant, vous risqueriez de le cramer...

Partie 2 : explications

Les servo-moteurs sont des moteurs un peu spéciaux qui diffèrent des moteurs à courant continu classiques par les caractéristiques suivantes :

Selon les modèles ils ne peuvent tourner que de 90, 180 ou 360 degrés. On parle de "débattement"

On peut définir précisément de combien de degrés ils vont tourner. On dit qu'ils sont "asservis en position angulaire"

Ils est impossible de régler leur vitesse de rotation (sauf pour les modèles les plus chers), qui est relativement faible et avec un couple supérieur aux moteurs classiques de la même taille.

On les utilise beaucoup dans le modélisme. Ils permettent de "commander" des petites rotations de façon précise. Par exemple piloter les roues d'une voiture, les gouvernails d'un avion ou encore commander un bras distributeur de bonbons skittles:

Le servo-moteur est branché par 3 fils : 2 pour l'alimentation, 1 pour la commande de l'angle.
Le fil rouge correspond à l'alimentation positive (5V).
Le fil noir ou marron correspond à la masse (0V).
Le fil orange ou jaune ou blanc correspond au signal de commande.

Je n'expliquerai pas dans ce tutoriel son fonctionnement interne mais uniquement comment l'utiliser. Pour ceux que cela intéresse, je conseille ce super article du blog d'Eskimon.
La commande du servo moteur est grandement facilitée par la bibliothèque "Servo" de l'Arduino que j'importe au début du programme et qui nous permet de commander directement le moteur sans comprendre son fonctionnement.
Dans le programme j'ai donné comme nom "monServo" au moteur, mais on peut décider de l'appeler autrement (par exemple : "servoGouvernail", "myServo" ...).
Dans la partie setup() du programme qui sert à l'initialisation de l'Arduino, on choisit le port de sortie qui va commander le servo-moteur, par exemple le port numero 9. Il faudra par la suite relier le cable orange du moteur au port numéro 9.
La technique de commande est la même que celle utilisée dans le tutoriel sur la commande d'une LED RGB et consiste à lire la valeur d'une resistance variable (ou potentiomètre) grâce à la fonction analogRead, puis à convertir cette donnée en degrés.
Enfin, nous utilisons la fonction .write de la bibliothèque Servo pour envoyer la consigne au moteur. Cette fonction ne prend qu'un seul argument : la position en degré que l'on souhaite que le moteur prenne.
On va donc pouvoir directement interagir avec le moteur en tournant le potentiomètre, l'Arduino se chargera de tout le reste !

Puissance du moteur :

Voici quelques indications pour savoir quelle va être le couple ou encore "la force" de votre moteur.
Si vous tapez le nom de votre servo-moteur sur internet, vous devriez retrouver facilement sa "data-sheet" qui devrait ressembler à cela

J'ai pris celle-ci totalement au hasard à titre d'exemple. Pour connaitre la force de votre moteur, il faut s'intéresser à la donnée "Torque" ou couple en français. Cette donnée en kg.cm vous indique le poids maximal d'un objet que vous pouvez suspendre à 1cm de l'axe du moteur. A x centimètres de l'axe, il faudra diviser cette valeur par x (et oui, c'est toujours pus difficile de porter les objets à bout de bras ...).
Par exemple, si le bras de votre moteur fait 10cm, il ne supportera pas plus de 0.18 kg de charge, autrement dit 180 grammes.
Au passage, vous pouvez aussi apercevoir la vitesse de rotation du moteur : 0.60 secondes pour réaliser un tour complet.

Partie 3 : pour s'entrainer

Pour vous entrainez vous pouvez :

Faire une micro-horloge qui se décale de 6 degrés toutes les secondes en utilisant la fonction delay(1000)

Faire une mini roue de la fortune en utilisant la fonction random(0, 180) qui donne une valeur au hasard entre 0 et 180.

Faire un système qui remonte votre sachet de thé après 3 minutes d'infusion

Et n'hésitez pas à envoyer des photos de vos réalisations en cliquant sur "je l'ai fait" ou à me poser des questions en commentaire :)

A bientôt !

# data[].attributes.attachment_link.keywords[]
maker faire soi-même bricoler tutoriels systèmed diy comment faire geek

# data[].attributes.attachment_link.description
Tutoriel pour apprendre à commander un servo-moteur avec un Arduino et un potentiomètre, comprendre les bases de son fonctionnement et ses applications. - La Fabrique DIY, premier site collaboratif de tutoriels DIY

# data[].attributes.attachment_link.readable_text
Une riche collection de capteurs variés et universel, utilisables directement avec les cartes Arduino (pas de soudage requis, compatibilité broche à broche directe). Avec cet ensemble bien conçu, vous mesurez tout ce que vous voulez à l'aide d'Arduino. Parmi les 35 composants, livrés dans une boîte plastique pratique, en plus des capteurs habituels vous trouverez notamment un module à LED clignotant automatique, plusieurs modules à LED bicolores ou tricolores, un détecteur de battement cardiaque, un détecteur de chocs, un interrupteur à clé, un capteur laser, un manche de commande X/Y et bien davantage.

Contenu

1x Joystick

1x Relay

1x Big Sound

1x Small Sound

1x Tracking

1x Avoidance

1x Flame

1x Linear Hall Sensor

1x Touch

1x Digital Temperature

1x Buzzer

1x Passive Buzzer

1x RGB LED

1x SMD RGB

1x Two Color (5 mm)

1x Mini Two Color (3 mm)

1x Reed Switch

1x Mini Reed Switch

1x Heartbeat

1x 7 Color Flash

1x Laser Emitter

1x PCB mounted push button

1x Shock, a rolling-ball type Tilt Switch

1x Rotary Encoders

1x Rolling ball Tilt Switch

1x Photoresistor

1x Temp and Humidity

1x Analog Hall

1x Hall Magnetic

1x DS18B20 Temp

1x Analog Temp

1x IR Emission

1x IR Receiver

1x Tap Module

1x Light Blocking

Pour cause de non conformité, les interrupteurs au mercure ont été retirés des kits de capteurs.

Télechargements

# data[].attributes.attachment_link.description
Une riche collection de capteurs variés et universel, utilisables directement avec les cartes Arduino (pas de soudage requis, compatibilité broche à broche directe).

# data[].attributes.attachment_link.readable_text
Le but de ce tutoriel est de répertorier les moyens de faire communiquer le monde extérieur avec un micro-contrôleur (Arduino, Raspberry...), un mini dictionnaire des capteurs en quelques sortes.
Si vous voyez qu'il manque un capteur, merci de l'ajouter en commentaire :)
Voici une première série de capteurs pour mesurer des variables physiques dans un environnement : Pression, température, gaz ...

Capteur de flamme (flame sensor): Très sensible aux rayons infrarouges de 750 à 1100 nm, le capteur de flamme permet de détecter une flamme devant lui. Pratique pour les applications de sécurité par exemple. démo.

Capteur d'altitude et de pression (Altitude/Pressure sensor): Permet de connaitre la pression ambiante et l'altitude. Ce type de capteur permet également de calculer la température.

Capteur de son (sound sensor): Permet d'obtenir une sortie binaire pour savoir si un son est présent ou non et d'analyser son amplitude. démo.

Thermomètre infrarouge (infrared thermometer): Permet de déterminer la température d'un corps sans le toucher. Exemple d'utilisation : applications de santé, détection de mouvements ... démo.

Capteur de lumière RGB (RGB sensor): Détecte la couleur des objets. Multiples applications de reconnaissances et de commande. Exemple : un robot qui réagit en fonction de la couleur des objets qu'on lui présente. démo.

Photorésistance (photocell): Permet de détecter la présence de lumière. Sa résistance est proportionnelle à la quantité de lumière qu'elle reçoit. Ce composant à l'avantage de ne couter presque rien et est présent partout : appareil photo, smartphone .... démo.

Capteur d'humidité des sols (moisture sensor): La conductivité entre les deux broches de ces capteurs est proportionnelle à l'humidité des sols dans lesquels on les plante. Pratique pour savoir quand arroser ses plantes :) démo.

Capteur UV (UV sensor): Fonctionne de la même manière que le capteur RGB mais pour la lumière ultraviollette. Pour savoir quand mettre de la crème solaire ou de la lumière artificielle sur ses plantes. démo.

Capteurs de gaz (gas sensor): Au pluriel car il existe beaucoup de capteurs différents pour les gaz : Methane, Butane, LPG, Ethanol, fumée, hydrogène, monoxyde de carbone, CO2, Ozone, qualité de l'air ... Les plus connus sont les MQ. démo

Thermistance (thermistor): Voila un autre composant qui ne coûte presque rien et qui est très pratique. La thermistance est simplement une resistance qui dépend de la température et qui donc permet de la déterminer facilement. démo

Compteur géger (geger sensor): Permet de calculer les rayonnements ionisants (alpha, beta, gamma, rayon X), en cas de catastrophe nucléaire, par exemple ...

J'ai décidé de regrouper les capteurs liés au mouvement dans une section à part car il y en a beaucoup !

Accéléromètre (accelerometer): Les accéléromètres sont souvent une combinaison de gyroscopes (qui permettent de détecter la rotation) et d'accéléromètres (qui permettent de détecter l'accélération). Ils ont plus ou moins de "degrés de liberté" ce qui définit le nombre de directions pour lesquelles ils peuvent détecter une accélération. Ils sont utilisés pour de multiples applications: construire un objet qui s'équilibre seul (type segway), controller des objets avec des mouvements (des gants qui font de la musique), calculer une vitesse .... démo.

Capteur de flexion (bend/flex sensor): La resistance de ces capteurs augmentent avec leur flexion. Permet de détecter l'ouverture d'une porte, un mouvement, la tension d'un arc ... démo.

Capteur de vibrations Piezoélectriques (piezo vibration sensor):
Les capteurs de vibrations sont en général des capteurs piezoélectriques plus ou moins sensibles. Le modèle sur la photo est accompagné d'une petite masse pour augmenter sa sensibilité. Les capteurs piezo sont utilisés très souvent, pour détecter une vibration, une balle qui rebondit, un impact, quelqu'un qui frappe à une porte... démo.

Capteur d'obstacles et de proximité (obstacle sensor):
Ce capteur émet en permanence une lumière infrarouge et analyse la lumière renvoyée par les objets. Lorsqu'un objet se rapproche, il renvoie plus de lumière et le capteur le détecte.
Avec ce petit capteur vous pouvez diriger un robot, donner des croquettes à votre chien quand il point le bout de sa truffe...

Capteur d'angle (angle sensor):
Ne payez pas ce capteur plus de 1€, il s'agit en réalité d'un potentiomètre... Il permet néanmoins de savoir précisément un angle en calculant sa résistance. C'est le principe de tous les boutons qui se tournent !

Voici une dernière section qui regroupe les capteurs qui nécessitent une action humaine et ceux que je n'ai pas réussi à placer dans les sections précédentes.

Module RFID (RFID reader):
Traçabilité, antivols, carte d'accès...Les tags RFID sont partout !
L'identification par radio fréquence consiste à échanger des données à très courte distance entre un lecteur et un tag RFID. Si ils sont autant utilisés, c'est notamment parce que seul le lecteur a besoin d'une source d'énergie pour fonctionner : le lecteur est composé d'un bobinage qui va générer un champ magnétique et alimenter le tag par induction. Chaque tag possède une micro puce radio capable d'émettre un numéro d'identification UID unique ainsi qu'une petite mémoire de quelques ko.
Le module le plus utilisé est le RC 522 car il est très peu cher. Il existe de super librairies qui permettent de lire facilement ces tags avec un micro-controlleur. démo.

Capteur capacitif (capacitive sensor):
Ce capteur existe sous plusieurs formats différents, plus ou moins chers. Le plus connu est peut-être le "Makey Makey", mais il existe aussi des petits modules ou encore des librairies ( comme capacitiveSensor pour Arduino) qui permettent de transformer n'importe quel pin en capteur capacitif. Les capteurs capacitifs sont aussi appellés capteurs "tactiles". Ils permettent de detecter si une personne touche un objet en mesurant la capacitance d'une électrode. démo.

Ecran tactile (touch screen):
Ce type d'écran s'utilise plutôt avec les raspberry étant donné que l'interaction avec un Arduino est assez limitée... Ils permettent de faire l'économie du clavier et de la souris et de rendre votre raspberry plus mobile ! démo.

Voilà j'espère que ce petit article vous donnera des idées ! Je compte sur vous pour contribuer et me suggérer des améliorations !!!

A bientôt

# data[].attributes.attachment_link.keywords[]
maker faire soi-même bricoler tutoriels systèmed diy comment faire geek

# data[].attributes.attachment_link.description
Liste exhaustive des capteurs Arduinos et Raspberry and co : capteurs ultrason, infrarouges, pression, RGB, UV, capteur de gaz, de pluie , de température, accéléromètre, capteur piezo, capteur PIR, interrupteur tilt, cellule de charge, détecteur à effet hall, transducteur ultrason.... - La Fabrique DIY, premier site collaboratif de tutoriels DIY

# data[].attributes.attachment_link.readable_text
Bonne année à tous (mieux vaut tard que jamais :). Pour commencer cette année, un petit article sur le relevé automatique de la consommation d'eau. Le montage utilise un compteur d'eau banal du commerce (sans capteur donc) et ne nécessite pas son démontage.

[adsGrandRectangleTexte]

Relever sa consommation d'eau : les différentes solutions

Pour faire du relevé de compteurs d'eau, il n'y a pas 36 solutions. Il faut que le compteur soit équipé d'un capteur.

Les solutions commerciales, " plug&play ", fiables ... et pas trop bon marché

Il existe des compteurs avec une sortie pour un capteur à impulsion? J'en possède un de la marque Sappel, on peut lui ajouter un module nommé " Pulsar " mais outre le compteur qui coute ~40€ le module capteur coute lui ~80€ ... 120€ pour avoir un retour de consommation d'eau, autant dire que c'est un investissement long terme ... d'autant plus si l'on souhaite domotiser deux compteurs (eau froide et eau chaude).
Il en existe d'autres, le compteur d'eau ci-dessous avec sortie impulsion semble pas mal utilisé :

On le trouve chez planète domotique par exemple : http://www.planete-domotique.com/energie/consommation-d-eau/compteur-d-eau-froide-avec-sortie-impulsion-1-imp-1-litre.html. Coté prix c'est mieux mais on va faire mieux 🙂

La solution du pauvre, play&plug ;), aussi fiables et pas chères !

Comme d'habitude je suis parti sur une solution la moins chère possible et sans sacrifier la fiabilité.

Domotisons un compteur d'eau classique

Là aussi, il existe plusieurs solutions. Il y a des compteurs à roues, comme celui ci:

On peut les démonter et placer un petit aimant sur l'aiguille des litres puis placer un capteur, genre capteur d'ouverture de porte, dessus. A chaque tour, le capteur renvoie un changement de statut. Vous trouverez des infos sur ce type de montage ici : http://www.macoda.com/index.php/Montage:Compteur_eau_DS2423

Je ne voulais pas démonter mon compteur et j'ai opté pour une autre solution : la lumière.

Montage à base d'arduino et d'interrupteur optique

J'ai domotiser deux compteurs, celui de marque Sappel ainsi qu'un deuxième pour l'eau chaude de marque itron que l'on trouve à 20€ en GSB. J'ai choisi ces deux compteurs d'eau car il ont en commun de posséder un demi disque réfléchissant couleur métal (cf flèche rouge) qui fait un tour à chaque litre consommé :

L'idée est donc de trouver un capteur capable de détecter ce disque. J'ai choisi un CNY70. C'est un capteur de réflexion aussi appelé " interrupteur optique".
Pour l'histoire, les capteurs de réflexions sont très présent en robotique. On peut utiliser notamment le CNY70 pour réaliser un suiveur de ligne. Il va permettre de différencier deux surfaces ayant une réflexion différente (la ligne noire du circuit et le blanc de la piste autour). Dans notre cas le demi disque réfléchissant.

Vous pouvez vous en procurer dans tous les magasins en ligne d'électronique aux alentours de 1€ ou directement chez le fabricant sous forme de sample (gratuit :).

Fonctionnement du CNY70 :

Il possède un émetteur et un récepteur infrarouge accordés sur la même longueur d'onde.
L'émetteur est une diode infrarouge et le récepteur est un phototransistor. La diode émet de la lumière IR en direction du disque. Si le capteur se trouve au dessus d'un objet de couleur claire, la lumière se reflète et vient frapper le phototransistor qui devient passant. Si on le connecte sur une pin digital de l'arduino, celle-ci passe à 1 lorsque quelque chose est détecté, sinon 0.

Pour connecter le capteur à l'arduino j'ai utilisé le schéma suivant (attention à la polarité, j'ai grillé bêtement la diode infrarouge sur un cny70) :

le schéma d'origine : http://www.flickr.com/photos/igorgm/2486110065/

Les tests

L'arduino est maintenant capable de recevoir les informations du capteur CNY70.

Lors de mes premiers tests, le capteur était collé directement contre le compteur et il renvoyait toujours 1 (la lumière était réfléchie que le disque soit en face ou pas).
Il est donc préférable d'éloigner le capteur de quelque cm pour qu'il soit moins sensible. Pour ce faire, je l'ai enfermer dans un petit tube PVC (type gaine d'électricité rigide) d'un diamètre équivalent à celui du demi disque. J'ai ensuite coller ce dernier sur le compteur, en face du demi disque, avec un adhésif bien costaud (le résultat fait un peu bidouille peu être, l'idée c'est qu'il tienne bien et je suis sûr que certains feront bien mieux :).

Après quelques tests on trouve la distance adéquate (1 à 2cm) pour que la lumière soit réfléchie par le disque et pas par le fond.

Pour effectuer ces tests et trouver la bonne position du capteur, voici un stetch tout simple qui permet d'allumer la LED de la pin 13 de l'arduino lorsque le CNY70 détecte un objet :

#define LED 13
#define IN 3

volatile uint8_t state = LOW;

void cny70_onRising(void)
{
    // bascule l'état de la led
    state = !state;

    Serial.print(state);
    Serial.println(" detected");
}

void setup ()
{
    Serial.begin(9600);
    Serial.println("CNY70 test");

    pinMode(IN, INPUT);
    pinMode(LED, OUTPUT);

    // Attache une interruption sur changement de valeur (pin 3)
    attachInterrupt(1, cny70_onRising, CHANGE);
}

void loop ()
{
  digitalWrite(LED, state);
}

Une fois la bonne configuration trouvée, vous pouvez fixer le CNY70 sur le compteur et vous aurez un retour à chaque ½ litre consommé (½ litre à chaque changement de valeur).

Ajoutons un peu d'xPL sur tout ça pour remonter les informations au serveur domotique

Il nous reste maintenant à propager l'information sur le réseau. Comme d'habitude, j'utilise le protocole xPL pour intégrer mon nouveau capteur à mon réseau domotique. Et je fais un peu de promo pour la librairie xPL.Arduino au passage 😉 voici le sketch final :

#include <xPL.h>
#include <EtherCard.h>

#define IN 3

volatile uint8_t state = LOW;

byte Ethernet::buffer[XPL_MESSAGE_BUFFER_MAX];
xPL xpl;

// Init du serveur HTTP
uint8_t mymac[6] = { 0x54,0x55,0x58,0x10,0x00,0x11 };
uint8_t myip[4] = { 192,168,1,136 };
uint8_t gwip[4] = { 192,168,1,1};

// Ethercard seems to only send broadcast on this addr
// if using xpl-perl, don't forget to add "--define broadcast=0.0.0.0" to the xpl-hub
uint8_t broadcast[4] = { 255,255,255,255};

void SendUdPMessage(char *buffer)
{
    ether.sendUdp (buffer, strlen(buffer), xpl.udp_port, broadcast, xpl.udp_port);
}

void cny70_onRising(void)
{
    // bascule l'état de la led
    state = !state;

    // Un message xPL est remonté à chaque front montant (un litre)
    // On peut supprimer la condition pour envoyer un message tous les 1/2 litre
    if(state)
    {
      xPL_Message msg;

      msg.hop = 1;
      msg.type = XPL_TRIG;

      msg.SetTarget_P(PSTR("*"));
      msg.SetSchema_P(PSTR("sensor"), PSTR("basic"));

      msg.AddCommand_P(PSTR("device"),PSTR("Eau"));
      msg.AddCommand_P(PSTR("type"),PSTR("output"));
      msg.AddCommand_P(PSTR("current"),PSTR("HIGH"));

      xpl.SendMessage(&msg);
    }

    Serial.print(state);
    Serial.println(" detected");
}

void setup ()
{
    Serial.begin(9600);
    Serial.println("CNY70 test");

    // decommenter pour un mega et commenter la ligne en dessous
    // ether.begin(sizeof Ethernet::buffer, mymac);
    ether.begin(sizeof Ethernet::buffer, mymac, 10);

    ether.staticSetup(myip, gwip);

    xpl.SendExternal = &SendUdPMessage;  // pointer to the send callback
    xpl.SetSource_P(PSTR("xpl"), PSTR("arduino"), PSTR("CNY70Test")); // parameters for hearbeat message

    pinMode(IN, INPUT);

    // Attache une interruption sur changement de valeur (pin 3)
    attachInterrupt(1, cny70_onRising, CHANGE);
}

void loop ()
{
}

Précision / Fiabilité

Concernant la précision du système, Je l'ai utilisé sur un an et la précision était vraiment bonne. Sur les les 14000 premiers litres (env deux mois) j'ai eu un écart de 4 litres soit moins de 0.1% d'erreur.

Relever sa consommation d'eau chaude, l'astuce à 2 balle

Histoire de gagner 10€ et se dire qu'on est super malin ..., pour la consommation d'eau chaude, plutôt que d'acheter un compteur pour eau chaude souvent plus cher, vous pouvez prendre un compteur d'eau froide et le placer à l'entrée du ballon d'eau chaude. Tout ce qui sort du ballon sera forcement entré en passant par le compteur, voila ça c'est fait 🙂

[adsGrandRectangleHTexte]

Conclusion

Le sketch est assez simple, il remonte sur le réseau en xPL chaque litre consommé, charge à vous d'en faire ce que vous voulez. Pour ma part, mon serveur log chaque litre en base, ensuite j'ai des scripts qui génère des graphs et agrège les données par heure/jour/mois pour limiter la taille en base.

On pourrait aussi ne pas envoyer un message à chaque litre mais stoker le total sur l'arduino et envoyer un rapport une fois pas jour par exemple ou à la demande. Pour plus de souplesse et facilité de maintenance, je préfère garder sur les arduino une logique très simple et centraliser l'intelligence.

Le prochain article parlera du relevé de la consommation électrique sur un vieux compteur à roue (et oui malheureusement ça existe encore) sans pince ampèremétrique mais basé sur ce même montage. Si vous voyez des améliorations ou d'autres montages possibles avec ce type de capteurs, n'hésitez pas à les partager!

# data[].attributes.attachment_link.title
Relever sa consommation d'eau à l'aide d'un arduino | Connecting Stuff

# data[].attributes.attachment_link.description
Réalisation d'un compteur d'eau avec capteur pour suivre sa consommation.

# data[].attributes.attachment_link.description
contient tous nos outils et permet la programmation des cartes Arduino , D1 & D1R32 . C'est la version la plus complète mais aussi la plus lourde.

# data[].attributes.attachment_link.title
GoTronic | Robotique et composants électroniques

# data[].attributes.attachment_link.description
Tous vos composants électroniques, interfaces, pièces détachées robotique, alarmes et outillage pour professionnels et particuliers ! GoTronic, plus de 25 ans d'expérience. Livraison rapide dans toute la France.