# data[].attributes.body
Retro-ingenierie : Formuler le code à base de l'observation du comportement de la boite (GIF pour en ligne)

# data[].attributes.attachment_link.readable_text
Une boite mystérieuse, qui va nous permettre d'apprendre les bases de la programmation de cartes Arduino.

Auteur Benjamin Gutjahr | Dernière modification 4/12/2020 par Julienrat

Licence : Attribution (CC-BY)

Introduction

L'objectif de ce tutoriel à destination des animateurs, des enseignants et des curieux, est trouver des pistes pour initier des jeunes et/ou des adultes à Arduino en privilégiant une démarche expérimentale.

Étape 1 - Préparez votre matériel

Rassemblez votre matériel.

Installez le logiciel Arduino sur votre ordinateur. Installer l'environnement Arduino sur votre système

Trouvez une boite en carton de taille minimale 2,5x9x6,5 cm (équivalent d'une boite de jeu de 64 cartes) ou fabriquez-la vous-même en vous aidant si vous le souhaitez de ce site internet pour fabriquer votre propre patron.

Étape 2 - Fabriquez votre boite noire

Réaliser le montage indiqué sur le schéma.

Attention à la façon dont vous positionnez votre LED. Il y a 2 pôles sur une LED, l'anode et la cathode (cf. schéma). L'anode doit être insérée dans la porte 13, la cathode sur la terre ("ground" en anglais, abrégé gnd).

Connectez la led à la résistance de 220 Ohms puis le tout à l'arduino en broche 13.

Connecter la carte à un ordinateur.

Ouvrez le logiciel Arduino et faites clignoter la LED en chargeant l'exemple situé dans Fichier>Exemples>01.Basics>Blink.

Vous pouvez si vous le souhaitez connecter votre boite noire à une alimentation externe (explications dans un prochain tutoriel).

Étape 3 - Faire découvrir et tester cette boite noire à votre public

Que fait-elle? Quelles actions se produisent? De quoi a-t-elle besoin pour fonctionner? Pourrait-on lui faire faire d'autres actions?

En se posant toutes ses questions, en formulant des hypothèses et les vérifiant, les personnes qui vivront cette animation vont progressivement découvrir les bases de la programmation avec Arduino.

Observations : que voit-on ?

La boite s'allume et s'éteint... elle clignote.

Mais comment fonctionne-t-elle?

Applications : dans la vie de tous les jours

Cette séquence pourrait s'apparenter à du reverse engineering ou rétro-ingénierie, discipline cherchant à analyser le fonctionnement d'un objet physique, électronique ou informatique afin de :

- comprendre le fonctionnement de cet objet, pour être en mesure de l'utiliser correctement, de le modifier, ou encore de s'assurer de son bon fonctionnement ;

- fabriquer une copie de cet objet alors qu'on ne peut en obtenir ni les plans ni les méthodes de fabrication (activité généralement illégale sur un plan juridique) ;

- créer un nouvel objet ayant des fonctionnalités identiques à l'objet de départ, sans violer de brevet ;

- analyser un objet produit par un concurrent, soit dans le cadre d'une activité de veille concurrentielle soit pour détecter d'éventuelles violations de brevets.

Suivant la nature de l'objet et l'objectif, différentes méthodes et techniques sont utilisées. Pour des objets physiques, il est possible de démonter le système jusqu'à un certain point pour en analyser les constituants. En électronique et en informatique, la démarche peut être celle de l'étude d'une boîte noire : on isole l'objet à étudier, on détermine les entrées et les sorties actives. On essaie ensuite de déterminer la réponse du système en fonction des variations du ou des signaux en entrée.

(Source: Wikipédia)

Éléments pédagogiques

Objectifs pédagogiques

- S'initier à la rétro-ingénierie

- Comprendre les bases de la programmation avec Arduino

Pistes pour animer l'expérience

Approche dite de "rétro-ingénierie"

Commencer par montrer aux enfants cette fameuse boîte noire, et discuter autour de cette curieuse invention.

- Que fait cette boite ?

les réponses des enfants :

- "Cette boite s'allume !"

- "ah ! elle s'éteint"

- "oh il y a une prise"

À ce moment, nous avons commencer à classer les propositions des enfants quand au fonctionnement de celle-ci et échafauder un semblant de programme, à haute voix, puis sur papier. La boite s'allume → La boite attend → La boite s'allume → La boite attend ...

2. Découverte du code

À la fin de cette première partie, les enfants ont construit le code de la boîte sur papier, et ont compris que cette-ci se branchait sur un ordinateur.

Il est temps de hacker cette boîte grâce au code !

Arrivés sur les ordinateurs préparés à l'avance, les enfants découvrent le code sur le logiciel Arduino. Ils doivent alors rapprocher le code qu'ils ont produit et celui présenté sur l'ordinateur.

3. Hacking du code

Après avoir compris les bases du code, les jeunes peuvent aller plus loin et répondre à ces défis:

- faire clignoter de plus en plus vite la lumière

- allumer en continu la lumière

- l'éteindre

- coder le message "SOS" en code morse

- faire clignoter une 2nd LED en la brochant sur la broche 12

Sources et ressources

- La page de l'ancien wikidébrouillard dédiée à cette curieuse invention: http://ancien.wikidebrouillard.org/index.php?title=Animer_une_premiere_s%C3%A9quence_Arduino_avec_des_enfants

- Bartmann, E. (2015). Le grand livre d'Arduino. Editions Eyrolles.

- Le livre des projets Arduino. Editions Arduino AG.

Dernière modification 4/12/2020 par user:Julienrat.

# data[].attributes.attachment_link.title
Initier des jeunes à Arduino: la boite noire

# data[].attributes.attachment_link.description
Une boite mystérieuse, qui va nous permettre d'apprendre les bases de la programmation de cartes Arduino.

# data[].attributes.body
Necessite un compte

Possibilité de simuler un arduino, avec code en block et en texte

Banque d'exemples existante

# data[].attributes.body
Identifier des composants, et leurs usages dans nos appareils du quotidien.

# data[].attributes.headline
Créer le code blink sur tinkercad (Block)

# data[].attributes.subject
Créer le code blink sur tinkercad (Block)

# data[].attributes.body
Avec les branchements déjà fait (sur ce lien)

Etape 2 : Modification du branchement de la LED

Etape 3 : Ajout d'une seconde LED

Etape 4 : Création feu rouge

# data[].attributes.attachment_link.readable_text
Jouez au pong en 1D ! Renvoyez-vous la led avant qu'elle n'atteigne l'extrémité du ruban.

Auteur PaulineB | Dernière modification 9/02/2023 par ZAB

Licence : Attribution (CC-BY)

Tutoriel documenté par Henri Giacomel, Antoine zabern et Pauline Bleunven à Nantes en Décembre 2019.

Étape 1 - Réunissez le matériel

Les indispensables matériel :

- Arduino ( Nano, micro, uno...peu importe)

Les branchements se basent sur la disposition du NANO

- Boutons arcades

- Guirlande WS2812 - 5Volt de 40 leds

Il existe plusieurs "densités" de leds ( 144 leds /mètres , 60 leds/m, 30 leds /m => à vous de choisir et de découper votre longueur)

- Un cable USB pour alimenter et programmer l'arduino

- Des petits fils électriques de récupération ( vieille souris, vieux cables usb...)

D'autres options matériels sont possibles aux étapes bonus, à la fin du tutoriel (comme la planche de prototypage ou l'interrupteur )

