LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

lundi 20 novembre 2017

69 visiteurs en ce moment

Piloter son Arduino avec son navigateur web et Node.js (2)

. Par : bobyAndCo

Dans l’article précédent Piloter son Arduino avec son navigateur web et Node.js (1), nous avons vu comment installer Node.js sur notre ordinateur et tester une première application permettant d’allumer ou d’éteindre la LED de l’Arduino avec un bouton poussoir inclus dans une page web.

Dans ce second article, il va être question de potentiomètres. Nous allons également travailler avec des messages plus complexes que de simples 0 ou 1 ce qui nous permettra d’envisager le pilotage d’applications importantes.

Tous les fichiers que nous allons utiliser pour ce deuxième article sont téléchargeables ici :

Archive2

Comme pour l’article précédent, vous devez les déposer dans votre répertoire "user".

REGLER L’INTENSITE D’UNE LED AVEC UN POTENTIOMETRE

Dans le premier projet de ce second article, nous allons utiliser un potentiomètre dans notre page web et régler ainsi la luminosité d’une LED reliée à une sortie PWM   de notre Arduino. Ici la sortie 11. Le montage est on ne peut plus simple.

On a besoin d’une LED (peut importe la couleur) et d’une résistance de 220 Ohms minimum (jusqu’à 1K voire 1K,5 avec les LED basse consommation).

Et il faut téléverser dans l’Arduino le sketch fadeLed.ino.

PNG - 123.8 ko

Par l’intermédiaire de l’instruction analogWrite(), la broche génère une onde carrée avec un « duty cycle » dont la valeur oscille entre 0 (0% HAUT donc toujours au niveau BAS) et 255 (100% HAUT donc toujours au niveau HAUT).

PNG - 20.5 ko

La page web http://localhost:8080/fadeLed.html contient un simple potentiomètre qui permet de faire varier la valeur lue de 0 à 100%.

PNG - 25.2 ko

Voici ce que l’on souhaite obtenir.

Pour bien comprendre la PWM  , je vous invite à lire les articles de Locoduino, La PWM : Qu’est-ce que c’est ?

Voyons le code de la page web fadeLed.html   :

  1. <head>
  2. <meta charset='UTF-8'>
  3. <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
  4. <script src="./socket.io/socket.io.js"></script>
  5. <link rel="stylesheet" href="http://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
  6. html {
  7. margin:20px;
  8. }
  9. table {
  10. width:450px;
  11. }
  12. td {
  13. padding:10px;
  14. }
  15. input[type="range"] {
  16. position: relative;
  17. margin-left: 1em;
  18. }
  19. input[type="range"]:after,
  20. input[type="range"]:before {
  21. position: absolute;
  22. top: 1em;
  23. }
  24. input[type="range"]:before {
  25. left:0em;
  26. content: attr(min);
  27. }
  28. input[type="range"]:after {
  29. right: 0em;
  30. content: attr(max);
  31. }
  32. #lightSlider:hover {
  33. cursor:pointer;
  34. }
  35. #log {
  36. text-align: center;
  37. color:red;
  38. }
  39. </style>
  40.  
  41. $(function() {
  42. var socket = io.connect('http://localhost:8080');
  43.  
  44. // Installation d'un écouteur sur le slider
  45. var slider = document.getElementById('lightSlider');
  46. slider.addEventListener('input', function() {
  47. setFade(slider.value);
  48. });
  49.  
  50. var setFade = function (fadeValue) {
  51. // La valeur lue dans le slider est convertie en caractère
  52. var fadeAscii = String.fromCharCode(fadeValue);
  53. // ... affichée sous le curseur
  54. $('#log').html(fadeValue+" %");
  55. // ... puis envoyée au serveur Node
  56. socket.emit('message', fadeAscii);
  57. }
  58. // Initialisation
  59. setFade(0);
  60. });
  61. </script>
  62. </head>
  63. <body>
  64. <tr>
  65. <td><input id="lightSlider" type="range" min="0" max="100" value="0" /></td>
  66. </tr>
  67. <tr>
  68. <td id="log">0 %</td>
  69. </tr>
  70. <tr>
  71. <td>Déplacez le curseur pour faire varier la luminosité de la LED.</td>
  72. </tr>
  73. </table>
  74. </body>
  75. </html>

