wigum::website - Arduino

CanControl

2026-01-16T00:00:00+00:00
FRC (FIRST Robotics Competition) robots often use motor controllers like the REV Robotics Spark MAX</a>, the CTRE Talon SRX</a>, or the CTRE Victor SPX</a>. However, these controllers are typically designed to work with specific libraries and hardware, such as the RoboRIO used in FRC. This can make it challenging to integrate them with other microcontrollers like Arduino. CanControl</code> is an Arduino library that enables communication with FRC-compatible motor controllers over the CAN bus. With CanControl</code>, you can send commands to motor controllers, read sensor data, and configure settings directly from an Arduino board. This opens up new possibilities for robotics projects that want to leverage the capabilities of FRC motor controllers without being tied to the FRC ecosystem.</p>
GitHub:</strong> willGuimont/CanControl</a></p>


Exercice conditions avec des photorésistances
2019-03-03T00:00:00+00:00
Le but de cet exercice est de vous faire pratiquer les conditions et la boucle principale. De plus, vous aurez la chance de vous pratiquer à lire de la documentation.</p>
Photorésistance</h2>
</p>
Une photorésistance est une composante électronique dont la résistance change selon la lumière qui l’éclaire. En bref, on peut regarder la tension aux bornes de la photorésistance.</p>
But de l’exercice</h2>
Écrivez le code pour qu’une DEL s’allume lorsque la photorésistance est à l’ombre et éteindre la DEL lorsqu’elle est éclairée.</p>
Liens utiles</h2>
analogRead</a></p>
Serial pour afficher des informations à l’écran</a></p>


Introduction aux conditions et à la boucle principale
2019-03-02T00:00:00+00:00
Dans l’article précédant, nous avons vu comment faire clignoter une DEL 2 fois avant de s’éteindre. Maintenant, essayons de n’allumer la DEL que lorsqu’un bouton est enfoncé.</p>
En mots, on voudrait demander à l’Arduino:</p>

Si le bouton est enfoncé

Allumer la DEL</li>
Attendre 3 secondes</li>
Éteindre la DEL</li>
</ol>
</li>
Sinon