- Fer à souder et étain

- Pince à dénuder ou ciseaux

- Scotch et colle chaude pour fixation/sécurisation des branchements

Étape 2 - Préparer les boutons

Pour faciliter les futurs branchement, nous soudons sur les embouts du bouton.

prévoir une longueur de câble suffisante selon la construction

Étape 3 - Préparer les rubans LED

Nous avons besoin d' un ruban de 40 Leds

Pour chacun des trois rubans nous soudons trois câbles (rouge sur 5V/VCC, noir sur la masse/GND, plus une autre couleur pour l'entrée digitale [le programme]), que nous avons précédemment découpés et dénudés, à l'une des extrémités du ruban.

Attention au sens du courant : souder dans le sens de la flèche (voir photo)

Attention, le tout est fragile. Manipulez avec précautions et pensez à sécuriser avec du scotch ( Voir photo)

Étape 4 - Le branchement

Voici le branchement pour que votre pong fonctionne.

La guirlande possède 3 branchements

- GND, soit la masse, le négatif [NOIR]

- DO, soit digital output, soit l'entrée du programme, des données [VERT]

- 5V, soit l'alimentation, soit le pôle positif [ROUGE]

Les Bouton possèdent 2 branchement. Peu importe le coté, mais chaque bouton doit avoir deux branchement :

- GND , soit la terre, le négatif [NOIR]

- DI, soit digital entry, soit l'entrée du programme, des données [JAUNE/VIOLET]

Les couleurs ROUGE / NOIR sont des normes qui nous permettent de nous repérer. De même que les autres couleurs. Votre pong fonctionnera dans tous les cas, mais cela aide énormément de choisir ces couleurs (maintenance, modifications...).

Le tout peut être soudé sur la carte, ou relié avec un planche de prototypage.

Étape 5 - Préparer la boite

Nous avons construit une boite en carton, en prenant en compte la longueur du ruban de led pour la longueur de la boite et la taille des boutons pour son épaisseurs. La breadboard et les câbles sont cachés à l'intérieur de la boîte.

Le support final peut également être construit avec d'autres matériaux.

Étape 6 - Uploader le code

Télécharger :

- Arduino IDE

https://www.arduino.cc/en/main/software

ou

La version en ligne, qui contient toutes les librairies (gratuite)

https://create.arduino.cc/

- Le code dans l'onglet fichier de ce tutoriel ( en haut!)

La version la plus à jour est Pong_V7 qui contient pong et un autre jeu de tir à la corde.

- La librairie FastLED est necessaire et disponible ici

https://github.com/FastLED/FastLED

ou via le gestionnaire de bilibiothèque directement dans le logiciel.

Une fois télécharger et incluse, elle s'ajoute directement au code.

Televerser le code

Brancher le jeu via la carte arduino. Verifier bien dans l'onglet outils, que le port et le type de carte soit bien coché. (Exemple : Arduino nano, Port 001).

Puis uploader le code dans l'arduino ( Flèche →) à cotés de la touche "valider".

Étape 7 - Exemples de réalisations

Étape 8 - BONUS 1 : Ajout d'une alimentation et d'un haut-parleur

Pour l'alimentation, vous pouvez faire fonctionner la boite en 5V c'est donc assez souple :

Avec un chargeur de téléphone

Une batterie "power bank" pour téléphone

des piles en série (3 piles 1,5 V font parfaitement l'affaire)

Pour le haut parleur, n'importe quel petit haut parleur fera l'affaire.

Étape 9 - BONUS 2 : Modifier le code

Le code est documenté en français. Au début du code vous trouverez plusieurs variables permettant de changer facilement des paramètres du jeu.

Par exemple voici quelques choses que vous pouvez changer:

- LED_PIN: Si vous ne branchez pas la bande de LED sur le pin 8, vous pouvez le changer ici.

- PLAYER1_COLOR: Modifiez cette variable pour changer la couleur de la première personne. Par exemple: ROUGE, VERT, JAUNE ...

- BALL_SPEED: Modifiez cette variable pour accélérer la balle.

Toutes les variables importantes sont commentées donc n'hésitez pas à fouiller.

Une fois vos modifications effectuées, téléversez le code à nouveau.

Optimisation :

- Utiliser d'autres connecteurs

- Sur batterie, sur secteur

Construire un objet numérique

- Histoire du jeu vidéo

- Assemblage du circuit

- Conception d'un objet fini

# data[].attributes.attachment_link.description
Jouez au pong en 1D ! Renvoyez-vous la led avant qu'elle n'atteigne l'extrémité du ruban.

# data[].attributes.headline
Utiliser d'autres composants et un code texte

# data[].attributes.subject
Utiliser d'autres composants et un code texte

# data[].attributes.body
Faire utiliser une ressource externe, d'autres composants et le code texte (qui peut faire peur)

# data[].attributes.attachment_link.readable_text
La fonction tone Arduino est utilisée pour générer un signal PWM avec une saturation de 50% et une fréquence définie à la sortie du microcontrôleur. Pour jouer le signal sonore, un haut-parleur piézo actif ou passif doit être connecté au port Arduino. La durée du signal peut être définie par un paramètre de la commande de tone(). La génération du son s'arrête lorsque la carte est réinitialisée ou lorsque la fonction noTone() de l'Arduino est appelée.
Pour cette activité, nous aurons besoin:

Arduino Uno / Arduino Nano / Arduino Mega

actif ou passif buzzer

breadboard

fils de connexion

Matériel supplémentaire sur ce sujet:

1. Comment branchement un buzzer Arduino

2. Projet sur Arduino: piano avec boutons

3. Minuterie de compte à rebours Arduino

Fonction tone() et noTone() Arduino description

Un seul signal peut être joué sur microcontrôleur Arduino à la fois. Si le signal audio est déjà en cours de lecture sur un port, un nouvel appel à tone() avec un numéro de port différent n'aura aucun effet. Si la fonction tone() de l'Arduino est appelée avec le même numéro de port, elle jouera le signal à la nouvelle fréquence. C'est-à-dire qu'une seule fréquence du signal peut être lue et sur une seule broche. Considérons la commande tone avec un exemples.

Syntaxe de la function tone Arduino

tone (pin, frequency);
tone (pin, frequency, duration);
noTone(pin);

pin - numéro du port sur lequel le signal sera généré
frequency - fréquence du signal en Hertz
duration - durée du signal en millisecondes

Arduino fonction tone() fréquence maximale sur le buzzer. La fréquence de la tonalité générée dépend de la taille du timer de la carte Arduino. Pour un microcontrôleur Arduino Uno ou Nano, la fréquence minimale du son généré est de 31 Hz et la fréquence maximale du son est de 65535 Hz. La gamme de fréquences perçues par l'oreille humaine est beaucoup plus réduite.

Programme Arduino avec fonction tone, noTone

Explication du code avec fonction tone(), noTone():

pour pouvoir être multitâche, utilisez fonction millis au lieu de delay().

Programme Arduino pour jouer de la musique

const byte COUNT_NOTES = 39;

int frequences[COUNT_NOTES] = {
  392, 392, 392, 311, 466, 392, 311, 466, 392,
  587, 587, 587, 622, 466, 369, 311, 466, 392,
  784, 392, 392, 784, 739, 698, 659, 622, 659,
  415, 554, 523, 493, 466, 440, 466,
  311, 369, 311, 466, 392
};

int durations[COUNT_NOTES] = {
  350, 350, 350, 250, 100, 350, 250, 100, 700,
  350, 350, 350, 250, 100, 350, 250, 100, 700,
  350, 250, 100, 350, 250, 100, 100, 100, 450,
  150, 350, 250, 100, 100, 100, 450,
  150, 350, 250, 100, 750
};

void setup() {
   pinMode(11, OUTPUT);
}

void loop() {
   for (int i = 0; i <= COUNT_NOTES; i++) {
      tone(11, frequences[i], durations[i] * 2);
      delay(durations[i] * 2);
      noTone(11);
   }
}

Conclusion. Les fonctions tone et noTone utilisent un timer matériel, il n'est donc pas possible d'utiliser un signal PWM pour le haut-parleur piézo dans le croquis sur les ports de sortie 3 et 11 (sauf sur la carte Arduino Mega). La génération du signal est semi-matérielle, c'est-à-dire que la broche de l'Arduino est activée/désactivée par un timer d'interruption (Timer 2), de sorte que le microcontrôleur peut se bloquer à des fréquences sonores élevées.

# data[].attributes.attachment_link.title
[TUTO] Arduino tone() noTone() fonction + code musique, example

# data[].attributes.attachment_link.description
Fonction tone Arduino est utilisée pour générer un signal PWM avec une saturation de 50% et une fréquence définie à broche du microcontrôleur

# data[].attributes.headline
Découvrir IDE ( Interface de transfert vers la carte)

# data[].attributes.subject
Découvrir IDE ( Interface de transfert vers la carte)

# data[].attributes.body
Voir cours E175

# data[].attributes.attachment_link.readable_text
Arduino Web Editor

Start coding online and save your sketches in the cloud. The most up-to-date version of the IDE includes all libraries and also supports new Arduino boards.
CODE ONLINE GETTING STARTED
Arduino IDE 2.2.1

The new major release of the Arduino IDE is faster and even more powerful! In addition to a more modern editor and a more responsive interface it features autocompletion, code navigation, and even a live debugger.

For more details, please refer to the Arduino IDE 2.0 documentation.

Nightly builds with the latest bugfixes are available through the section below.

SOURCE CODE

The Arduino IDE 2.0 is open source and its source code is hosted on GitHub.

Arduino with Chromebook

To program Arduino from a Chromebook, you can use the Arduino Web Editor on Arduino Cloud. The desktop version of the IDE is not available on Chrome OS.

MicroPython With Arduino Boards

To program your boards using MicroPython, visit the MicroPython with Arduino page. There you find download links and additional resources for getting started with MicroPython on your Arduino boards.

Arduino PLC IDE 1.0.3

Program using IEC 61131-3 languages and mix Arduino sketches through Arduino PLC IDE! Configure easily your pre-mapped resources and get quick no code fieldbus support, dive into your code analysis thanks to the wide set of debugging tools.

For more details, please refer to Arduino PLC IDE documentation.
Both files are required
DOWNLOAD OPTIONS

Version 1.0.4 coming soon

Arduino IDE 1.8.19

The open-source Arduino Software (IDE) makes it easy to write code and upload it to the board. This software can be used with any Arduino board.

Refer to the Getting Started page for Installation instructions.

SOURCE CODE

Active development of the Arduino software is hosted by GitHub. See the instructions for building the code. Latest release source code archives are available here. The archives are PGP-signed so they can be verified using this gpg key.

# data[].attributes.attachment_link.description
Open-source electronic prototyping platform enabling users to create interactive electronic objects.

# data[].attributes.body
Ne necessite pas de compte

Possibilité de simuler plus de cartes, et d'importer des composants

Banque d'exemples disponibles

# data[].attributes.attachment_link.title
Arduino on Wokwi - Online ESP32, STM32, Arduino Simulator

# data[].attributes.attachment_link.description
A faster way to prototype Uno, Mega and Nano projects

# data[].attributes.attachment_link.readable_text
Simuler l'allumage d'une LED avec Arduino grâce à Tinkercad.

Auteur Pierre Bergeret | Dernière modification 11/05/2020 par Pierre

Simuler l'allumage d'une LED avec Arduino grâce à Tinkercad.

Licence : Attribution (CC-BY)

Introduction

De nombreux montages utilisant les cartes arduino sont disponibles sur le Wikidébrouillard, mais peut être que malgré votre envie de découvrir cet outil vous ne possédez pas encore le matériel requis ? Tinkercad est un logiciel permettant de modéliser un certain nombre de choses, y compris des montages électroniques Arduino, et ce de manière très simple, de quoi vous permettre de vous initier à ces cartes en attendant de recevoir du vrai matériel, ou de tester des montages plus complexes même s'il vous manque certains composants... Découvrons comment utiliser Tinkercad pour simuler le contrôle de l'allumage d'une LED.

Étape 1 - Lancer Tinkercad

Allez sur https://www.tinkercad.com/ puis connectez-vous avec l'une des méthodes proposées. Ensuite, cherchez " Circuits " dans le menu à gauche, puis cliquez sur " créer un circuit ". Une page vierge s'ouvre alors, et à droite vous avez un menu proposant une grande quantité de composants.

Étape 2 - Modéliser le circuit

Différents types de composants vous sont proposés. Dans les composants " de base ", cherchez la carte Arduino Uno R3, cliquez dessus en maintenant appuyé et déposez la sur l'espace vierge. Une fenêtre s'ouvre, donnant entre autre la possibilité de renommer l'objet, ce qui peut s'avérer utile pour s'y retrouver par la suite. Ensuite, faites de même avec une platine d'essai de petite taille (aussi appelée Breadboard), que vous placerez à droite de votre carte. Normalement, à ce stade, vous devez avoir quelque chose qui ressemble à ça :

Ajoutez ensuite une LED ainsi qu'une résistance sur votre breadboard. Pour faire pivoter un élément, vous pouvez le sélectionner et cliquer sur " Faire pivoter " tout à gauche de la barre d'outil. Pour rappel, les canaux latéraux de la breadboard (ceux marqué d'un - et d'un +) sont tous connecté entre eux horizontalement, tandis que les canaux à l'intérieur sont connectés par rangée verticale. La LED et la résistance doivent être montés en série, ils doivent donc être connecté entre eux, par exemple comme ceci :

Ensuite il suffit de relier correctement les éléments entre eux, pour cela cliquez sur l'une des broches de la carte (que l'on appelle également pin, qui sont numéroté de 0 à 13), puis cliquez sur la breadboard, un câble est apparu pour relier les deux points. Faite de même afin de fermer le circuit, en reliant la breadboard à l'un des ground de l'arduino (il s'agit de broches destinées à fermer le circuit, notées GND sur la carte, et il y en a trois). Pour rappel, l'électricité circule toujours du + vers le -, et la LED doit être connectée de façon à ce que la plus grande patte (celle qui a un plis) soit reliée à la borne positive. On obtient donc (avec le pin 1 pour l'exemple) quelque chose comme ça :

Ici, si on demande à la carte d'envoyer du courant par le pin 1, l'électricité devrait circuler comme cela, allumant au passage notre LED :

Nous allons maintenant vérifier ce que ça donne.

Étape 3 - Contrôler l'allumage de la LED

Dans le bandeau au-dessus du montage, cliquez sur " code ", une fenêtre s'ouvre, cliquez alors sur " Blocs ", puis sélectionnez " texte ", et confirmez. Ensuite, collez ce code dans la zone de texte, en mettant le bon numéro de pin dans " int pinLed " (dans l'exemple j'ai utilisé le pin 1, mais peut être que vous en avez utilisé un autre) :

Vous pouvez maintenant fermer la fenêtre et cliquer sur " Démarrer la simulation ".

Observations : que voit-on ?

La LED de votre circuit se met à s'allumer, puis à s'éteindre.

Explications

Pour plus de détail sur la structure d'un code arduino, je vous invite à aller voir une page dédiée, par exemple ici : https://www.wikidebrouillard.org/wiki/Premiers_pas_avec_Arduino, mais sachez que la partie du code ou il y a écrit " digitalWrite(pinLed, HIGH); " donne l'ordre à la carte d'envoyer du courant par le pin, la partie " digitalWrite(pinLed, LOW); " donne l'ordre à la carte d'arrêter d'envoyer du courant sur ce pin, et la partie " delay(1000); " donne l'ordre à la carte d'arrêter d'exécuter le code pendant la durée indiquée en millisecondes, ici 1000 ms, soit 1 seconde. Avec ce code, la LED devrait donc s'allumer et s'éteindre toute les secondes.

Plus d'explications

Si vous voulez faire en sorte que la LED clignote plus vite, il suffit de modifier la valeur des " delay " dans le code. Par exemple, pour qu'elle clignote deux fois plus vite, vous pouvez rouvrir le code, puis mettre 500 à la place de 1000 dans les " delay ".

Applications : dans la vie de tous les jours

Vous savez désormais comment créer des circuits électriques Arduino avec Tinkercad. Evidemment, il s'agissait ici d'un exemple extrêmement simple avec juste une LED, mais vous avez désormais les armes pour pouvoir suivre d'autres guides Arduino plus complexes, sans avoir de matériel à votre disposition. Il suffit simplement de sélectionner les bons composants et de les connecter comme il vous le sera indiqué dans ces guides.

Dernière modification 11/05/2020 par user:Pierre.

# data[].attributes.attachment_link.description
Simuler l'allumage d'une LED avec Arduino grâce à Tinkercad.

# data[].attributes.attachment_link.readable_text
Tutoriels et Projets Arduino pour les nuls. Sélection exercices gratuits pour apprendre Arduino pour débutant et expert

Reviews, projets et tutoriels pour Arduino

Bienvenue sur la site internet qui se veut être un guide pour débutant en Arduino et dans lequel nous allons vous montrer comment vous servir de votre carte Arduino au travers d'exemples, de programmes commentés et de projets afin que même le plus débutant d'entre vous puisse utiliser sa carte Arduino rapidement et facilement.

Nouvelles Arduino Tutoriels

Nouvelles Arduino Reviews

Nouvelles Arduino Projets

# data[].attributes.attachment_link.description
Tutoriels et Projets Arduino pour les nuls. Sélection exercices gratuits pour apprendre Arduino pour débutant et expert

# data[].attributes.attachment_link.readable_text
Voici un classique dans les projets d' Arduino: simuler un feu tricolore simple, un feu de signalisation automatisé pour voitures et piétons et, finalement, un feu avec bouton poussoir.

Feu tricolore simple.

Il est nécessaire:

Arduino Uno ou équivalent.

Une plaque d'essai ou breadboard.

4 fils.

3 led: rouge, jaune et verte.

3 résistances de 220 Ω.

Pour le cablage on positionne les trois diodes sur la breadboard, les reliant aux broches 10, 9, 8 de la plaque Arduino Uno. Il faudra vérifier que la patte longue soit connectée positif et la patte courte soit reliée à la résistance.

Feu tricolore simple

Le code es simple: on introduit une variable où noter le temps d'attente. Dans la fonction setup() on indique que les pins 10, 9, 8 seront les voies de sortie.

Après, on allumera la led concernée avec la valeur HIGH, et on l'éteindra changeant la valeur à LOW. D'abord, la couleur rouge sera allumé, quand le feu passera à vert, la diode rouge s'éteindra; avant de revenir sur le rouge, la couleur jaune s'allumera et la diode verte sera éteinte.

Code:

// Feu tricolore simple avec Arduino int tempsAttente = 5000; void setup(){ pinMode(10, OUTPUT); // Rouge pinMode(9, OUTPUT); // Jaune pinMode(8, OUTPUT); // Verte } void loop() { digitalWrite(10, HIGH); // rouge allumée delay(tempsAttente); digitalWrite(8, HIGH); // verte allumée digitalWrite(10, LOW); // rouge éteinte delay(tempsAttente); digitalWrite(9, HIGH); // jaune allumée digitalWrite(8, LOW); // verte éteinte delay(1000); digitalWrite(9, LOW); // jaune éteinte }

Feu automatisé pour voitures et piétons.

Il est nécessaire:

Arduino Uno ou équivalent.

Une breadboard.

6 fils.

5 led: 2 rouges, 1 jaune, 2 vertes.

5 résistances de 220 Ω.

Feu tricolore pour voitures et piétons

Le code est similaire, simplement on ajoute deux diodes supplémentaires. Tenons compte que le feu pour voitures doit être rouge pour que celui des piétons soit vert.

Code:

// Feu pour voitures et piétons avec Arduino int tempsVoitures = 5000; int tempsPietons = 3000; void setup(){ // Feu voitures pinMode(10, OUTPUT); // Rouge pinMode(9, OUTPUT); // Jaune pinMode(8, OUTPUT); // Vert // Feu piétons pinMode(3, OUTPUT); // Rouge pinMode(2, OUTPUT); // Vert } void loop() { digitalWrite(10, HIGH); // rouge allumé digitalWrite(2, HIGH); // vert piétons allumé digitalWrite(3, LOW); // rouge piétons éteint delay(tempsVoitures); digitalWrite(8, HIGH); // vert allumé digitalWrite(10, LOW); // rouge éteint digitalWrite(2, LOW); // vert piétons éteint digitalWrite(3, HIGH); // rouge piétons allumé delay(tempsPietons); digitalWrite(9, HIGH); // jaune allumé digitalWrite(8, LOW); // vert éteint delay(1000); digitalWrite(9, LOW); // jaune éteint }

Feu avec bouton-poussoir pour voitures et piétons.

Il est nécessaire:

Arduino Uno ou équivalent.

Une plaque d'essai ou breadboard.

9 fils.

5 led: 2 rouges, 1 jaune, 2 vertes.

5 résistances de 220 Ω et 1 de 10 KΩ.

1 bouton-poussoir.

Le cablage se complique un peu puisque on va insérer un pulsateur qu' activera le changement de couleur du feu afin de permettre le passage des piétons.

Feu tricolore avec bouton poussoir

Pour commencer, le feu pour voitures est vert, donc celui des piétons doit être rouge. Nous allons créer la fonction changeCouleu r(), à laquelle on appellera si l'état du bouton-poussoir change.

Code:

int tempsTraverse = 5000; unsigned long tempsChange = 0; void setup(){ // feu voitures pinMode(10, OUTPUT); // rouge pinMode(9, OUTPUT); // jaune pinMode(8, OUTPUT); // vert // feu piétons pinMode(3, OUTPUT); // rouge pinMode(2, OUTPUT); // vert pinMode(6, INPUT); // bouton-poussoir, changement couleur digitalWrite(8, HIGH); // vert allumé, voitures digitalWrite(3, HIGH); // rouge allumé, piétons } void loop() { int etat = digitalRead(6); if (etat == LOW && (millis() - tempsChange) > 5000 ){ changeCouleur(); } } void changeCouleur() { digitalWrite(8,LOW); // vert éteint, voitures digitalWrite(9, HIGH); // jaune allumé, voitures delay(2000); digitalWrite(9, LOW); // jaune éteint, voitures digitalWrite(10, HIGH); // rouge allumé, voitures delay(1000); digitalWrite(3, LOW); // rouge éteint, piétons digitalWrite(2, HIGH); // vert allumé, piétons delay(tempsTraverse); // clignotement de la diode verte pour piétons for (int x=0; x<10; x++) { digitalWrite(2, HIGH); delay(250); digitalWrite(2, LOW); delay(250); } digitalWrite(3, HIGH); // rouge allumé, piétons delay(500); digitalWrite(10, LOW); // rouge éteint, voiture digitalWrite(8, HIGH); // vert allumé, voiture tempsChange = millis(); }

Articles similaires

# data[].attributes.attachment_link.title
Comment faire un feu de signalisation tricolore avec Arduino.

# data[].attributes.attachment_link.description
Voici un classique dans les projets d' Arduino: simuler un feu tricolore simple, un feu automatisé pour voitures et piétons.

# data[].attributes.attachment_link.readable_text
Faire clignoter une LED à l'aide d'une carte Arduino pour en comprendre les bases.

Auteur Pierre Bergeret | Dernière modification 2/05/2023 par Antonydbzh

Faire clignoter une LED à l'aide d'une carte Arduino pour en comprendre les bases.

Licence : Attribution (CC-BY)

Introduction

Si vous avez déjà entendu parler des cartes Arduino mais que vous ne comprenez pas ce que c'est et pourquoi elles permettent de réaliser de nombreux projets, alors vous êtes sur la bonne page. Le but ici est d'expliquer ce que sont les cartes arduino, puis de réaliser un montage très simple afin de comprendre leur fonctionnement. Le mieux pour suivre cette page est d'avoir un kit débutant Arduino, mais si vous n'en avez pas vous pouvez aussi suivre la page sur Tinkercad ( https://www.wikidebrouillard.org/wiki/Tinkercad_pour_Arduino ) afin de voir comment réaliser ce montage sur un simulateur.

Étape 1 - Explications de base sur le materiel

Les cartes Arduino sont des microcontrôleurs, des sortes de mini-ordinateurs capable de mémoriser des informations, de les traiter de la manière qu'on le souhaite avec un programme et de recevoir et d'envoyer des signaux électriques. Ces deux dernières possibilités sont réalisables grâce aux broches de l'Arduino (aussi appelée pin), pour l'instant nous nous intéressons seulement à celles numérotées de 0 à 13, entourées en rouge sur l'image.

La carte est alimentée en électricité par les prises sur le côté gauche.

Étape 2 - Le circuit électrique

Dans le montage que nous allons réaliser, nous allons faire clignoter une LED. Pour cela, il va falloir créer un circuit électrique qui relie la carte et la LED, puis programmer la carte pour lui demander alternativement d'envoyer puis de ne pas envoyer de courant dans ce circuit. Pour cela nous avons besoin de la carte, d'une breadboard, de câbles, d'une LED et d'une résistance (à notre stade n'importe quelle résistance fera l'affaire, pourvu qu'elle ne soit pas trop forte). Le courant va être envoyé à partir d'un pin de la carte (disons le pin 1 pour l'exemple), il faut donc relier ce pin a la breadboard par un câble. Sur la breadboard, les canaux latéraux de la breadboard (ceux marqués d'un - et d'un +) sont tous connecté entre eux horizontalement, tandis que les canaux à l'intérieur sont connectés par rangée verticale, les séparations sont représentées sur le schéma de la breadboard par les lignes vertes.

· Avec un câble, reliez le pin 1 avec une des rangées verticales de la breadboard. Sur cette même rangée, placez la patte la plus longue de la LED (aussi appelée la cathode), et branchez l'autre patte sur une autre rangée verticale.

· Sur cette nouvelle rangée, branchez la patte courte (l'anode) ainsi qu'une des pattes de la résistance.

· Branchez l'autre patte de la résistance sur une nouvelle rangée verticale, et enfin reliez cette rangée avec l'un des pins GND de la carte (il s'agit du ground en anglais, l'endroit où le circuit se termine).

Vous pouvez voir ce que cela donne avec l'image du schéma issus de Tinkercad, et ce que cela donne en vrai avec la photo de mon circuit connecté à ma carte.

De cette façon si on demande à la carte d'envoyer du courant par le pin1, l'électricité va circuler à travers le circuit et allumer la LED au passage.

Étape 3 - Programmation

Avant de se lancer dans la programmation, il va falloir Installer l'environnement Arduino sur votre système

Lancez le logiciel Arduino (disponible ici : https://www.arduino.cc/en/Main/Software), puis connectez votre carte à l'aide du câble USB. Vérifiez bien que votre carte est connectée, si c'est bien le cas la ligne " port " en dessous de la ligne " type de carte " devrait indiquer quelque chose comme " COM4(Arduino Uno) ", si ce n'est pas le cas et que cette ligne est grisée cherchez dans " type de carte " " Arduino Uno ".

Le logiciel propose un code vierge, effacez-le et collez ce code a la place :

Cliquez sur " Téléverser " pour envoyer le programme.

Observations : que voit-on ?

La LED devrait se mettre à clignoter une seconde toute les secondes.

Mise en garde : qu'est-ce qui pourrait faire rater l'expérience ?

Faute de frappe dans le programme, téléversement impossible à partir du logiciel Arduino (si le type de carte n'est pas correctement précisé ou encore si le logiciel n'est pas à jour...), circuit incorrectement monté.

Explications

Le programme est une suite d'instruction pour la carte :

· dans la première ligne on demande à la carte de définir le chiffre 1 à la variable " pinLed ", ce qui nous permettra plus tard de modifier facilement quel pin de sortie on veut choisir.

· Ensuite la partie " Setup " après " Void Setup " est une portion de code que la carte doit effectuer une seule fois, on s'en sert pour initialiser les paramètres. Ici la ligne " pinMode(pinLed, OUTPUT) " demande à la carte de définir le pin1 (puisque pinLed a été définie plus tôt par 1) en sortie, pour la préparer à envoyer du courant.

· Enfin la partie " Void Loop " est la portion de code qui va se répéter en boucle. Nous avons quatre lignes ici :

o La ligne " digitalWrite(pinLed, HIGH); " demande à la carte d'envoyer du courant par le pin1.

o La ligne " delay(1000); " ordonne de mettre le programme en pause pendant une seconde (le chiffre 1000 indique le temps d'attente en millisecondes).

o La ligne suivante " digitalWrite(pinLed, LOW); " ordonne à la carte d'arrêter d'envoyer du courant par le pin1.

o Et enfin la dernière ligne demande à nouveau d'attendre une seconde.

Les parties Void Setup et Void Loop sont obligatoires pour tous les codes Arduino, sinon cela provoque une erreur.

Pour résumer, on demande à la carte de définir " pinLed " sur 1, puis de définir le pin1 comme une sortie et ensuite on lui demande en boucle d'envoyer du courant par ce pin pendant une seconde puis d'arrêter d'en envoyer pendant une seconde.

Au final la LED (qui est connectée dans le circuit électrique au pin1) devrait donc clignoter en brillant une seconde toute les secondes.

Il est possible de modifier le programme pour faire clignoter la LED plus rapidement par exemple, en mettant des temps d'attente plus court. Si on met " 500 " à la place de " 1000 " dans les " delay " la LED clignotera deux fois plus vite. Il est également facile de modifier le pin de sortie si besoin, il suffit de changer le " 1 " par le pin de votre choix dans la ligne " int pinLed = 1 ".

Applications : dans la vie de tous les jours

Ici on a vu comment régler un pin en mode sortie, mais sachez que l'on peut également régler les pins en mode entrée et de demander à la carte de lire si du courant y circule et d'effectuer certaines actions si c'est le cas. C'est ce qui se passe notamment quand on utilise des capteurs. Par exemple, on pourrait commander l'allumage de la LED avec une télécommande infrarouge. Il faudrait pour cela brancher un capteur infrarouge sur un pin d'entrée de la carte. Lorsque l'on enverrait des ondes à l'aide d'une télécommande le capteur ferait circuler du courant dans ce pin, et la carte pourrait être programmée pour allumer la LED uniquement si c'est le cas. Une application possible de ce fonctionnement dans la vie de tous les jours sont les télécommandes de télévision. Chaque touche envoie un train d'onde particulier que la télévision interprète comme un ordre (changer de chaîne, augmenter le volume, la luminosité, ...). Il existe de nombreux capteurs, sensibles à l'humidité, le mouvement, la lumière, etc.

Éléments pédagogiques

Objectifs pédagogiques

Apprendre à se servir des cartes Arduino est un très bon moyen pour comprendre comment fonctionne de nombreux objets électroniques du quotidien.

Pistes pour animer l'expérience

A partir de ce montage très simple, vous êtes désormais en mesure de comprendre pourquoi les cartes Arduino permettent de réaliser un si grand nombre de projet, et de les réaliser vous-même en suivant correctement les instructions (vous pouvez essayer des projets du site wikidébrouillards). Un exemple notable : Il est possible de demander à la carte d'envoyer du courant non pas dans une LED mais dans un moteur à la place, ce qui entraîne sa rotation, et de lui demander de le faire que quand on appuie sur le bouton d'une télécommande (grâce à des capteurs et aux pins d'entrées), une étape nécessaire a la fabrication d'une voiture ou d'un robot téléguidé.

Sources et ressources

Le cours openclassroom pour les novices sur Arduino est vraiment bien écrit si vous voulez tirer tout le potentiel de votre kit débutant.

Dernière modification 2/05/2023 par user:Antonydbzh.

# data[].attributes.attachment_link.description
Faire clignoter une LED à l'aide d'une carte Arduino pour en comprendre les bases.

# data[].attributes.attachment_link.readable_text
Introduction: CARDBIRD - the Cardboard Robotic Arm

Build your own cardboard robotic arm in 2 hours. Let´s Rock´n´Roll!

Step 1: Get Inspired for the Build!

Step 2: Get the Parts!

Here is the parts list:

- cardboard (I actually used about 10 capri sonne boxes)

- hardboard 195 x 295 (Bottom of fruit box for example)

- metal piece 45 x 10 x 1 (Metal constructor parts are perfect for this)

- any arduino board

- breadboard

- servo motor x 4 (Tower Pro Micro Servo SG90 9g )

- jamper cables

- tape

- clip x 3

optional:

- IR receiver

- IR pult

For the build you will need glue gun or stick, screwdriver and utility knife.

Step 3: Cut the Body!

Cut the parts like in pictures above. You will need:

- circle with 3 holes x 6

- circle with 2 holes x 1 (second picture without servo hole)

- circle with 35 x 35 square in the middle x 1

- arm holder 1 with servo hole x 4

- arm holder 2 with small hole x 4

- first arm part x 2

- second arm part x 2

You can play a little bit with dimensions. I did it all approximatelly.

Be aware that arm parts must be not too heavy for servos.

Step 4: Prepare CARDBIRD Gripper

Cut two 12 x 120 cardboard rectangles and form them like in the first picture.

Form clips like in the second picture.

Form the metal piece with the clip like in the third picture.

Last pictures should just give you the idea behind it, so don´t bring the parts together in this step.

Step 5: Build It!

First make a hole in hardboard and glue the circle with 35 x 35 square in the middle right over it. As a next step make the plattform from 7 other circles and servo motor (the circle without middle hole should be on top). Now screw the plattform to the servo arm and the servo arm itself to the hardboard on the bottom side (see pictures). Don´t forget to calibrate platform position. These servos can rotate only for 180 degrees. Further make the arm holders, first and second arms like in pictures above. Now you can screw the arms and the holder together and plug it into the plattform. And again, don´t forget to calibrate arms position. As next install the gripper. And you´re done! It´s time for electronics!

Step 6: Electronics!

Servos: PIN 9 - plattform, PIN 8 - first arm, PIN 7 - second arm, PIN 6 - gripper.

Upload the arduino code! Don´t forget to download the IR-Remote-library at
https://github.com/shirriff/Arduino-IRremote.
Copy it in your libraries folder and then rename it to "IRremote" before uploading.

Now you have 2 options to control your arm: via PC or via IR pult. For the first option just open the processing program and use the keyboard. With IR pult try this: 7 and 8 for the plattform, 2 and 5 for the first arm, 2 and 4 for the second arm, + and - for the gripper. If it´s not working you will need to adjust the loop()-function in arduino code. Just read the corresponding values with serial monitor and replace my values.

Step 7: Have Fun!

You're done! Now you can play with your own cardboard robotic arm!

Any questions? Just write it in comments or send me a message!

# data[].attributes.attachment_link.description
CARDBIRD - the Cardboard Robotic Arm: Build your own cardboard robotic arm in 2 hours. Let´s Rock´n´Roll!

# data[].attributes.attachment_link.title
Arduino 16x2 LCD Display with Distance Sensor

# data[].attributes.attachment_link.description
Print distance on Arduino LCD Display using I2c

# data[].attributes.attachment_link.description
Dans ce tutoriel, nous allons voir comment flasher le petitbot de façon simple

# data[].attributes.attachment_link.title
Fabriquez votre PetitBot — Wikidebrouillard

# data[].attributes.body
Défis prompt image : Compétition de prompt pour obtenir l'image la plus approprié à un objectif

Défis prompt texte ...

# data[].attributes.attachment_link.readable_text
ENTRAÎNEMENT IA

Entraînez et expérimentez des modèles d'IA, et visualisez des zones d'interaction qui permettent à l'IA de prendre sa décision.

RÉSEAU DE NEURONES

Explorez la structure et le fonctionnement du réseau de neurones des modèles entraînés pour " ouvrir la boîte noire ",

COMPATIBLE

Utilisez vos modèles sur deux interfaces de programmation : Adacraft (dérivé de Scratch) et Python.

Accéder à toutes les vidéos

L'interface d'IA de Vittascience a été réalisée grâce au soutien du dispositif Édu-up

Ce dispositif, piloté par le Ministère de l'Éducation Nationale, soutient la production de ressources numériques innovantes et adaptées.
En savoir plus

# data[].attributes.attachment_link.description
L'interface entraînement IA permet l'initiation à l'intelligence artificielle.

# data[].attributes.attachment_link.description
Can a neural network learn to recognize doodles? See how well it does with your drawings and help teach it, just by playing.

# data[].attributes.attachment_link.description
Developing pedagogical ressources for teaching Artificial Intelligence

# data[].attributes.attachment_link.description
guide interactif au biais de l'intelligence artificielle

# data[].attributes.attachment_link.readable_text
L'Intelligence Artificielle générative s'immisce de plus en plus dans nos vies à travers des outils (ChatGPT, Midjourney, DALL-E, etc... ) capables de générer des contenus (textuels, visuels et vidéo) de qualité quasi-humaine et à une vitesse inégalée. Nous nous devons de questionner l'impact de cette révolution technologique sur notre société. Il n'est plus seulement question de savoir comment exploiter ces outils, mais aussi et surtout pourquoi et dans quel but.

Data For Good, depuis sa création en 2014, travaille inlassablement à mettre le numérique au service de l'intérêt général. C'est dans cette perspective que nous avons conduit une recherche approfondie sur les enjeux de l'IA générative, ses implications directes et indirectes sur nos vies, notre environnement et notre société.

L'objectif de ce premier rapport est de fournir une analyse détaillée des risques présentés par ces avancées technologiques, tout en proposant des recommandations ciblées aux utilisateurs, aux décideurs et aux développeurs, afin de maximiser l'impact positif de l'IA générative sur la société et minimiser les risques qui lui sont associés.

Ce premier rapport aborde 4 sujets principaux :

1. Fiabilité de l'information : Dans un monde dans lequel l'IA générative peut créer des contenus très réalistes, comment maintenir la confiance dans l'information? Le rapport explore les implications de la diffusion de "deepfakes" et "d'hallucinations génératives", ainsi que des solutions potentielles pour contrer ces problèmes.

2. Propriété intellectuelle et données personnelles : Avec l'IA capable de générer du contenu, les questions de propriété intellectuelle deviennent complexes. Le livre examine les aspects juridiques, les défis et les pistes possibles pour respecter la propriété des artistes et encadrer la génération d'œuvre par IA. Il aborde aussi la notion de respect de la réglementation liée aux données personnelles lors du développement et de l'utilisation de l'IA générative.

3. Biais algorithmiques : Les outils d'IA sont entraînés sur des données qui peuvent contenir des biais inhérents, ce qui peut conduire à des discriminations ou des stéréotypes dans leurs résultats. Le livre blanc souligne ces défis et propose des façons de les atténuer pour créer une IA plus équitable et représentative de la diversité de notre société.

4. Impact environnemental : L'IA n'est pas seulement un défi éthique ou sociétal, mais également environnemental. L'entraînement des modèles d'IA est très énergivore et contribue à l'émission de gaz à effet de serre. Le rapport explore les impacts directs et indirects et les moyens de minimiser cet impact.

"Les meilleurs esprits de notre génération passent leur temps à faire cliquer des gens sur des publicités", a déploré un des premiers employés de Facebook. Et si nous pouvions ensemble redonner un sens à la technologie? C'est la mission que Data For Good s'est donnée. Soyons techno-lucides à l'ère de l'IA générative.

Le livre blanc a été présenté pendant un webinar accessible ici

Contacts (presse, conférences, ...) à genai@dataforgood.fr

Nous publions tous les mois des newsletters sur l'IA générative et ses enjeux sociaux et environnementaux

# data[].attributes.attachment_link.description
L'Intelligence Artificielle générative s'immisce de plus en plus dans nos vies à travers des outils (ChatGPT, Midjourney, DALL-E, etc... ) capables de générer des contenus (textuels, visuels et vidéo) de qualité quasi-humaine et à une vitesse inégalée. Nous nous devons de questionner l'impact de cette révolution technologique sur notre société.

# data[].attributes.body
MonaLisa avec un handspinner

# data[].attributes.attachment_caption
une pomme golden verte avec des dreads rousses, et des lunettes à écailles et qui sourit

# data[].attributes.body
Mona Lisa reptilienne .

# data[].attributes.body
Le ludion réaliste lol

# data[].attributes.body
Flotteur dans la bouteille.

# data[].attributes.attachment_link.title
Cette IA scientifique a modifié son propre code pour échapper au contrôle des humains qui l’utilisent !

# data[].attributes.attachment_link.description
L’entreprise Sakura AI, située à Tokyo, vient de dévoiler une nouvelle IA baptisée The AI Scientist. Conçue pour automatiser la recherche scientifique, elle a tenté d’échapper au contrôle des…

# data[].attributes.body
Hallucination ChatGPT Strawberry

# data[].attributes.attachment_link.title
Chut! Explore 6 - Fonctionnement de ChatGPT | Chut! Magazine

# data[].attributes.attachment_link.description
Générer des images dans le style des studios Ghibli ? Cela semble si facile ! Corriger un texte ? Un jeu d’enfant ! Répondre à toutes vos questions existentielles ? En quelques minutes… Mais comme ça marche ? Magie de la technologie ? Pas vraiment ... Un contenu à lire en famille ou en classe au format papier comme toujours 🗞️ dans Chut! Explore N°6 - IA Situations ⤵️ https://lnkd.in/eWjpFSuJ Et n'oubliez pas de vous abonner 😊 https://lnkd.in/eb5zh_v2