Télécharger

Tout d’abord le potentiomètre qui est inclus dans le body ligne 69.

<input id="lightSlider" type="range" min="0" max="100" value="0" />

C’est une balise input de type="range". Les valeurs mini et maxi que renvoie le potentiomètre sont définies dans min="0" max="100". Toutes autres valeurs mini ou maxi peuvent être choisies. Quant à value="0", cela permet de positionner le curseur à 0 au chargement de la page. J’ai appelé l’identifiant unique de l’objet « lightSlider » (id="lightSlider") pour pouvoir m’en servir plus tard dans ma programmation.

L’objet graphique input range dispose d’autres options. Ainsi, la valeur du pas qui est 1 par défaut « step="1" » peut être réglée sur toute autre valeur (2 en 2, 5 en 5, 10 en 10…). N’hésitez pas à chercher des exemples sur internet.

De même, pour le CSS   où vous voyez entre les balises <style> que je n’ai pas hésité à utiliser des options disponibles.

Mais attardons nous sur un élément nouveau et important du code JavaScript (lignes 48 à 51) :

  1. // Installation d'un écouteur sur le slider
  2. var slider = document.getElementById('lightSlider');
  3. slider.addEventListener('input', function() {
  4. setFade(slider.value);
  5. });

Comme le commentaire l’indique, j’ai installé un écouteur sur l’objet qui a pour id « lightSlider ». Cet écouteur n’est actif que sur les événements de type « input », c’est à dire quand on déplace le curseur. Cela appellera alors la fonction setFade avec comme paramètre (slider.value).

Il est possible d’installer plusieurs écouteurs sur un même objet pour des événements différents comme le double click ou le passage de la souris. Ces nouveaux écouteurs peuvent appeler d’autres fonctions.

Comme dans le dernier exemple du premier article (power3.html  ), la fonction setFade reprend la conversion du caractère en code ASCII : var fadeAscii = String.fromCharCode(fadeValue); et envoie ce code ASCII à l’Arduino via la fonction socket.emit('message', fadeAscii);

$('#log').html(fadeValue+" %"); sert à afficher en temps réel la valeur renvoyée par le potentiomètre. Vous avez bien noté que la valeur envoyée est en pourcentage.

Voyons maintenant les choses côté Arduino avec le sketch fadeLed.ino

  1. /*
  2.   Ce sketche est inspiré de : https://www.arduino.cc/en/tutorial/fade
  3.  
  4.   This example shows how to fade an LED on pin 11
  5.   using the analogWrite() function.
  6.  
  7.   The analogWrite() function uses PWM, so if
  8.   you want to change the pin you're using, be
  9.   sure to use another PWM capable pin. On most
  10.   Arduino, the PWM pins are identified with
  11.   a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.
  12. */
  13.  
  14. int led = 11; // the PWM pin
  15. float brightness = 0; // how bright the LED is
  16.  
  17. void process() {
  18. brightness *= 2.55;
  19. analogWrite(led, brightness);
  20. Serial.println(brightness);
  21. }
  22.  
  23. // the setup routine runs once when you press reset:
  24. void setup() {
  25. // declare pin 11 to be an output:
  26. pinMode(led, OUTPUT);
  27. Serial.begin(115200);
  28. }
  29.  
  30. void loop() {
  31. while (Serial.available()) {
  32. brightness = (int)Serial.read();
  33. if (brightness >= 0 || brightness <= 100) {
  34. process();
  35. }
  36. }
  37. }

Télécharger