Laisser la DEL éteinte</li>
</ol>
</li>
</ol>
Pour ce faire, on branche un bouton de la façon suivante.</p>
</p>
Les zig-zags représentent la résistance. Le symbole avec les deux points vides et le bout de fil représente un bouton ou un interrupteur.</p>
</p>
Fonctions de bases</h2>
Pin en lecture</h3>
pinMode</span>(</span>2</span>,</span> INPUT</span>)</span>;</span></span></code></pre>
Cette fonction permet de mettre la pin 2 en mode lecture.</p>
Lecture d’une pin</h3>
digitalRead</span>(</span>2</span>)</span>;</span></span></code></pre>
Cette fonction retourne HIGH</code> si la tension est près de 5V sur la pin, ou LOW</code> si la tension est près de 0V.</p>
Variables</h2>
On aimerait pouvoir garder l’état du bouton pour pouvoir comparer sa valeur. Pour ce faire, on utilise des variables. Les variables sont comme des boîtes. On peut donner un nom à la boîte et mettre une valeur dedans.</p>
On peut demander à l’Arduino de nous créer une boîte avec un certain nom. On peut ensuite mettre une valeur à l’intérieur. Si on veut, on peut mettre une autre valeur dans la boîte par la suite.</p>
Exemple</h3>
int</span> maVariable</span>;</span></span>
maVariable </span>=</span> 4</span>;</span></span>
maVariable </span>=</span> 2</span>;</span></span>
maVariable </span>=</span> maVariable </span>+</span> 1</span>;</span></span></code></pre>
int</code> correspond au type de la variable. maVariable est donc de type int. int veut dire integer, c’est-à-dire entier en français. Un nombre entier sont des nombres comme 0, 1, 2, 3, 4, -3, 42 et -245. On a donc que maVariable peut contenir des nombres entiers.
On commence par donner la valeur 4 à maVariable.
Ensuite, on change cette valeur pour 2.
Ensuite, on met dans maVariable la valeur de maVariable + 1. Comme maVariable valait 2, on a que maVariable est maintenant 2 + 1, donc 3.</p>
On remarque que le signe = n’a pas le même sens qu’en mathématique. En mathématique, il serait faux de dire 2 = 3. Dans notre cas, on assigne</strong> la valeur de droite à la variable de gauche.</p>
Remarque</strong>: On aurait pu utiliser n’importe quel autre nom pour la variable.</p>
Remarque</strong>: D’autres opérateurs que l’addition (+</code>) sont définis, on peut faire des soustractions (-</code>), des multiplications (*</code>), des division (/</code>) et le modulo (%</code>). La division est toutefois tronqué avec des int</code> puisqu’un int</code> ne peut contenir que des nombres entiers. Le modulo calcule le reste de la division. Pour le moment, ne vous inquiétez pas avec cela.</p>
Storer l’état du bouton dans une variable</h2>
Maintenant que nous savons ce qu’est une variable et comment récupérer l’état du bouton, sauvegardons l’état du bouton dans une variable.</p>
pinMode</span>(</span>2</span>,</span> INPUT</span>)</span>;</span>                 //</span> pin 2 en lecture</span></span>
int</span> etatBouton </span>=</span> digitalRead</span>(</span>2</span>)</span>;</span>   //</span> mettre l'etat du bouton dans etatBouton</span></span></code></pre>
Voilà, nous avons l’état du bouton dans etatBouton.</p>
Conditions</h2>
Maintenant que nous avons l’état du bouton dans une variable, on aimerait pouvoir réaliser certaines actions SI</code> une condition est vraie et d’autres SINON</code>.</p>
Il existe en C++ une façon de réaliser des branchements conditionnelles, c’est-à-dire de faire certaines chose si la condition est vraie. En voici un exemple simple:</p>
int</span> x </span>=</span> 5</span>;</span></span>
if</span> (</span>x </span><</span> 10</span>)</span></span>
{</span></span>
    x </span>=</span> 10</span>;</span></span>
}</span></span></code></pre>
if veut dire si en français. Si on lit le code en français, on a:</p>

Créer une variable nommée x et mettre 5 dedans</li>
Si x est plus petit que</strong> 10 alors

On mets 10 dans x</li>
</ol>
</li>
</ol>
Comme 5 est plus petit que 10, on a que la valeur de x est maintenant 10.</p>
Voici un second exemple:</p>
int</span> x </span>=</span> 42</span>;</span></span>
if</span> (</span>x </span>==</span> 42</span>)</span></span>
{</span></span>
    x </span>=</span> x </span>-</span> 10</span>;</span></span>
}</span></span></code></pre>
if veut dire si en français. Si on lit le code en français, on a:</p>

Créer une variable nommée x et mettre 42 dedans</li>
Si x est égal à</strong> 42 alors

On mets x - 10 dans x</li>
</ol>
</li>
</ol>
Comme x est bien égal à 42, on soustrait 10 à x. x a donc la valeur de 32 après l’exécution.</p>
Remarque</strong>: ==</code> veut dire est égal à</strong>, à ne pas confondre avec = qui veut dire assigner</p>
Disons que nous voulons réaliser ceci:</p>

Soit un entier x qui vaut 39</li>
Si x == 42

x = x - 10</li>
</ol>
</li>
Sinon

