Pour piloter votre Arduino, vous pouvez utiliser des boutons, des interrupteurs ou encore des potentiomètres. Ils font d’ailleurs partie de tous les bons kits de démarrage.
Mais vous pouvez aussi rêver d’interfaces graphiques riches et esthétiques avec lesquelles vous pourriez commander votre Arduino depuis votre ordinateur, votre tablette ou encore votre téléphone portable. C’est par exemple le cas d’un TCO qui vous permettrait de commander tous les aiguillages de votre réseau ou de manettes pour piloter vos locomotives.
Processing est l’une des alternatives pour réaliser des interfaces graphiques dont la programmation s’apparente à celle de l’Arduino. Son utilisation se fait en lignes de code et repose sur Java.
Mais ce que je vous propose ici, c’est de recourir aux outils de création graphique du web qui sont particulièrement conçus pour produire facilement des contenus graphiques très esthétiques. Par ailleurs, il existe une multitude de bibliothèques qui vous offrent des contenus déjà créés, permettant de simplifier grandement le travail. Vous connaissez tous les glyphicons de Bootstrap sans savoir peut-être que ceux-ci proviennent de bibliothèques : plus d’infos sur les glyphicons
L’application de pilotage de locomotives que j’ai déjà présentée sur Locoduino (copie d’écran ci-dessus) n’utilise que des bibliothèques graphiques. A aucun moment je n’ai utilisé le moindre outil de dessin.
Et Node.js dans tout cela ?
Eh bien, c’est Node qui, installé sur votre ordinateur (ou tout ordinateur en réseau), va servir d’interface réseau entre la page web que vous aurez créé avec ses boutons et potentiomètres et la ou les cartes Arduino que vous souhaitez piloter. Notez que Node fonctionne sur Mac, Windows et Linux.
Node va-t-il m’obliger à ajouter un shield Ethernet sur mon Arduino ?
Non ! Node peut communiquer avec vos Arduino via le port série. A partir de là, votre Arduino équipé par exemple d’une carte CAN pourra relayer les messages à d’autres Arduino également équipés en CAN.
Mais au fait, c’est quoi Node ?
Tenter de définir Node en quelques lignes est impossible. Wikipédia nous donne la définition suivante : « une plate-forme logicielle libre et événementielle en JavaScript orientée vers les applications réseau qui doivent pouvoir monter en charge »
En réalité, Node offre côté serveur un environnement qui utilise le JavaScript et permet grâce à de très nombreuses bibliothèques de faire tourner des applications qui communiquent en réseau. Des serveurs web, mais pas que…
Par conséquent Node est une façon de développer une interface Web dans un serveur qui commande directement votre Arduino.
Pourquoi Node est-il autant plébiscité ?
Node est simple, puissant et rapide. C’est un environnement de bas niveau comme peut l’être le langage C par exemple. Node.js utilise le moteur d’exécution ultrarapide V8 de Google Chrome. Node s’est ainsi imposé sur des sites aussi célèbres que PayPal, Groupon ou Linkedln pour n’en citer que quelques uns.
Chez PayPal, on considère que Node c’est un tiers de lignes de code en moins, deux fois plus de requêtes traitées par seconde et la réduction d’un tiers du temps de réponse moyen.
Mais dans le contexte qui nous intéresse ici, à savoir, piloter un Arduino à partir d’un navigateur web, on va voir que son point fort est bien la simplicité. A peine une quarantaine de lignes de codes, programmées pratiquement une fois pour toute, quelque soit l’évolution de notre interface graphique ou les nouvelles pages que nous allons créer.
Avertissement : Node nécessite de travailler à l’intérieur du terminal en lignes de commandes. Cela demande une certaine connaissance de l’informatique. Néanmoins, une fois que votre serveur sera installé, vous n’aurez plus à y revenir. Par ailleurs, si vous êtes bien attentif et un peu motivé vous ne devriez pas rencontrer de difficultés particulières. Suivez précisément les consignes qui vous sont données.
Sous Windows, cela s’appelle l’invite de commande :
Pour commencer rapidement, nous allons reprendre les exemples d’OpenClassRooms. Avec n’importe quel éditeur de texte, vous allez créer un fichier en copiant le code suivant :
var http = require('http');
var server = http.createServer(function(req, res) {
res.writeHead(200);
res.end('Salut Locoduino !');
});
server.listen(8080);
console.log("Server Ok");
Ensuite, vous allez l’enregistrer au premier niveau de votre session. Pour Linux ou Mac, ça se passe dans le répertoire « user », au même niveau que le dossier « node_modules » (pas dedans). Pour Windows, il s’agit de « c :\Utilisateurs\VotreNom », ou « c :\Users\VotreNom » à partir de l’invite de commande, et le répertoire « node_modules » n’existe pas encore. Nommez le nouveau fichier « startNode.js ». Maintenant, dans le terminal, vous allez taper « node startNode.js ». Dans mon cas, sur mon ordinateur qui s’appelle Christophe, voici le message qui s’affiche :
Si tout c’est bien déroulé, vous allez ensuite avoir le message suivant :
Important : Pour ouvrir le terminal sous Windows, allez chercher Node dans vos programmes, puis développez avec la flèche à droite pour obtenir les différentes options (comme le montre la figure ci-dessous) et sélectionnez Node.js command prompt. L’autre solution est de n’importe où taper une fois sur la touche ’Windows’ à gauche de la barre espace pour ouvrir le menu ’Démarrer’, et sans rien sélectionner taper directement ’node’. Toutes les applications dont le nom commence par ’node’ s’afficheront, il suffira de lancer la bonne ! Une fois dans le terminal, pour récupérer l’invite de commande, il suffit de taper le raccourci clavier CTRL + C. Pour fermer le terminal, et donc sortir du programme Node, il suffit de taper exit suivi de la touche Entrée (Return).
Dans votre navigateur, entrez http://localhost:8080 comme url. Vous devriez voir apparaître le texte : Salut Locoduino !
Nous venons de créer un serveur web qui « écoute » sur le port 8080 et qui, quand on l’interroge, retourne un header 200 qui signifie « communication établie » et un texte qui s’affiche dans la page « Salut Locoduino ».
J’ai envie de dire, le plus dur est fait ! Nous allons maintenant faire évoluer le code exécuté par Node. Notez à la première ligne du code l’expression require('http'). C’est en quelque sorte l’équivalent de include en C. On demande à l’application de charger une bibliothèque particulière (pour Node, cela s’appelle un module). Ici, le module http qui fournit tout un certain nombre de fonctions. Nous allons utiliser d’autres modules pour simplifier la rédaction de notre code.
Pour qu’un module soit utilisable par Node, il devra avoir été chargé au moins une fois sur votre ordinateur. Pour ce faire, on tape dans la fenêtre du terminal npm install puis le nom du module. Ici, nous allons installer le module socket.io dont nous allons avoir besoin. Soit :
npm install socket.io.
Une petite précision concernant les installations de modules sur Mac. Il se peut que l’installation ne se soit pas bien déroulée simplement parce que vous ne disposez pas avec votre session des droits suffisants. Pour Linux ou Mac, il vous faudra alors taper sudo puis npm install socket.io soit en entier et sur une ligne :
sudo npm install socket.io.
Il vous sera alors demandé d’entrer le password d’administrateur et si celui-ci est correct, l’installation se poursuivra normalement. Pour Windows, la fenêtre de demande de confirmation d’accès administrateur s’affichera et vous n’aurez qu’à valider.
Le module socket.io va nous permettre de créer une communication synchrone et permanente avec le serveur. Ainsi, il vous sera possible d’envoyer des ordres à votre Arduino, mais cela nous permettra aussi de voir dans votre page web les messages que l’Arduino va retourner via la fonction Serial.print (ou Serial.println).
Nous allons en profiter pour installer deux autres modules dont nous allons avoir besoin. Un pour la manipulation de fichiers sur disque qui s’appelle fs et l’autre serialport qui va servir à envoyer les données par le port série à l’Arduino.
Nous allons également avoir besoin de modules pour la gestion des différentes pages web que nous allons créer. Ce sont les modules path et url.
Dans la fenêtre du terminal, nous allons donc taper :
npm install fs puis npm install serialport puis npm install path et enfin npm install url.
A chaque installation vous verrez peut-être des lignes s’afficher telles que :
Vous pouvez ensuite vérifier que les modules sont présents dans le dossier « node_modules ».
Vous allez maintenant placer tous les fichiers téléchargeables ici :
archive1
dans le répertoire où se trouve le dossier « node_modules », là où vous avez déjà placé « startNode.js ».
Avant d’aller plus loin, vous allez devoir modifier le fichier « serialport.js » qui est situé à l’intérieur des dossiers suivants : node_modules -> serialport -> lib -> serialport.js.
Ligne 32, vous allez entrez baudRate: 115200 au lieu de 9600 comme actuellement.
Enregistrez et fermez ce fichier.
Ouvrez dans l’IDE d’Arduino le sketch « power1.ino » et téléversez le dans votre Arduino.
Au passage, notez le port série auquel est connecté votre Arduino.
Dans le fichier « arduino.js », la première ligne indique : var usbserial = '/dev/cu.usbmodem1451';
Si le port série de votre Arduino ne coincide pas exactement avec cette ligne, alors changez le nom du port série dans cette ligne. Par exemple, sous Windows, si le module Arduino utilise le port COM4, vous aurez à changer cette ligne pour : var usbserial = 'COM4';
Dans la fenêtre de votre terminal, vous allez entrer « node arduino.js ». Le message Communication serie Arduino 115200 bauds : Ok vous indique que Node a réussi à communiquer avec la carte. Sinon, vérifiez la connexion de la carte au port USB.
ALLUMER OU ÉTEINDRE LA LED DE VOTRE ARDUINO A PARTIR DE VOTRE NAVIGATEUR
Sur la page qui apparaît, quand vous cliquez sur le bouton « on », la LED de la carte doit s’allumer et inversement quand vous cliquez sur le bouton « off ».
La ligne de logs sous les boutons affiche les messages retournés par l’Arduino. Ici 1 ou 0 selon que la LED est allumée ou éteinte.
Regardons tout d’abord le code de l’Arduino :
/*
* Eteindre ou allumer la LED_BUILTIN d'un Arduino en fonction du message reçu
* d'un navigateur web par l'intermédiaire de Node.js.
* Christophe BOBILLE juin 2017
*/
void process(unsigned char inChar) {
switch (inChar) {
case 48:
digitalWrite(LED_BUILTIN, LOW);
Serial.print("0");
break;
case 49:
digitalWrite(LED_BUILTIN, HIGH);
Serial.print("1");
break;
default:
Serial.print("error");
}
}
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
Serial.begin(115200);
}
void loop() {
while (Serial.available()) {
unsigned char inChar = (unsigned char)Serial.read();
process(inChar);
}
}
Dans le loop, la boucle while (Serial.available()) ligne 28 attend que quelque chose soit présent sur le port série. Quand c’est le cas, le caractère reçu est stocké dans la variable inChar. Je ne parle bien que d’un seul caractère, ce qui va être largement suffisant pour l’instant. Puis la fonction void process(unsigned char inChar) est appelée avec en paramètre le caractère reçu.
Dans cette fonction process, j’utilise un switch qui est beaucoup plus rapide et beaucoup plus clair quand vous souhaitez traiter un nombre important de cas. Si le caractère reçu est 48 alors on éteint la LED, si c’est 49, on l’allume. Et comme dans tout swich qui se respecte, je prévois tous les autres cas avec default qui signifie que si le message reçu ne correspond à rien de ce qui est attendu on retourne un message « error ».
Pourquoi case 48 ou case 49 dans le switch alors que nous verrons par la suite que ce sont les caractères « 0 » ou « 1 » qui vont être envoyés. C’est que dans la variable inChar, c’est la valeur ASCII du caractère que je récupère et non la valeur du caractère. Ce qui m’arrange beaucoup car il y a 127 codes ASCII pour 127 caractères. Un seul caractère me permet donc d’avoir un codage en 7 bits (127 possibilités différentes). En décimal, avec 1 caractère je ne couvre que la plage 0 à 9 puis il me faut 2 caractères pour 10 à 99 ce qui reste encore inférieur à mes 127 possibilités précédentes.
L’Arduino ne peut utiliser que les 127 premiers caractère de la table ASCII et ne connaît pas ce que l’on appelle la table ASCII étendue qui comprend en plus et entre autres les caractères accentués.
Mais j’aurais tout aussi bien pu écrire :
switch (inChar) {
case '0':
digitalWrite(LED_BUILTIN, LOW);
Serial.print("0");
break;
case '1':
digitalWrite(LED_BUILTIN, HIGH);
Serial.print("1");
break;
default:
Serial.print("error");
}
’0’ ou ’1’ entre simple quote sont la représentation du caractère. En effet char ’0’ est équivalent à char 48. Par contre "0" ou "1" entre double quote n’auraient pas fonctionné car ils représentent des chaines de caractères (string). Retenez qu’avec Arduino (et les langages C ou C++) un caractère s"écrit ’A’ alors qu’une chaîne s’écrit "A" même si elle n’a qu’un caractère.
Concernant le code JavaScript « arduino.js » qui sert à faire fonctionner notre application sur Node, je ne m’y attarderai pas. En effet, vous pouvez le considérer comme une bibliothèque sans savoir ce qu’il y a dedans. Aucune modification ne sera nécessaire pour tous les exemples que nous aborderons et bien probablement tout ce que vous voudrez créer par la suite. Mais je répondrai volontiers à tous ceux qui souhaiteraient avoir des informations complémentaires.
Comme indiqué plus haut, vous devrez tout de même régler un paramètre à la ligne 1 de ce fichier en entrant votre port série spécifique. Pour mon Uno ou mon Mega sur Mac, ce réglage est : var usbserial = '/dev/cu.usbmodem1451';. Sur Windows, cette variable sera du type var usbserial = 'COM3'; ou COM4...
var usbserial = '/dev/cu.usbmodem1451'; // Pour mon UNO et mon MEGA
//var usbserial = '/dev/cu.usbserial-AL02VFGY'; // Pour mon NANO
var http = require('http');
var fs = require('fs');
var path = require("path");
var url = require("url");
// Gestion des pages HTML
function sendError(errCode, errString, response) {
response.writeHead(errCode, {"Content-Type": "text/plain"});
response.write(errString + "\n");
response.end();
return;
}
function sendFile(err, file, response) {
if(err) return sendError(500, err, response);
response.writeHead(200);
response.write(file, "binary");
response.end();
}
function getFile(exists, response, localpath) {
if(!exists) return sendError(404, '404 Not Found', response);
fs.readFile(localpath, "binary",
function(err, file){ sendFile(err, file, response);});
}
function getFilename(request, response) {
var urlpath = url.parse(request.url).pathname;
var localpath = path.join(process.cwd(), urlpath);
fs.exists(localpath, function(result) { getFile(result, response, localpath)});
}
var server = http.createServer(getFilename);
// -- socket.io --
// Chargement
var io = require('socket.io').listen(server);
// -- SerialPort --
// Chargement
var SerialPort = require('serialport');
var arduino = new SerialPort(usbserial, { autoOpen: false });
/************ IMPORTANT ********
Pour fonctionner correctement, le fichier 'serialport' @ Users/node_modules/serialport/lib/serialport.js
à été modifié à la ligne 32
baudRate: 115200,
La communication série dans les sketches arduino doit être paramètrés à 115200 bauds : Serial.begin(115200);
*/
// Overture du port serie
arduino.open(function (err) {
if (err) {
return console.log('Error opening port: ', err.message);
}
else {
console.log ("Communication serie Arduino 115200 bauds : Ok")
}
});
// Requetes
io.sockets.on('connection', function (socket) {
// Message à la connexion
console.log('Connexion socket : Ok');
socket.emit('message', 'Connexion : Ok');
// Le serveur reçoit un message" du navigateur
socket.on('message', function (msg) {
//console.log(msg);
socket.emit('message', 'Veuillez patienter !');
arduino.write(msg, function (err) {
if (err) {
io.sockets.emit('message', err.message);
return console.log('Error: ', err.message);
}
});
});
});
arduino.on('data', function (data) {
let buf = new Buffer(data);
io.sockets.emit('message', buf.toString('ascii'));
console.log(buf.toString('ascii'));
//console.log(buf);
});
server.listen(8080);
console.log("Serveur : Ok");
Voyons maintenant le premier fichier HTML, power1.html correspondant à notre première application. Elle est très simple et contient deux boutons qui servent à allumer ou éteindre la LED de la carte reliée à la sortie 13 (LED_BUILTIN).
Information pratique. Pour avoir le rendu en temps réel du code HTML que vous rédigez, utilisez un éditeur on-line (et gratuit) comme celui de Mozilla qui est vraiment très bien. https://thimble.mozilla.org/fr/
A partir de la page d’accueil, cliquez sur créer un nouveau projet.
Un fichier HTML se structure autour de 2 balises principales, <head> jusqu’à </head> et <body> jusqu’à </body>. Dans le body se trouve le code de la partie visible de la page alors que dans le head se trouvent les « utilitaires ».
Dans le body, j’ai mis un texte entre balises <h1>Communication avec Arduino !</h1> qui va lui donner un aspect gros caractères en gras. Ensuite, j’ai créé un tableau entre les balises <table> et </table>. Je vous conseil de procéder ainsi surtout si vous n’êtes pas familier avec le HTML. Le tableau va vous aider considérablement à réaliser la mise en page de tous vos éléments graphiques. A ce tableau j’ai donné les propriétés width="100%" qui fait qu’il occupe toute la largeur de la page et border="1" qui place une bordure de 1 pixel autour. Pas très jolie je vous l’accorde mais qui nous permet pour l’instant de mieux repérer nos objets dans la page.
Un tableau HTML est toujours constitué d’au moins 1 série de balises <tr> </tr> qui permettent de créer des lignes au tableau. Ensuite, on créé les colonnes du tableau avec les balises <td> </td>.
Ici nous n’avons 1 ligne et 2 colonnes. Dans la première colonne, j’ai placé le code pour 1 bouton : <td><input type="button" value="On" id="btn_on" /></td>.
<input type="button" /> désigne un objet servant à recevoir une information « input » et que le type de l’objet est un bouton « type="button" ». « Value » est le texte apparaissant dans le bouton. Enfin, id="btn_on" est une information très importante. Cela sert à identifier de manière unique cet objet dans la page grâce à son « id ». Ici, c’est moi qui ai choisi le nom « btn_on ». Cela aurait pu être tout autre chose mais ne doit pas porter le même id qu’un autre objet de la page.
Dans la seconde colonne du tableau, j’ai un autre bouton : <input type="button" value="Off" id="btn_off" /> qui se distingue du précédent par son texte et aussi par son id="btn_off" qui précise bien je crois ce que fait le bouton.
Pour finir sur la partie affichage de cette page, on trouve en bas une zone de paragraphe entre <p> et </p> avec un texte « Logs : » est une zone dans laquelle viendra s’afficher entre <span> et </span> le message renvoyé par la fonction Serial.print de l’Arduino. De la même façon, vous remarquez que j’ai donné in « id » à cette zone : id="logs".
Dans le <head> je trouve un lien : <script src="http://code.jquery.com/jquery-1.10.1.min.js"></script> qui va charger une bibliothèque JavaScript externe très puissante nommée Jquery. Elle est chargée par internet.
La seconde bibliothèque : <script src="./socket.io/socket.io.js"></script> est aussi externe mais présente dans le dossier des modules de Node. Elle sert à la communication avec Node.
Enfin, une troisième balise <script> </script>. Ici, le code est interne à notre page car il est spécifique à notre application.
J’ai mis la première ligne en commentaire //$(document).ready(function() { car en Jquery ça veut dire exactement la même chose que $(function() { mais c’est plus explicite. Cela indique que le code sera exécuté quand la page HTML sera chargée (ready).
var socket = io.connect('http://localhost:8080'); sert à créer une instance pour la connexion avec Node. C’est un objet (au sens informatique) stocké dans une variable à laquelle j’ai donné le nom socket.
L’objet socket hérite d’un certain nombre de fonction dont .on(‘message’ qui se déclenche quand la page HTML reçoit un message du serveur Node. $('#logs') avec Jquery fait référence à la zone dont on parlait un peu plus haut. Celle à laquelle on a donné l’id=logs. $('#logs').html(message); indique d’écrire dans la zone « logs » le message qui sera reçu de Node, qui l’aura lui même reçu de l’Arduino.
Les lignes suivantes sont assez similaires dans leur compréhension. $('#btn_on').click indique un click sur le bouton ayant pour id « btn_on ».
socket.emit('message', '1'); appelle la fonction « emit » dont l’objet socket a hérité. C’est ici le second paramètre de la fonction qui nous intéresse, la valeur « 1 ».
indique que quand on clique sur le bouton ayant pour id btn_off, alors on va envoyer un message dont le contenu est « 0 ».
Notez bien que les valeurs « 0 » ou « 1 » envoyées par le message auraient pu être toutes autres, « a » ou « b » par exemple. Simplement, nous avons vu dans le code de l’Arduino que quand celui-ci reçoit le message « 1 » la carte allume la diode, et elle l’éteint si elle reçoit le message « 0 ». Tout ceci est donc purement conventionnel.
Si vous ouvrez la page web dans votre navigateur avec l’url : http://localhost:8080/power1.html, vous devez donc voir s’allumer ou s’éteindre la LED selon que vous cliquerez sur on ou sur off.
Il s’agit ici d’une bibliothèque graphique dans laquelle je vais puiser les icônes dont j’ai envie pour ma page. Vous avez ici : http://getbootstrap.com/components/ un aperçu des icônes disponibles.
Dans mes colonnes <td>, j’ai remplacé les boutons standards du HTML par des icônes et le curseur de la souris change au survol de ces icônes (cursor:pointer ;). Pour ce faire, j’ai créé deux divisions dans la page avec <span> et comme toute à l’heure, les id de ces <span> restent btn_on et btn_off.
Mais j’ai surtout ajouté des « class ». En fait, 3 classes par bouton. Les « class » glyphicon et glyphicon-off qui vont chercher dans la bibliothèque externe l’icône des boutons et les « class » btn_red et btn_green que j’ai créées dans le header entre les balises <style> et </style>. Ces classes déterminent, outre la couleur (red ou green) la taille (font-size:48px) et la modification de l’aspect du pointeur (cursor:pointer ;) au survol.
Tout le reste du code et en particulier le JavaScript est identique. Voici donc une évolution purement cosmétique avec par exemple un « margin-left:20px ; » appliqué au html qui décale la page du bord droit de 20 pixels.
html {
margin-left:20px;
}
La page : http://localhost:8080/power3.html apporte un résultat plus ergonomique. Il n’y a plus qu’un seul bouton dont la couleur change en fonction de l’état de la LED de l’Arduino. Plus besoin non plus de ligne de logs puisque la couleur suffit à nous donner l’information "on" ou "off".
Ici, contrairement à la page 2, la différence graphique est obtenue essentiellement par le JavaScript et non le style. On a supprimé un bouton en supprimant une colonne du tableau. Il ne reste que celui dont la « class » est « btn_red ». Le bouton sera donc rouge au chargement de la page (initialisation).
A l’intérieur de la balise <script> </script>, sous le commentaire // Initialisation on trouve une nouvelle ligne. La déclaration et l’initialisation d’une variable globale « status » à « 0 ». Puisqu’il n’y a plus qu’un seul bouton, la variable status enregistre l’état du bouton.
<script>
//$(document).ready(function() {
$(function() {
// Ouverture d'un socket avec le serveur
var socket = io.connect('http://localhost:8080');
// En cas de réception d'un message du serveur
socket.on('message', function(message) {
status = message;
if(status == "1") {
$("#btn").removeClass("btn_red");
$("#btn").addClass("btn_green");
}
else {
$("#btn").removeClass("btn_green");
$("#btn").addClass("btn_red");
}
});
// Sur click
$('#btn').click(function () {
if(status == "0") {
status = "1";
}
else {
status = "0";
}
socketEmit(status);
});
var socketEmit = function(status) {
var statusAscii = String.fromCharCode(status);
socket.emit('message', statusAscii);
}
// Initialisation
var status = "0";
socketEmit(status);
});
</script>
Pour la même raison, nous n’avons plus qu’une seule fonction « $('#btn').click(function () » qui modifie le statut du bouton à 1 s’il était à 0 et inversement. La fonction appelle non plus directement « socket.emit(’message’, value) ; » comme avant mais une fonction nouvelle « socketEmit (status) » que l’on retrouve juste en dessous. La chose la plus importante et nouvelle dans cette fonction est la ligne : var value = String.fromCharCode(status) ; Nous n’allons plus envoyer à l’Arduino le caractère « 0 » ou « 1 » mais grâce à « String.fromCharCode » directement le code ASCII 1 ou 0.
Nous verrons dans le fichier « power2.ino » que le switch est aussi modifié puisque c’est bien le code ASCII « 0 » ou « 1 » qui est reçu.
Bien évidemment, c’est le fichier « power2.ino » qu’il faut téléverser sur l’Arduino pour fonctionner avec ce fichier « power3.html ». Pour cela, il faut déjà libérer le port qui est utilisé par Node tout simplement en fermant le terminal ou en tapant ^C (control/C) ; une fois le téléversement terminé, vous pourrez rouvrir le terminal et entrer "node arduino.js" pour essayer ce nouvel exemple.
Dans le <body>, l’id de la <span> devient id="btn" puisqu’il n’y a plus qu’un bouton. Dans le JavaScript, dans la fonction sur click, la variable status change de valeur et c’est cette nouvelle valeur qui est envoyée à l’Arduino via Node.
// En cas de réception d'un message du serveur
socket.on('message', function(message) {
status = message;
if(status == "1") {
$("#btn").removeClass("btn_red");
$("#btn").addClass("btn_green");
}
else {
$("#btn").removeClass("btn_green");
$("#btn").addClass("btn_red");
}
});
Plus haut dans le JavaScript, à la réception du message retourné par l’Arduino, la variable status prend la valeur retournée : status = message;. Ce qui est surtout intéressant, c’est que l’on va ici modifier les class par programmation. En effet, si la LED est allumée if(status == "1"), on va supprimer la class btn_red$("#btn").removeClass("btn_red"); et ajouter la class btn_green » $("#btn").addClass("btn_green"); ce qui va avoir pour conséquence de donner au bouton la couleur verte.
Puis en dessus dans le JavaScript, l’effet inverse, $("#btn").removeClass("btn_green"); et $("#btn").addClass("btn_red"); si la LED est éteinte.
Nous avons donc modifié le style (css) de la page par programmation en fonction de la valeur de variables.
A la fin de cette expérimentation, n’oubliez pas d’arrêter le serveur node, soit en tapant ^C dans la fenêtre du Terminal, soit en quittant l’application Terminal, ce qui affichera la message suivant :
Voilà pour ce premier article, surement le plus difficile. Dans l’article suivant, nous nous intéresserons aux potentiomètres et ensuite encore, au pilotage d’un servomoteur pour terminer par une application très complète : Une manette de pilotage de locomotives avec DCC++.
N’hésitez pas à me poser toutes vos questions et j’essayerai d’y répondre au mieux.
Excellent article qui ouvre des possibilités incroyables.
Avez-vous examiné l’utilisation du codage graphique avec l’utilisation de node RED développé par IBM pour des applications de ’’Internet of things``IOT.
Je suis heureux que vous ayez perçu les possibilités que cela pouvait ouvrir de pouvoir piloter son Arduino à partir de son ordinateur, sa tablette et/ou son smartphone. C’est bien que vous citiez également Node RED auquel les plus convaincus pourront se référer. Pour l’essentiel, les Locoduinistes sont avant tout des modélistes ferroviaires, intéressés par ce que l’Arduino peut apporter sur leur réseau. Tout ce qui peut leur simplifier la tâche de programmation est bienvenu.
Moi je note au passage l’investissement de IBM autour des technologies JavaScript (Node RED, TypeScript...) ce qui tend à démontrer à mon avis sa puissance et son potentiel.
pour Node RED je viens de franchir le cap il à de ça une semaine, simple et rapide de mise en oeuvre. Il me permet de contrôler par wifi sur une tablette mes loco LGB avec un Wemos 1D (équivalent arduino nano avec wifi intégré). Il faut que je trouve un peu de temps pour mettre à jour mon fil sur le forum !
En protocole d’échange j’utilise MQTT (facile pour deboger).
Je trouve qu’il y a une accélération des offres en ce moment avec une multiplicité de produits nouveaux ; autours des technologies WIFI entre autres. Je suis convaincu qu’il y a plein de choses à imaginer en modélisme ferroviaire autour des modules WIFI (ESP8266) dont certains ont des tailles extrêmement réduites, jusqu’à 12 E/S et d’un prix quasiment ridicule, de 2 à 10 € !!! On peut entre autre réfléchir à des systèmes embarqués sinon dans des locos mais tout au moins dans les wagons d’un convoi. A quand les décodeurs WIFI ? Et pourquoi pas des réseaux totalement sans câbles ?
N’hésitez pas à présenter vos propres projets de la façon la plus explicite possible pour les partager avec tous les Locoduinistes. Node RED est assez abordable pour qui a une certaine appréhension à se lancer dans la programmation.
Merci pour cet article qui donne envie de s’y lancer.
ROCO a fait une tentative de décodeur Wifi (en fait une carte Wifi couplée à un décodeur DCC) avec ses kits Next Generation 51400 sortis en 2014. En prime une détection de Tag RFID pour la position des locomotives. Manifestement pour attirer vers le modélisme les enfants à partir de 6-8 ans avec des scénarios se déroulant sur tablette. Probablement trop répéfitifs sur un ovale et 3 arrêts. Une extension avec un aiguillage existe. Mais pas de version en français (seuls D, SP et GB). Malheureusement ce projet n’a pas rencontré le succès puisqu’on trouve ce matériel bradé à 75€ sur eBay et ailleurs et il n’est plus au catalogue de ROCO. Les locos 51400 sont canibalisés en éléments séparés. Le projet initial consistait en une rame ICE de 3 éléments alors que celui qui a été commercialisé contenait une locomotive électrique basique en rouge ou en bleu, sans aucun détaillage (pas de tampons, pantographe ultra simple) avec deux wagons. Avantage, on fait du numérique avec seulement de la technologie dans la locomotive (et du RFID à 3 sous) en supposant que la tablette est déjà acquise.
Il est peut-être possible de faire du reverse engeniering sur l’application android qu’on peut télécharger gratuitement. Je suis intéressé par tout détail qui serait disponible.
Ce projet est pourtant très innovant. Si je comprends bien, il y a un module WIFI embarqué dans la loco. Mais vous pensez vraiment qu’il y a un décodeur DCC ou quoique ce soit de similaire dans la machine ? A mon avis non. Les commandes passent en WIFI et le courant de traction par les rails. Un L293 lui aussi embarqué (et un µc) et le tour est joué. C’est exactement ce que j’évoquais plus haut avec les ESP8266. La fin des décodeurs embarqués est peut être pour bientôt ?
Pour le RFID, je ne m’y suis que très peu intéressé car j’étais resté sur l’idée qu’il était assez difficile de faire fonctionner plus d’un capteur (interférences). Apparemment non. Là aussi ce serait une très bonne nouvelle.
Quant à faire "du reverse engeniering sur l’application android" cela me semble assez facilement envisageable pour peu que l’on puisse décrypter les messages envoyés pour chaque commande et les reprogrammer dans un Arduino. C’est un peu du même ordre que lorsque l’on utilise une télécommande par exemple. Beaucoup de boulot en perspective.
Nous sommes bien d’accord que les projet que je présente : "Pilotage d’un Arduino avec son navigateur WEB" pourraient tout aussi bien fonctionner en WIFI. J’en ai d’ailleurs présenté plusieurs ici. Ce que nous voulions dans cette série d’article, c’était de proposer une configuration "minimaliste" fonctionnant sur le moins cher des Arduino (UNO) et sans shield ou hard quelconque supplémentaire.
Je travaille actuellement sur le protocole TELNET qui permettra de s’affranchir de la liaison série entre Node et Arduino (donc WIFI en particulier) en consommant très peu de ressources réseau contrairement au HTTP plus "verbeux" en travaillant directement sur les commandes TCP/IP de bas niveau. A suivre donc !
bonjour, j’ai pas réussi à faire communiquer NODE avec arduino en entrant la commande node arduino.js...
est ce que je rassemble tout les fichiers(serialport.js et arduino.js) dans un meme dossier et puis j’ouvre le terminal dans cette dossier...ou quoi faire ?
j’ai vraiment besoin d’aide je suis coincé...merci !
Je suis désolé mais reconnaissez que vous ne donnez que peu d’informations pour permettre de trouver une solution. Pouvez-vous être plus précis. Cette configuration est éprouvée depuis longtemps, moi-même, je l’utilise régulièrement. En suivant pas à pas les explications, il ne devrait pas y avoir de problème.
C’est effectivement dommage que Roco n’ait pas poursuivi. (et qu’il n’ait pas publié le standard pour amorcer une normalisation - du moins à ma connaissance) Il s’agit bien d’un "vrai" décodeur DCC respectant le standard. D’ailleurs Roco indique qu’il peut se piloter avec une Z21. J’ai testé avec DCC++ : adresse loco modifiable, commande éclairage par exemple. Si je me souvient bien du CV8, ce serait un ZIMO. Tant qu’on n’a pas pris la main sur la loco en Wifi, elle fonctionne en DCC.
Pour les applications en apk, il semble qu’il y ait de nombreux décompilateurs qui permettent d’avoir le code java. Mais cela dépasse mes compétences d’utiliser ensuite ce code.
Pour le RFID, il y a dans le ballast de la voie Geoline un circuit imprimé avec une antenne et un CI SOT8 de STI marqué 24LBERB K435U juste connecté à l’antenne.
Effectivement, on dérive du sujet initial, peut-être faudrait-il passer sur le forum ?
Oui il faut ouvrir un nouveau sujet sur le forum en précisant bien les objectifs poursivis et les réponses attendues. Il semble que pas mal de choses soient abordées ci-dessus.
Super Christophe j’ai enfin des explications du comment fonctionne DCC+_Controller_Ethernet que j’utilise avec plaisir sur mon réseau. J’attends ensuite les autres explications pour le DCC++. Pour le moment je suis indécis pour l’automatisation de mon réseau soit continuer avec tes explications futures ou utiliser "Un gestionnaire en C++ pour votre réseau" ? avec bus CAN. Sachant que mon réseau est découpé en cantons avec détection de consommation et des relais tout cela pas très satisfaisant. Un conseil serait le bien venu.
Bien cordialement.
Bonjour Christophe.
Merci beaucoup pour ces explications détaillées, en français et en détail... Même si je ne suis pas pratiquant ferroviaire, ma petite contribution pour les débutants comme moi :
_vérifier le comportement de l’arduino dans son environnement avec l’interface série intégrée : ctrl maj M
en envoyant directement 0 et 1.
_Chrome ne permet pas forcément de faire tourner des serveurs en adresse locale (secu) ; Firefoxe ne se limite pas a ca. Sous firefoxe utiliser F12 pour debugger. Ce qui m’a permis de voir que pour mon installation du 12/2017 il fallait modifier la ligne de la lib socket io comme suit :
./node_modules/socket.io-client/dist/socket.io.js
Mon but est de faire plus simple pour le moment : utiliser un script nodejs pour récupérer des infos sur le port série après l’émission d’une commande. Plus simple en python et en perl , moins simple avec nodejs et ses gestions parallèle d’événements, plus puissant a terme, c’est certain.
Bonjour,
Super, merci pour tous ces tuyaux. Juste une question j’aimerai bien savoir faire l’inverse j’ai besoin lorsque je clique sur une bouton passoire l’arduino envoi une requet via nodejs vers page html pour faire bouger quelque chose .
Besoin d’aide concernant ça.
Merci
Attention tout d’abord, un bouton "passoire" laisse tout passer ;-)
La question importante est de savoir ce que vous voulez faire bouger ? Un élément dans la page HTML, changer un bouton, faire varier un compteur ? Ou faire bouger autre chose (hors de la page HTML), moteur, LED ???
En fonction de cela la réponse sera bien différente.
Bonjour,
Ok je vais expliquer a vous , je dois travailler sur jeu snake,. Au lieu d’utiliser les fleche de calvier , le remplacer par Joystick de arduino , donc j’utiliser javascript via serveur NodeJs.
Donc actuellement je suis ressuie a faire allumé une led lorsque le snake tape le mur çàd gameouvre mais j’arrive pas a faire transmet un message de la part d’arduino vers le serveur.
Merci tout aide
Bonjour,
Votre question ne concerne pas le modélisme ferroviaire, mais voici la réponse (qui se trouve d’ailleurs dans l’article). Il faut tout simplement utiliser Serial.print ou Serial.write et un message sera retourné à Node.js. Dans l’exemple, la fonction retourne soit "0" soit "1" soit le texte "error" :
switch (inChar) {
case '0':
digitalWrite(LED_BUILTIN, LOW);
Serial.print("0");
break;
case '1':
digitalWrite(LED_BUILTIN, HIGH);
Serial.print("1");
break;
default:
Serial.print("error");
}
La réponse est captée par Node.js par l’événement "on(data)" de l’objet que j’ai nommé ici arduino
arduino.on('data', function (data) {
let buf = new Buffer(data);
io.sockets.emit('message', buf.toString('ascii'));
console.log(buf.toString('ascii'));
//console.log(buf);
});
Bonsoir Christophe,
J’ai testé exemple "power1.ino" avec arduino UNO en modifiant ’COM4’ ça fonctionne parfaitement.
Ensuite je change de carte pour ARDUINO MEGA mais en ’COM6’ comme me l’indique IDE que je modifie et j’ai comme message "Logs : Connexion : Ok" j’appuie sur le bouton ON et j’ai comme message "Logs : Veuillez patienter !".
Où est le problème ? j’ai cherché dans les programmes je n’ai même pas trouvé la provenance du message "Logs : Veuillez patienter !"
Merci de m’aider, j’attendais depuis longtemps la dernière parution de NODE 4 et maintenant que c’est fait je souhaite transformer tout mon travail de ETHERNET_DCC++ en NODE.
REBonsoir Christophe,
Ne tiens pas compte de mon précédent message tout fonctionne maintenant...
Ne me demande pas pourquoi, j’ai tout réinitialisé NODE, POWER1, etc... et ça marche.
Je passe à l’étape suivant me passer de ETHERNET_DCC++ et programmer une occupation d’une ZONE par le NODE.
Bonsoir.
J’ai testé exemple "power1.ino" avec arduino UNO en modifiant ’COM3’.
J’ai comme message "Logs : Connexion : Ok" suite à l’ouverture de la page html
Lorsque j’appuie sur le bouton ON,j’ai comme message "Logs : Veuillez patienter !".
J’ai modifié les programmes de façon à tester le passage d’infos entre la page html et mon arduino. Celui-ci détecte bien lorsque j’appuie sur le bouton ON ou OFF (modif prog arduino pour détecter si quelque chose est emis sur la liaison série). Je pense que j’ai un pb avec la reconnaissances des variables char transmises entre la page html et l’arduino mais je vois pas comment le résoudre.
Si je comprends bien, vous avez modifié le programme de l’Arduino. Il faudrait m’adresser via la messagerie de Locoduino le code Arduino pour que je regarde ce que cela peut être.
J’ai voulu tester votre exemple "power1.ino" avec un arduino UNO en modifiant ’COM3’.
Lorsque j’utilise la page html : power1.html, j’ai comme message "Logs : Connexion : Ok" suite à l’ouverture de la page html => la connexion PC —> Arduino se déroule bien
Mais lorsque j’appuie sur le bouton ON,j’ai comme message "Logs : Veuillez patienter !" => pas d’allumage de la led 13.
J’ai redémarré le pc, relancé la communication série et tj impossibilité de faire allumer la led (nota : je n’ai pas modifié vos programmes)
Cordialement
J’ai repris les manips à zéro en suivant pas à pas votre tuto :
1) modification de la vitesse de connexion de 9600bd à 115200 dans serialport.js (on trouve aussi 9600 dans les premières ligne du fichier, à modifier en 115200 ou seulement modif ligne32 ?)
2) modification du nom du port dans arduino.js
3) telechargement du sketch power1.ino dans mon arduino
4) lancement du serveur web arduino.js dans le terminal
=> message
Serveur : OK
Communication serie Arduino 115200 bauds : Ok
Connexion socket : OK
6) clic sur bouton On => la led reste éteinte et affichage o à coté de Logs.
7) clic sur bouton Off => la led reste éteinte et affichage ? à coté de Logs
=> Il y a bien un dialogue entre la page html et l’arduino mais j’ai l’impression que les caractères Ascii sont mal retransmis.
Je pense que votre analyse doit être bonne et qu’il s’agit probablement de problèmes de caractères puisque vous avez bien un retour de l’Arduino :
6) clic sur bouton On => la led reste éteinte et affichage o à coté de Logs.
7) clic sur bouton Off => la led reste éteinte et affichage ? à coté de Logs
Cela peut avoir plusieurs causes. Il est possible que le paramètre de vitesse de transfert dans serial.js influe. Dans ma version, je n’ai de réglage qu’à la ligne 32. Si vous avez 9600b ailleurs (version plus récente), n’hésitez pas à changer, et à tester.
Dans le terminal (invite commande) doivent s’afficher 0 ou 1 quand vous appuyez sur les boutons de la page HTML, quand est il pour vous ?
En stoppant le terminal et en utilisant la fenêtre série de l’IDE d’Arduino, envoyez le caractère 1 à la carte et voyez si vous avez un retour 1. Vous allez avoir sans doute aussi plusieurs "error" mais c’est parce que la fenêtre de l’IDE envoie d’autres caractères mais l’important est que vous ayez bien 1 ou 0 dans les retours. Si vous voulez supprimer les error, selectionnez "pas de fin de ligne" dans la fenêtre de l’IDE.
Voilà, de cette manière, vous voyez déjà si la carte répond et allume ou éteint la LED. Ensuite, dans la page HTML (javascript) modifiez le code à partir de la ligne 15
Bonsoir Christophe,
Merci pour votre réponse très détaillée. Je suis allé voir le contenu de mon fichier serial.js : je n’ai effectivement pas la même version que vous et j’avais un pb de paramétrage. Il faut en réalité changer le paramétrage de vitesse au début du fichier. J’avais changé la vitesse dans une zone de commentaire (avec le bloc note de windows, la lecture du fichier n’est pas très pratique ...) Est-ce qu’il existe des utilitaires plus pratiques avec numérotation des lignes ?
J’ai fait le test d’allumage/extinction de la led dans la fenetre de l’IDE d’Arduino et cela a fonctionné.
=> la Led réagit correctement aux clics sur On et Off. J’ai 1 et 0 en retour dans la zone LOGS.
Merci encore. Grace à votre dernier message, j’ai réussi envoyer des cdes à mon arduino et à récupérer des données via une page htlm.
Mon projet est de faire l’acquisition d’une température avec un capteur DS18B20 et d’afficher celle-ci sur une page html.
J’ai maintenant les outils de base pour le faire. J’ai modifié mon programme d’acquisition et traitement de température et j’arrive à faire afficher celle-ci sur la page power1.html dans la zone LOGS (je n’ai pas encore de compétences en html) mais par moment l’affichage est tronqué :
ex : 22.5 C puis affichage C puis 5 C.
A votre avis, d’où vient ce phénomène ? Est-ce un pb de vitesse de transmission de donnée qui serait trop lent par rapport au traitement de la mesure dans l’arduino ?
Je réponds à votre message car il présente un caractère général, mais je vous rappelle que le site Locoduino est réservé au modélisme ferroviaire.
mais par moment l’affichage est tronqué : ex : 22.5 C puis affichage C puis 5 C.
Ce problème est sans doute lié à une question de vitesse en effet. J’ai depuis réglé le problème de la manière présentée ci-dessous dans le fichier e Node.js
Dans la réponse de l’Arduino, je place un caractère de fin de message, ici ">". Dans le code de Node js, je concatène les messages reçu dans la variable responseServ jusqu’à ce que je trouve le caractère ">" if(responseServ.indexOf(">") > 0 ) {
Et alors j’envoie le message "complet" à la page HTML.
Vous parlez d’une modification à apporter au fichier e node.js ou node.js ?
Où se trouve ce fichier ? Est-ce que vous parlez du fichier arduino.js qu’on lance pour communiquer avec la carte ? Merci pour votre aide
Bon, ça relève plus du PC que de l’Arduino. Ca peut avoir pas mal de causes. Avez-vous réussi toutes les installations précédentes ? Node bien sûr mais aussi les autres modules ? Ceci pour savoir si on a le même problème sur d’autres modules ou seulement sur serialport ? Je vois qu’il est question de Phyton (Can’t find Python executable "python", you can set the PYTHON env variable.) Il est maintenant assez courant de devoir installer Python pour executer des scrits d’installation.
Attention aussi, si vous installez serialport, il y a dans la version actuelle des incompatibilités avec ce que j’ai écrit à l’époque avec une version antérieure. Il faudra un peu chercher, en particulier en ce qui concerne les vitesses sur le port série mais rien de très compliqué.
Est-il important pour vous d’utiliser Node car je présente en effet de nouvelles solutions plus simples et tout aussi performantes en WiFi et sans Node. Voir ici : Controller DCC++ Base Station en WiFi
A voir également l’ébauche d’un article dont je prépare la publication sur Locoduino au sujet des shieldes WiFi
Je n’ai encore pas écrit grand choses mais si cela vous intéresse mieux, je peux m’y mettre ce qui en intéressera d’autres.
Merci pour votre réactivité.
Je voudrais pouvoir commander mon arduino par ethernet au final avec des échanges de données simple, visualiser les état des In/Out et possibilité de les commander à distance.
j’ai un shield ethernet et je suis en train de faire un tuto en parallèle (beaucoup d’info).
Node me paraissait une bonne solution pour personnaliser l’interface Homme / machine.
Je débute le JS et dans mon projet la communication série ne me parait pas nécessaire (sauf pour faire ce superbe tutoriel).
Oui, ça va toujours mieux quand on commence par le besoin. Pouvez-vous présenter succinctement votre projet ?
Il y a une solution avec le shield Ethernet qui consiste à héberger un mini site, en fait une application en HTML et JavaScript sur une carte SD elle-même hébergée dans le lecteur SD du shield Ethernet.
J’aborde cela en détail avec un mini-controller que je présente ici sur Locoduino.
On pourra alors utiliser de classiques requêtes http (POST ou GET) mais aussi des requêtes en TCP (moins gourmandes en ressource et plus réactivites) Probablement aussi des websockets.
Tenez-moi au courant pour savoir si cela répond à votre attente et je vous aiderai au besoin.
Bonjour,
je viens juste de tester le pilotage de mon Arduino par navigateur web ainsi que vous l’avez très bien décrit. J’ai un problème, il ne m’est pas possible de modifier le fichier serialport.js tout simplement parce que ce fichier est absent du répertoire \node_modules\serialport malgré deux tentatives de recharger par install dans la fenêtre Node.js command prompt.
Pouvez-vous m’aider à résoudre ce problème ?
Merci.
j’ai lu le post "Piloter son Arduino avec son navigateur web et Node.js (1) 4 avril 22:00, par Thierry " ainsi que votre réponse. (le pilotage de la led port 13 fonctionne sans soucis avec par exemple "blink.ino")
J’ai rencontré le même problème. Il faut indiquer la vitesse dans le fichier arduino.js à la ligne 45. Ajoutez le paramètre baudRate:115200 devant autoOpen : false
Uhmm, uhmm, c’est bien embêtant en effet. Mais je pense que l’on devrait trouver une solution simple en recopiant le dossier complet dans le bon repertoire sur votre ordinateur. Envoyez moi votre mail en MP, je vous retournerai le dossier à recopier et ça devrait fonctionner.
moi je fais ex 192.168.1.50:8080/bb.js je tombe sur la page mais mon soucis, quand j’appuie sur la touche d’une commande rien ne se passe. sur le pc ou il y a le serveur par contre cela réagis.
Si le PC fonctionne mais pas le téléphone, c’est que ce dernier doit avoir des paramètres de sécurité activés (étonnant cependant). Je n’ai pas de réponse, il faut faire des recherche sur le net.
Slt, je recherche. je sous ubuntu. c’est peut etre pour cela que je suis bloqué. un probleme de sécurité. J’ai accés à ma page html, mais non executable. je cherche et reviens vers vous une fois fait.
Bonjour, je suis bloqué, il est écrit qu’il faut modifier le fichier intitulé "serialport.js", mais je ne le trouve pas. Je suis pourtant bien allé dans : Utilisateurs/totol/node_modules/serialport/lib mais je ne trouve que "index" et "parsers".
je rencontre exactement le même problème, j’ai essayé une solution qui a été donnée plus haut, mais en vain !!! Avez-vous trouver une solution à cela ?
Bonjour
Visiblement tout cela semble simple pour tout le monde sauf pour moi. Etape 1
J’ai suivi scrupuleusement l’installation Etape 2
je lance donc node, dans la fenêtre (Dos) je tape : node startNode.js réponse Thrown
node startNode.js
Syntax error : Unexpected identifier
Quelle en est la raison ? Grand mystère
Serait-il possible d’avoir un élément de réponse ?
Merci par avance
Cordialement
Dans un fichier que vous nommerez "test.js", écrivez ceci : console.log("Hello Rolland !") ;console.log("Node.js fonctionne !") ;
ensuite, de le terminal (invite commande sous "Fenêtres"), entrez node test.js
S’il n’affiche pas le message, "Hello Rolland !, Node.js fonctionne !" c’est déjà qu’il y a un problème dans l’installation de Node.js
Merci pour votre réponse, problème solutionné.
J’avais sauté une étape.
En fait je n’ai pas lancé la fonction "cmd" pour pouvoir avancer.
Tout fonctionne parfaitement.
Ces explications sont vraiment formidables.
Beaucoup de temps passé pour les rédiger mais cela permet de découvrir d’autres possibilités
Cordialement
serialport est un module de Node. Quand on excecute NPM comme indiqué, serialport est automatiquement placé dans le répertoire : node_modules -> serialport -> lib -> serialport.js
Cela aussi je l’indique dans l’article :
Avant d’aller plus loin, vous allez devoir modifier le fichier « serialport.js » qui est situé à l’intérieur des dossiers suivants :
node_modules -> serialport -> lib -> serialport.js.
Bonjour,
Pour répondre à vos questions sur le fichier "serialport.js", celui-ci n’est plus dans les dernières distribution de Serialport.
Il faut toutefois modifier la vitesse pour que ça fonctionne et ne pas avoir d’erreur de transimission. Pour cela, une fois Serialport installé (avec npm install serialport), il faut aller dans ouvrir le fichier : "index.js" dans \node_modules\@serialport\stream\lib . Dans ce fichier, ligne 14 (dans ma version), il faudra changer "baudRate : 9600," par "baudRate : 115200,".
J’espère que ça vous sera utile et merci pour ce tuto.
Bonne journée
Bonjour
Je me heurte à des problèmes de version (entre 2022 et 2018) qui nécessitent des modifications dans les programmes ou les bibliothèques. Je n’y entends pas grand chose et je me déplace dans un "brouillard informatique".
J’ai réussi à suivre votre tuto (dans la forme assez clair) jusqu’à la modification : "node_modules -> serialport -> lib -> serialport.js. "
J’ai la version 16.15.0 de Node dans laquelle je ne trouve aucun dossier "lib" ni dans "@serialport/stream" ni dans "serialport". Donc pas de modification possible de débit dans un fichier "index".
Par ailleurs j’ai modifié (comme conseillé) la ligne 40 du fichier "arduino.js" mais il reste toujours à intervenir sur la ligne 45 : "var arduino = new SerialPort(usbserial, autoOpen : false ) ;" qui bloque.
Pourriez vous m’aider svp.
Emmanuel
tout ,d’abord bravo pour l’article !
j’ai réussi avec la version actuelle de node.js a obtenir la commutation de la LED sur mon Arduino Uno.
j’ai rencontré plusieurs problèmes (dus au décalage de version je pense, j’utilise Windows 10 - NodeJS 16.13.0 (avec npm 8.1.0)) :
1) serialport.js qui n’existe plus et le paramétrage de la vitesse à faire comme indiqué dans le message précédent
2) index.js la ligne 40 doit etre modifiée de :
var io = require(’socket.io’).listen(server) ;
pour devenir :
var io = require(’socket.io’)(server) ; // on supprime .listen qui donne une erreur "listen is not a function" sinon...
je continue la suite de l’article pour créer ma propre IHM
Olivier
Cet article à maintenant 5 ans et les choses ont beaucoup évoluées depuis. La bibliothèque « serialport » pour Node.js elle aussi a beaucoup évoluée et n’est plus directement compatible avec ce que j’avais écrit à l’époque.
Et les websockets en JavaScript ont aussi fait leur entrée dans le paysage !
Je suis absent pour plusieurs semaines et je n’ai pas avec moi le matériel pour tester des mises à jour et je ne suis pas sûr d’en avoir le temps.
Si vous voulez avancer sur ce sujet, vous pouvez vous reporter au site de serialport : https://serialport.io/
Effectivement aujourd’hui (janv.2023), la version actuelle de Node.js et du module SerialPort sont différents de ce qu’ils étaient eu début de cet article. Voilà ce qu’il faut faire.
Il n’y a pas de modifications à faire dans node_modules/serialport/lib/serialport.js, ce fichier n’existe plus.
Toutes les modifications sont à faire dans le fichier arduino.js :
la modification de la ligne 1 concernant le port série reste d’actualité var usbserial = 'COM3';
la ligne 40 devient var io = require('socket.io')(server);
au lieu de var io = require('socket.io').listen(server);
les lignes 44 et 45 devienent
var { SerialPort } = require('serialport');
var arduino = new SerialPort({ path: usbserial, baudRate: 115200, autoOpen: false });
au lieu de
var SerialPort = require('serialport');
var arduino = new SerialPort(usbserial, { autoOpen: false });
Bonjour
Je suis très intéressé par votre article.
Jusqu’a cette étape tout ce passe bien, mais je suis coincé au niveau du fichier node_modules -> serialport -> lib -> serialport.js.
Dans serial port il n’y a pas ou plus le dossier LIB.
Il y a bien un fichier serialport.js mais dans le dossier node_modules>serialport>dist>serialport.js. pas LIB
Quand j’ouvre serialport avec bloc note mais aucune ligne concernant la vitesse de connexion à modifier.
De ce fait pas de communication avec arduino.
Voila le message d’erreur
C :\Users\domin>node arduino.js
node:internal/modules/cjs/loader:1051
throw err ;
^
Error : Cannot find module ’C :\Users\domin\arduino.js’
at Module._resolveFilename (node:internal/modules/cjs/loader:1048:15)
at Module._load (node:internal/modules/cjs/loader:901:27)
at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:83:12)
at node:internal/main/run_main_module:23:47
code : ’MODULE_NOT_FOUND’,
requireStack : []
Node.js v20.9.0
Avez-vous une solution ou est ce que je ne cherche pas au bon endroit ?
Cordialement
Bonjour
je viens de voir les modifications a faire dans le fichier arduino.js
Je viens de les réalisées par des copier coller mais toujours pas de communication.
Le port COM 3 est utilisé et bien réglé en vitesse 115200.
Pour l’instant bloqué.
Quand pensez vous
Cordialement
Bonsoir
merçi de votre réponse.
J’ai fait un copier coller du fichier arduino.js et mis dans le meme dossier que startNode et la j’ai la communication OK.
Je continu la lecture de ce projet.
Cordialement