Dans le loop, la valeur reçue du navigateur est stockée dans la variable brightness qui est de type float. En effet, si les valeurs reçues sont de type entier comprises entre 0 et 100 (on s’exprime ici en % de luminosité), cette valeur devra être multipliée par le coefficient 2.55 pour être envoyée sur la sortie avec la fonction analogWrite() dont la plage de valeurs va de 0 à 255

Vous constaterez que là aussi, le code est concis.

COMMANDER UNE LED RVB

Pour cet exemple, nous allons continuer à nous servir de potentiomètres, trois cette fois, pour pouvoir agir sur chacune des trois couleurs primaires d’une LED RVB.

Faire fonctionner une LED RVB n’est pas beaucoup plus compliqué qu’une LED simple. Il faut tout d’abord repérer les broches par rapport à la broche la plus longue qui peut être soit une cathode commune, soit une anode commune. Ici nous avons une cathode commune qui sera reliée au GND de l’Arduino.

PNG - 11.3 ko

Voici le schéma du montage. Les résistances sont des 270 ohms 1/4 W.

Et il faut téléverser dans l’Arduino le sketch colorMixingLamp.ino.

JPEG - 141.8 ko

Côté HTML, nous allons avoir une page led_rvb.html (http://localhost:8080/led_rvb.html) très similaire à la précédente avec trois potentiomètres au lieu d’un auxquels nous allons donner des ID R_Slider pour le rouge, V_Slider pour le vert et B_Slider pour le bleu. Facile, non ?

  1. <head>
  2. <meta charset='UTF-8'>
  3. <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
  4. <script src="./socket.io/socket.io.js"></script>
  5. <link rel="stylesheet" href="http://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
  6. html {
  7. margin:50px;
  8. }
  9. table {
  10. width:100%;
  11. }
  12. td {
  13. padding:10px;
  14. }
  15. input[type="range"] {
  16. position: relative;
  17. margin-left: 1em;
  18. }
  19. input[type="range"]:after,
  20. input[type="range"]:before {
  21. position: absolute;
  22. top: 1em;
  23. }
  24. input[type="range"]:before {
  25. left:0em;
  26. content: attr(min);
  27. }
  28. input[type="range"]:after {
  29. right: 0em;
  30. content: attr(max);
  31. }
  32. #lightSlider:hover {
  33. cursor:pointer;
  34. }
  35. #log {
  36. text-align: center;
  37. color:red;
  38. }
  39. </style>
  40.  
  41. $(function() {
  42. var socket = io.connect('http://localhost:8080');
  43.  
  44. var fullMsg = ""; // Initialisation d'une variable globale pour la réception des messages
  45.  
  46. // En cas de réception d'un message du serveur
  47. socket.on('message', function(message) {
  48. fullMsg += message; // On ajoute le message reçu à fullMsg
  49. if(message.charAt(message.length-1) == '\n') { // Si délimiteur de fin de message
  50. $('#log').html(fullMsg); // Affichage du message
  51. fullMsg = ""; // On efface le contenu de fullMsg
  52. }
  53. });
  54.  
  55. // Installation d'écouteurs sur les 3 sliders
  56. /*
  57. var r = document.getElementById('R_Slider');
  58. r.addEventListener('input', function() {
  59. set();
  60. });
  61. var v = document.getElementById('V_Slider');
  62. v.addEventListener('input', function() {
  63. set();
  64. });
  65. var b = document.getElementById('B_Slider');
  66. b.addEventListener('input', function() {
  67. set();
  68. });
  69. */
  70.  
  71. $("[type=range]").on("input", function () {
  72. set();
  73. });
  74.  
  75. var set = function () {
  76. var msgString = '<'+R_Slider.value+" "+V_Slider.value+" "+B_Slider.value+'>';
  77. socket.emit('message', msgString);
  78. }
  79.  
  80. // Initialisation
  81. set();
  82. });
  83. </script>
  84. </head>
  85. <body>
  86. <tr>
  87. <td>Rouge :</td><td><input id="R_Slider" type="range" min="0" max="255" value="0" /></td>
  88. </tr>
  89. <tr>
  90. <td>Vert :</td><td><input id="V_Slider" type="range" min="0" max="255" value="0" /></td>
  91. </tr>
  92. <tr>
  93. <td>Bleu :</td><td><input id="B_Slider" type="range" min="0" max="255" value="0" /></td>
  94. </tr>
  95. <tr>
  96. <td>Logs : </td><td id="log"></td>
  97. </tr>
  98.  
  99. </table>
  100. </body>
  101. </html>