x = 0</li>
</ol>
</li>
</ol>
Comment pouvons nous traduire cela en code?
Il existe le mot-clef else</code> qui fait exactement cela.</p>
On aurait alors</p>
int</span> x </span>=</span> 39</span>;</span></span>
if</span> (</span>x </span>==</span> 42</span>)</span></span>
{</span></span>
    x </span>=</span> x </span>-</span> 10</span>;</span></span>
}</span></span>
else</span></span>
{</span></span>
    x </span>=</span> 0</span>;</span></span>
}</span></span></code></pre>
Comme x = 39</code>, on a que la condition x == 42</code> est fausse, donc on n’exécute pas x = x - 10</code>, on entre ensuite dans le else où on assigne 0 à x</code>.</p>
Maintenant que nous savons comment faire des conditions, on peut allumer la DEL si l’état du bouton est à HIGH.</p>
void</span> setup</span>(</span>)</span> </span></span>
{</span></span>
  pinMode</span>(</span>13</span>,</span> OUTPUT</span>)</span>;</span></span>
  pinMode</span>(</span>2</span>,</span> INPUT</span>)</span>;</span>                 //</span> pin 2 en lecture</span></span>
  int</span> etatBouton </span>=</span> digitalRead</span>(</span>2</span>)</span>;</span>   //</span> mettre l'etat du bouton dans etatBouton</span></span>
  if</span> (</span>etatBouton </span>==</span> HIGH</span>)</span></span>
  {</span></span>
    digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span> //</span> Si le bouton est a HIGH, on allume</span></span>
  }</span></span>
  else</span></span>
  {</span></span>
    digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span> //</span> Sinon on laisse éteint</span></span>
  }</span></span>
}</span></span>
</span>
void</span> loop</span>(</span>)</span></span>
{</span></span>
}</span></span></code></pre>
Il y a toutefois un petit problème, la lumière ne s’allume ou ne s’éteint qu’au démarrage de l’Arduino. Pour changer l’état de la lumière, il faut appuyer sur le bouton, puis redémarrer l’Arduino avec le bouton reset. Ce n’est pas très pratique. On aimerait que cela se fasse en tout temps.</p>
</p>
Pour palier à ce problème, on peut utiliser loop</code>. Comme son nom l’indique, loop</code> est une boucle, c’est-à-dire que le code dans cette fonction s’exécute continuellement après l’exécution de setup</code>. Déplaçons donc ce qui doit être exécuté plusieurs fois dans loop</code>.</p>
void</span> setup</span>(</span>)</span> </span></span>
{</span></span>
  pinMode</span>(</span>13</span>,</span> OUTPUT</span>)</span>;</span>  //</span> pin 13 en sortie</span></span>
  pinMode</span>(</span>2</span>,</span> INPUT</span>)</span>;</span>    //</span> pin 2 en lecture</span></span>
}</span></span>
</span>
void</span> loop</span>(</span>)</span> </span></span>
{</span></span>
  int</span> etatBouton </span>=</span> digitalRead</span>(</span>2</span>)</span>;</span>   //</span> mettre l'etat du bouton dans etatBouton</span></span>
  if</span> (</span>etatBouton </span>==</span> HIGH</span>)</span></span>
  {</span></span>
    digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span> //</span> Si le bouton est a HIGH, on allume</span></span>
  }</span></span>
  else</span></span>
  {</span></span>
    digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span> //</span> Sinon on laisse éteint</span></span>
  }</span></span>
}</span></span></code></pre>
On remarque que les pinMode</code> sont restés dans setup</code>. En effet, on ne veut réserver ces pin qu’une seule fois.</p>
Alors que le if</code> et else</code> a été déplacé dans loop, puisque l’on veut continuellement vérifier si le bouton est enfoncé.</p>
Maintenant, on a que la lumière s’allume et s’éteint dès que l’on appuie ou relâche le bouton.</p>


Introduction à Arduino
2019-03-01T00:00:00+00:00
Qu’est-ce qu’Arduino</h2>
</p>

The UNO is the best board to get started with electronics and coding. If this is your first experience tinkering with the platform, the UNO is the most robust board you can start playing with. The UNO is the most used and documented board of the whole Arduino family.</p>
– Site officiel Arduino.cc</p>
</blockquote>
Il s’agit d’une carte comprenant un micro-contrôleur. La puce sur la carte est un petit ordinateur que l’on peut programmer. Il y a un port USB pour envoyer le code sur la puce et communiquer avec un ordinateur. Les pins sur le côté permettent d’avoir des entrées-sorties vers le vrai monde. On peut activer des lumières et des moteurs. On peut aussi lire les données envoyées par un capteur de distance à l’ultrason ou une photorésistante pour savoir s’il fait noir.</p>
Introduction à la programmation</h2>
Un programme est une suite d’instructions exécutées les unes après les autres. On peut voir un programme comme une recette très précise pour réaliser des choses.</p>
On pourrait vouloir donner la suite d’étape pour faire un sandwich au beurre d’arachides. On pourrait essayer de demander à l’ordinateur de faire:</p>