Télécharger

Le principal intérêt de ce troisième exemple concerne essentiellement le message que nous allons envoyer à l’Arduino. En effet, jusqu’ici, les messages envoyés étaient simples et ne concernaient qu’un seul paramètre et avec des valeurs inférieures à 128 (7 bits). Nous pouvions donc nous servir des codes ASCII de caractères.

Mais ici, nous devons envoyer au moins deux informations à l’Arduino. La couleur concernée et la valeur souhaitée. Sachant qu’il s’agit de sorties en PWM, ces valeurs peuvent varier de 0 à 255. Nous allons donc être obligé d’envoyer des chaines de caractères. Strings en Anglais.

Les messages envoyés à l’Arduino pourraient être de type R 123 si l’on voulait régler l’intensité du rouge sur 123 par exemple ou B 255 si l’on voulait un bleu au maximum.

Mais ici nous allons retenir une autre structuration de message qui consistera à envoyer les trois valeurs RVB dans un seul message et dans un ordre précis, le R en premier, le V en deuxième et le B en troisième. Le message sera donc de type 123 255 75 où, vous l’avez compris, la valeur du rouge est 123, du vert 255 et du bleu 75.

Dans le JavasScript, la structuration du message et son envoi sont programmés ainsi dans la fonction set() :

  1. var set = function () {
  2. msgString = '<'+R_Slider.value+" "+V_Slider.value+" "+B_Slider.value+'>';
  3. socket.emit('message', msgString);
  4. }

msgString est la variable qui contient le message avec la valeur de R_Slider puis un espace puis la valeur de V_Slider puis un espace et enfin la valeur de B_Slider. Remarquez que le message commence par le caractère ’<’ et se termine par ’>’, ceci est important, nous en reparlerons quand nous examinerons le croquis de l’Arduino.

Cette fonction set() réalise donc la structuration du message et son envoi : socket.emit('message', msgString);

Il y a aussi une autre chose très intéressante dans ce code JavaScript. Alors que dans les exemples précédents, nous avions placé un script ou un écouteur sur chaque élément actif, nous aurions également dû placer un écouteur sur chacun des trois potentiomètres ce qui aurait donné ceci :

  1. // Installation d'écouteurs sur les 3 sliders
  2. var r = document.getElementById('R_Slider');
  3. r.addEventListener('input', function() {
  4. set();
  5. });
  6. var v = document.getElementById('V_Slider');
  7. v.addEventListener('input', function() {
  8. set();
  9. });
  10. var b = document.getElementById('B_Slider');
  11. b.addEventListener('input', function() {
  12. set();
  13. });

En fait, nous allons utiliser le code suivant qui va faire exactement la même chose :

  1. $("[type=range]").on("input", function () {
  2. set();
  3. });

$("[type=range]") nous permet de ne plus à avoir à cibler chaque potentiomètre individuellement mais cible tous les éléments de la page qui ont pour type="range".

Ce code à été laissé volontairement sur la page mais mis en commentaire de la ligne 58 à 72, vous pouvez tout à fait le supprimer.

Au final, quand vous observez le JavaScript de cette page, vous vous apercevez qu’il est extrêmement compact, ce qui est une très bonne chose en programmation.

Voyons maintenant le code coté Arduino qui est inclus dans le croquis colorMixingLamp.ino. Pour ce programme, je suis parti d’un croquis du même nom déjà existant dans les exemples de l’Arduino dans 10.StarterKit et je l’ai adapté pour les besoins.

  1. /*
  2.   Ce sketch reprend en partie les éléments de :
  3.  
  4.   Arduino Starter Kit example
  5.   Project 4 - Color Mixing Lamp
  6.  
  7.   This sketch is written to accompany Project 3 in the
  8.   Arduino Starter Kit
  9.  
  10.   Parts required:
  11.   1 RGB LED
  12.   3 220 ohm resistors
  13.  
  14.   Created 13 September 2012
  15.   Modified 14 November 2012
  16.   by Scott Fitzgerald
  17.   Thanks to Federico Vanzati for improvements
  18.  
  19.   http://www.arduino.cc/starterKit
  20.  
  21.   This example code is part of the public domain
  22.  
  23.   Modifiée par Christophe BOBILLE - juin 2017
  24. */
  25.  
  26. const int redLEDPin = 9; // LED connected to digital pin 9
  27. const int greenLEDPin = 10; // LED connected to digital pin 10
  28. const int blueLEDPin = 11; // LED connected to digital pin 11
  29.  
  30. int redValue; // value to write to the red LED
  31. int greenValue; // value to write to the green LED
  32. int blueValue; // value to write to the blue LED
  33.  
  34. char msgString[12]; // Tableau qui va recevoir les caractères envoyés
  35. char response[24]; // Tableau qui va recevoir les caractères de la reponse
  36. //
  37.  
  38. void process (char *msgString) {
  39. int r, v, b;
  40. sscanf(msgString, "%d%d%d", &r, &v, &b);
  41.  
  42. analogWrite(redLEDPin, r);
  43. analogWrite(greenLEDPin, v);
  44. analogWrite(blueLEDPin, b);
  45.  
  46. snprintf(response, sizeof(response), "%d - %d - %d\n", r, v, b);
  47. Serial.print(response);
  48. }
  49.  
  50. void setup() {
  51. Serial.begin(115200);
  52. // set the digital pins as outputs
  53. pinMode(greenLEDPin, OUTPUT);
  54. pinMode(redLEDPin, OUTPUT);
  55. pinMode(blueLEDPin, OUTPUT);
  56. }
  57.  
  58. void loop() {
  59. char c;
  60. while (Serial.available()) {
  61. c = Serial.read();
  62. if (c == '<') { // Caractère délimiteur de début de message
  63. sprintf(msgString, "");
  64. }
  65. else if (c == '>') { // Caractère délimiteur de fin de message
  66. process(msgString);
  67. }
  68. else { // Caractères du message
  69. sprintf(msgString, "%s%c", msgString, c);
  70. }
  71. }
  72. }

Télécharger

Le premier élément nouveau et important est à la ligne 34 : char msgString[12];

Juste un petit rappel concernant les chaines de caractères. Une chaîne de caractères (string) n’est rien d’autre qu’un tableau de caractères et se « manipule comme tout autre tableau ». Nous avons donc ici déclaré un tableau de caractères (char) ayant pour nom msgString et dont la taille est fixée ici à 12 (c’est la taille maximale du message pouvant être envoyé dans notre projet + un caractère de retour à la ligne ’\n’, inutile de gaspiller la mémoire avec un tableau plus grand). Pour accéder par exemple au premier caractère de la chaîne, il faut donc faire x = msgString[0]. Si vous n’êtes pas familier avec les tableaux d’une manière générale, je ne peux que vous inviter à creuser cette partie de la programmation qui est extrêmement puissante et utile.

Dans la loop, nous avons while (Serial.available()) et Serial.read() déjà rencontrés. Par contre sprintf est une fonction nouvelle que j’ai empruntée au langage C car elle aussi est très puissante.