Faire un sandwich au beurre d’arachide</li>
</ol>
Toutefois, l’ordinateur ne comprend pas comment faire cela. On devrait alors décrire les étapes de façon plus précises de façon à ce que l’ordinateur comprenne. On aurait alors:</p>

Ouvrir le sac contenant le pain</li>
Sortir une tranche de pain</li>
Sortir le pot de beurre d’arachide de l’armoire</li>
Sortir un couteau</li>
Ouvrir le pot</li>
Tartiner le pain avec le couteau</li>
Sortir une seconde tranche de pain</li>
Placer la tranche sur l’autre qui est déjà beurrée</li>
</ol>
Ouf ! C’est beaucoup d’étapes pour un simple sandwich.
Pour programmer un robot, c’est très semblable. On ne peut pas dire au robot de:</p>

Avancer pendant 10 secondes</li>
</ol>
Il faut plutôt lui dire:</p>

Actionne les moteurs</li>
Attendre 10 secondes</li>
Arrête les moteurs</li>
</ol>
DEL et Arduino</h2>
DEL</code>: D</code>iode É</code>lectro L</code>uminescente</p>

En bref, une DEL est une lumière qui ne demande que très peu d’énergie. On peut donc l’alimenter directement depuis l’Arduino.</p>
Si l’on applique une tension aux deux bornes de la DEL, elle s’allumera.</p>
Une DEL a deux “pattes”. L’une d’elles est légèrement plus longue, il s’agit de la patte positive. L’autre est la négative. Lors du branchement, il faut faire attention de bien brancher la DEL.</p>
Faire clignoter une DEL</h2>
On voudrait demander à l’Arduino de faire clignoter une la DEL deux fois en la laissant 2 secondes éteintes et 3 secondes allumées. En mots, on aurait:</p>

Allumer la DEL</li>
Attendre 3 secondes</li>
Éteindre la DEL</li>
Attendre 2 secondes</li>
Allumer la DEL</li>
Attendre 3 secondes</li>
Éteindre la DEL</li>
</ol>
Télécharger Arduino</h3>
Il est maintenant temps d’essayer de demander à l’Arduino de faire ces étapes. Téléchargeons le logiciel depuis le site officiel d’Arduino</a>.</p>
On peut télécharger le ZIP ne demandant pas d’installation à cette adresse</a>.</p>
On peut maintenant lancer l’application.</p>
Premiers pas en Arduino</h3>
</p>
On voit maintenant un code de base fournit par Arduino.</p>
void</span> setup</span>(</span>)</span> {</span></span>
  //</span> put your setup code here, to run once:</span></span>
</span>
}</span></span>
</span>
void</span> loop</span>(</span>)</span> {</span></span>
  //</span> put your main code here, to run repeatedly:</span></span>
</span>
}</span></span></code></pre>
setup</code> est exécuté qu’une fois au démarrage de l’Arduino.</p>
loop</code> est ensuite exécuté continuellement.</p>
Toutefois, avant de commencer à coder, branchons la DEL dans l’Arduino.</p>
</p>
Dans le cadre de ce document, nous allons utiliser la pin</strong> numéro 13. Vous pouvez en choisir une autre si vous voulez. La longue patte doit être connectée dans la pin 13 et la courte au ground. Le ground</strong> est le 0 volt de référence de l’Arduino.</p>
Pour empêcher de brûler la DEL, on place une résistance en série</strong> avec la DEL. La résistance doit être entre 220 et 280 Ohms. Elle peut être placée avant ou après la DEL.</p>
Fonctions de base</h4>
Pour faire clignoter une DEL, on doit pouvoir être capable de l’allumer, de l’éteindre et d’attendre. Nous allons voir comment réaliser ces actions dans Arduino.</p>
Configuration de la DEL</h5>
On doit indiquer à l’Arduino quelles pins on désire utiliser, dans notre cas il s’agit de la pin 13. On appelle alors la fonction suivante:</p>
pinMode</span>(</span>13</span>,</span> OUTPUT</span>)</span>;</span></span></code></pre>
OUTPUT</code> signifie que l’on veut se servir de la pin comme d’une sortie, donc mettre une certaine tension à la pin plutôt que de lire la tension. On aurait pu utiliser INPUT</code> pour initialiser la pin comme une entrée. Nous allons en voir une exemple par la suite.</p>
Allumer la DEL</h5>
Pour allumer la DEL, on doit mettre une certaine tension aux bornes de la DEL. Comme la patte négative est branchée au ground, on doit appliquer un voltage positif à la patte branchée dans la pin 13. Pour ce faire, on utilise la fonction suivante:</p>
digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span></span></code></pre>
HIGH</code> signifie une tension positive. Dans le cas d’une Arduino UNO, on met 5 volts sur la pin 13.</p>
Éteindre la DEL</h5>
Pour l’éteindre, on procède de façon semblable.</p>
digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span></span></code></pre>Attendre</h5>
Pour attendre un certain temps, on utilise la fonction:</p>
delay</span>(</span>1000</span>)</span>;</span></span></code></pre>
Ici, 1000 représente le temps à attendre en millisecondes. On a qu’une seconde est 1000 ms. Par exemple, pour attendre 5 secondes, on devrait indiquer 5000 ms.</p>
Mettre le tout ensemble</h4>
Reprenons la liste d’étapes à suivre pour faire clignoter notre DEL:</p>

Allumer la DEL</li>
Attendre 3 secondes</li>
Éteindre le DEL</li>
Attendre 2 secondes</li>
Allumer la DEL</li>
Attendre 3 secondes</li>
Éteindre la DEL</li>
</ol>
On peut maintenant “traduire” chaque étape en code. Il manque toutefois l’initialisation de la pin au début. Avec les informations un peu plus haut, on peut maintenant coder notre Arduino.</p>
void</span> setup</span>(</span>)</span> </span></span>
{</span></span>
  pinMode</span>(</span>13</span>,</span> OUTPUT</span>)</span>;</span>     //</span> 0. On dit a l'Arduino que l'on réserve la pin 13</span></span>
  digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span>  //</span> 1. Allumer la DEL</span></span>
  delay</span>(</span>3000</span>)</span>;</span>             //</span> 2. Attendre 3 secondes</span></span>
  digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span>   //</span> 3. Éteindre le DEL</span></span>
  delay</span>(</span>2000</span>)</span>;</span>             //</span> 4. Attendre 2 secondes</span></span>
  digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span>  //</span> 5. Allumer la DEL</span></span>
  delay</span>(</span>3000</span>)</span>;</span>             //</span> 6. Attendre 3 secondes</span></span>
  digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span>   //</span> 7. Éteindre le DEL</span></span>
}</span></span>
</span>
void</span> loop</span>(</span>)</span> </span></span>
{</span></span>
</span>
}</span></span></code></pre>
On peut maintenant connecter l’Arduino par USB à l’ordinateur.</p>
On doit premièrement vérifier que l’Aduino est connectée dans Outils -> Port. Il faut s’assurer que le port selectionné est bien celui de l’Arduino.</p>
</p>
On peut envoyer le code sur l’Arduino avec le bouton “Téléverser” (la flèche vers la droite). Après un certain temps, l’Arduino devrait faire clignoter la DEL deux fois selon les délais définit.</p>
À l’infini</h3>
Et si on désirait faire clignoter le DEL à l’infini? Il faudrait demander à l’Arduino de la faire clignoter pleins de fois. On pourrait avoir:</p>
void</span> setup</span>(</span>)</span> </span></span>
{</span></span>
  pinMode</span>(</span>13</span>,</span> OUTPUT</span>)</span>;</span>     //</span> 0. On dit a l'Arduino que l'on réserve la pin 13</span></span>
  digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span>  //</span> 1. Allumer la DEL</span></span>
  delay</span>(</span>3000</span>)</span>;</span>             //</span> 2. Attendre 3 secondes</span></span>
  digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span>   //</span> 3. Éteindre le DEL</span></span>
  delay</span>(</span>2000</span>)</span>;</span>             //</span> 4. Attendre 2 secondes</span></span>
  digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span>  //</span> 5. Allumer la DEL</span></span>
  delay</span>(</span>3000</span>)</span>;</span>             //</span> 6. Attendre 3 secondes</span></span>
  digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span>   //</span> 7. Éteindre le DEL</span></span>
  //</span></span>
  digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span>  </span></span>
  delay</span>(</span>3000</span>)</span>;</span>             </span></span>
  digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span> </span></span>
  delay</span>(</span>2000</span>)</span>;</span>             </span></span>
  digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span>  </span></span>
  delay</span>(</span>3000</span>)</span>;</span>           </span></span>
  digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span>   </span></span>
  //</span></span>
  digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span>  </span></span>
  delay</span>(</span>3000</span>)</span>;</span>             </span></span>
  digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span> </span></span>
  delay</span>(</span>2000</span>)</span>;</span>             </span></span>
  digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span>  </span></span>
  delay</span>(</span>3000</span>)</span>;</span>           </span></span>
  digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span>   </span></span>
  //</span></span>
  digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span>  </span></span>
  delay</span>(</span>3000</span>)</span>;</span>             </span></span>
  digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span> </span></span>
  delay</span>(</span>2000</span>)</span>;</span>             </span></span>
  digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span>  </span></span>
  delay</span>(</span>3000</span>)</span>;</span>           </span></span>
  digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span>   </span></span>
  //</span>....</span></span>
}</span></span>
</span>
void</span> loop</span>(</span>)</span> </span></span>
{</span></span>
</span>
}</span></span></code></pre>
Et on devrait continuer ainsi pendant longtemps… Heureusement, il y a une meilleure façon !</p>
La fonction loop est exécutée continuellement après setup, il suffit donc d’avoir le code suivant:</p>
void</span> setup</span>(</span>)</span> </span></span>
{</span></span>
  pinMode</span>(</span>13</span>,</span> OUTPUT</span>)</span>;</span>     //</span> 0. On dit a l'Arduino que l'on réserve la pin 13</span></span>
}</span></span>
</span>
void</span> loop</span>(</span>)</span> </span></span>
{</span></span>
  digitalWrite</span>(</span>13</span>,</span> HIGH</span>)</span>;</span>  //</span> 1. Allumer la DEL</span></span>
  delay</span>(</span>3000</span>)</span>;</span>             //</span> 2. Attendre 3 secondes</span></span>
  digitalWrite</span>(</span>13</span>,</span> LOW</span>)</span>;</span>   //</span> 3. Éteindre le DEL</span></span>
  delay</span>(</span>2000</span>)</span>;</span>             //</span> 4. Attendre 2 secondes</span></span>
}</span></span></code></pre>
On a donc que la lumière s’allume pour 3 secondes, et s’éteint pendant 3 secondes à l’infini. On remarque qu’il y a moins de code copier-collé</strong> !</p>
wigum::website - Arduino

CanControl

Exercice conditions avec des photorésistances

Photorésistance</h2> </p> Une photorésistance est une composante électronique dont la résistance change selon la lumière qui l’éclaire. En bref, on peut regarder la tension aux bornes de la photorésistance.</p>

But de l’exercice</h2> Écrivez le code pour qu’une DEL s’allume lorsque la photorésistance est à l’ombre et éteindre la DEL lorsqu’elle est éclairée.</p>

Liens utiles</h2> analogRead</a></p> Serial pour afficher des informations à l’écran</a></p>

Introduction aux conditions et à la boucle principale

Fonctions de bases</h2>

Introduction à Arduino

Qu’est-ce qu’Arduino</h2> </p>

Photorésistance</h2>
</p>
Une photorésistance est une composante électronique dont la résistance change selon la lumière qui l’éclaire. En bref, on peut regarder la tension aux bornes de la photorésistance.</p>

But de l’exercice</h2>
Écrivez le code pour qu’une DEL s’allume lorsque la photorésistance est à l’ombre et éteindre la DEL lorsqu’elle est éclairée.</p>

Liens utiles</h2>
analogRead</a></p>
Serial pour afficher des informations à l’écran</a></p>