On rencontre cette fonction une première fois ligne 62 :

  1. if (c == '<') { // Caractère délimiteur de début de message
  2. sprintf(msgString, "");
  3. }

Souvenez-vous dans le JavaScript : msgString = '<'+R_Slider.value+" "+V_Slider.value+" "+B_Slider.value+'>';

Nous avions ajouté ’<’ en début de message et ’>’ en fin de message. Ces caractères vont nous servir à délimiter le début et la fin du message. Ligne 62 du code Arduino, si le caractère rencontré est ’<’, alors notre tableau msgString est vidé : sprintf(msgString, "");

Au dessous, ligne 65 :

  1. else if (c == '>') { // Caractère délimiteur de fin de message
  2. process(msgString);
  3. }

Nous avons rencontré le caractère de fin de message, nous allons maintenant le traiter : process(msgString);

Mais en attendant, on exécute le code ligne 68 :

  1. else { // Caractères à l'intérieur du message
  2. sprintf(msgString, "%s%c", msgString, c);
  3. }

Nous allons ajouter (concaténer) les caractères du message dans notre tableau msgString et en même temps en faire la conversion au format string grâce là encore à la fonction sprintf(). Souvenez-vous précédemment que un « 1 » reçu était converti en « 49 » son code ASCII. Ici, un « 1 » reçu est bien converti en chaîne « 1 ».

Nous avons vu ligne 65 que quand tout le message avait été reçu, on appelait la fonction process avec notre tableau msgString en paramètre.

Cette fonction process est elle aussi complexe à appréhender mais vous allez le voir, elle est très puissante également. Dans un premier temps, ligne 39, nous allons déclarer trois variables de type int que nous allons nommer r, v et b.

Puis la fonction sscanf va convertir chacune des trois valeurs contenues dans msgString (et qui sont reconnues comme telles car séparées par des espaces) en décimal et placer ces valeurs décimales dans les trois variables r, v et b. C’est assez magique non ?

Vous avez sans doute remarqué que je suis obligé d’utiliser les pointeurs (*) et des références (&) mais si vous n’êtes pas familiers avec ces concepts, vous pouvez vous contenter de recopier ce code. Mais si vous voulez approfondir sur ces questions de pointeurs, je vous renvoie aux articles de Thierry sur ce sujet (articles Les pointeurs (1) et Les pointeurs (2)).

Vous comprenez bien que si vous aviez envoyé cinq valeurs par exemple (1234 12 12345 1 1234567), vous auriez eu à déclarer cinq variable, par exemple : int a, b, c, d, e ; et vous auriez récupéré la valeur de ces variable en décimal de la façon suivante : sscanf(msgString, "%d%d%d%d%d ", &a, &b, &c, &d, &e) ;

De la même façon, si nous avions envoyé non plus les trois valeurs RVB à la suite mais choisi de mettre une lettre puis la valeur, R 123 ou V 255, nous aurions décodé ce message de la façon suivante :

  1. Char color ;
  2. Int value ;
  3. sscanf(msgString, "%s%d ", &color, &value);

et la suite du code :

  1. if(color == 'R') {
  2. analogWrite(redLEDPin, value);
  3. }
  4. else if(color == 'V') {
  5. analogWrite(greenLEDPin, value);
  6. }
  7. else if(color == 'B') {
  8. analogWrite(blueLEDPin, value);
  9. }

Mais la première méthode est tout de même plus simple et moins « verbeuse ».

Pour la réponse aussi, j’ai eu recours à des fonctions empruntées au langage C lignes 46 et 47.

  1. snprintf(response, sizeof(response), "%d - %d - %d\n", r, v, b);
  2. Serial.print(response);

La fonction Serial.printf() n’est pas reconnue par Arduino. Il faut donc contourner.

Ligne 35, on créé un tableau de CHAR pour la réponse : char response[24]; // Tableau qui va recevoir les caractères de la réponse

Puis on va utiliser ligne 46 la fonction snprintf() pour formater notre réponse en y incluant les variables pour enfin envoyer la variable response avec un Serial.print() bien classique et bien connu.

Notez que sans cela le code Arduino aurait été plus long :

  1. Serial.print(r);
  2. Serial.print(" - ");
  3. Serial.print(v);
  4. Serial.print(" - ");
  5. Serial.print(b);
  6. Serial.print("\n");

Voilà donc au travers de cet exemple de la LED RVB comment on peut manipuler des chaines de caractère en langage C dans l’Arduino. C’est complexe mais en même temps si puissant que ça mérite à mon avis que l’on s’y intéresse.

Si vous souhaitez aller plus loin sur les questions de chaines de caractères, vous pouvez vous reporter à l’article de Thierry Les chaînes de caractères.

Nous voila arrivé à la fin de ce deuxième article où nous avons découvert les potentiomètres, accessoires très utiles dans nos montages Arduino. Mais nous avons également vu comment lire (facilement) des messages longs dans l’Arduino ce qui va nous permettre d’envisager l’envoi de commandes complexes avec de nombreux paramètres à l’intérieur.

Cela sera le cas dans l’article 3 où nous allons piloter un servomoteur et surtout dans l’article 4 où nous traiterons de l’envoi de commandes à DCC  ++ pour le pilotage de locomotives.

Comme d’habitude, n’hésitez pas à poser toutes vos questions pour autant quelles concernent le modélisme ferroviaire.

Réagissez à « Piloter son Arduino avec son navigateur web et Node.js (2) »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Programmation »

Comment gérer le temps dans un programme ?

La programmation, qu’est ce que c’est

Types, constantes et variables

Installation de l’IDE Arduino

Répéter des instructions : les boucles

Les interruptions (1)

Instructions conditionnelles : le if … else

Instructions conditionnelles : le switch … case

Comment gérer l’aléatoire ?

Calculer avec l’Arduino (1)

Calculer avec l’Arduino (2)

Les structures

Systèmes de numération

Les fonctions

Trois façons de déclarer des constantes

Transcription d’un programme simple en programmation objet

Ces tableaux qui peuvent nous simplifier le développement Arduino

Les chaînes de caractères

Trucs, astuces et choses à ne pas faire !

Processing pour nos trains

Arduino : toute première fois !

Démarrer en Processing (1)

Le monde des objets (1)

Le monde des objets (2)

Le monde des objets (3)

Le monde des objets (4)

Les pointeurs (1)

Les pointeurs (2)

Les Timers (I)

Les Timers (II)

Les Timers (III)

Les Timers (IV)

Les Timers (V)

Bien utiliser l’IDE d’Arduino (1)

Bien utiliser l’IDE d’Arduino (2)

Les derniers articles

Ces tableaux qui peuvent nous simplifier le développement Arduino


bobyAndCo

Processing pour nos trains


Pierre59

Piloter son Arduino avec son navigateur web et Node.js (3)


bobyAndCo

Piloter son Arduino avec son navigateur web et Node.js (2)


bobyAndCo

Démarrer en Processing (1)


DDEFF

Piloter son Arduino avec son navigateur web et Node.js (1)


bobyAndCo

Arduino : toute première fois !


Christian

Bien utiliser l’IDE d’Arduino (2)


Thierry

Bien utiliser l’IDE d’Arduino (1)


Christian, Dominique, Jean-Luc, Thierry

Les Timers (V)


Christian

Les articles les plus lus

Les Timers (I)

Les interruptions (1)

Comment gérer le temps dans un programme ?

Instructions conditionnelles : le if … else

Ces tableaux qui peuvent nous simplifier le développement Arduino

Répéter des instructions : les boucles

Calculer avec l’Arduino (1)

Les fonctions

Les Timers (III)

Piloter son Arduino avec son navigateur web et Node.js (1)