Fabriquer un robot connecté au Web (pour environ 500 $) (à l'aide d'un Arduino et d'un netbook) : 6 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:11

Ce Instructable va vous montrer comment construire votre propre Robot Web Connecté (à l'aide d'un micro-contrôleur Arduino et Asus eee pc). Pourquoi voudriez-vous un Robot Web Connecté ? Pour jouer avec bien sûr. Conduisez votre robot de l'autre côté de la pièce ou à travers le pays, en utilisant rien de plus que Skype et un navigateur Web (rien à installer sur l'ordinateur de contrôle). Après ça? Creusez dans le logiciel et adaptez-le comme vous le souhaitez, ajoutez un GPS pour voir où vous conduisez sur une carte, ajoutez des capteurs de température pour cartographier les gradients de température dans votre maison, ou des capteurs de sonar pour ajouter des contrôles sur ce que vous êtes sur le Web les conducteurs peuvent et ne peuvent pas rencontrer. Caractéristiques:

• Bon marché - (~ 500 $ si vous achetez toutes les pièces neuves et considérablement moins cher si vous fouillez dans votre bac à pièces)
• Une fois opérationnel, le contrôle du robot ne nécessite qu'un navigateur Web - (et Skype si vous voulez voir où vous conduisez)
• Open Source et facilement adaptable - (utilise un micro-contrôleur Arduino, le traitement pour le serveur Web et tous les logiciels peuvent être exécutés sur Linux (tout le code est également fortement commenté pour faciliter le saut et le changement))
• Conception modulaire (pas un système complètement intégré, si vous souhaitez utiliser un service de visioconférence différent pas de soucis, ou si vous avez un tampon de base plutôt qu'un Arduino, ajustez juste un petit morceau de code et insérez-le)

Voici une vidéo rapide de mon robot connecté au Web en train d'être chassé de la cuisine.

Étape 1: Pièces et outils

Seules quelques pièces sont nécessaires:Robot: Robot servocommandé Arduino - (SERB) (175 $ @ oomlout.com) ou (créez le vôtre)

Un robot open source qui utilise un microcontrôleur Arduino comme cerveau

(n'importe quelle plate-forme de robot servo double avec un arduino peut être utilisée (option 1) (veuillez m'envoyer un message si vous découvrez d'autres options)Ordinateur: Asus eee PC 4G (280 $) (@Best Buy)

Un petit ordinateur portable bon marché qui est parfait à cet effet

(n'importe quel ordinateur portable (ou ordinateur de bureau si vous souhaitez utiliser un accord) capable d'exécuter des esquisses de traitement peut être utilisé) Bureau d'ordinateur portable: acrylique découpé au laser (25 $ (@ oomlout)) ou (construisez votre propre étape 3)

Quelques pièces acryliques supplémentaires qui se boulonnent sur un (SERB) pour lui donner un bureau sur lequel l'ordinateur portable peut s'asseoir

Noix et bols: (disponibles chez Home Depot)

• Boulon de 3 mm x 10 mm (x4)
• Boulon de 3 mm x 15 mm (x4)
• Écrou 3mm (x8)

Étape 2: Découpe des pièces et assemblage

Il existe trois options pour obtenir des pièces pour votre bureau d'ordinateur portable. Option de coupe 1: (Achat sur oomlout.com)

les pièces de bureau découpées au laser et le matériel nécessaire sont disponibles chez oomlout pour 25 $ (ici)

Option 2: (Découper sur votre propre découpeur laser ou Ponoko.com)

• Téléchargez le fichier ci-dessous (03-WEBB-Acrylic Parts.cdr ou 03-WEBB-Acrylic Parts (Ponoko P2).eps)
• Coupez-les dans de l'acrylique de 3 mm (1/8")

Option 3: (Scie à chantourner)

• Téléchargez le modèle de scie à chantourner ci-dessous (03-WEBB-ScrollSaw Pattern (A4).pdf (pour le papier au format A4) ou 03-WEBB-ScrollSaw Pattern (letter).pdf (pour le papier au format lettre))
• Vérifiez qu'il n'a pas été mis à l'échelle lors de l'impression (en mesurant les règles imprimées)
• Collez sur un morceau d'acrylique de 3 mm (1/8") et découpez les morceaux.

Assemblage: Téléchargez le guide d'assemblage (04-WEBB-Assembly Guide.pdf) ci-dessous et assemblez le bureau pour ordinateur portable.

Étape 3: Logiciel - (Arduino)

Pour ceux qui découvrent Arduino, consultez le grand guide de démarrage sur Arduino.cc Tout d'abord, le logiciel s'exécutant sur l'Arduino. C'est un programme très simple, ce que fait l'Arduino est de surveiller son port série pour les données. Ce qu'il recherche, c'est une conversation de 5 octets.

• Octet 1-3 (Vérifier les octets "AAA")
• Commande Octet 4 (Dit à l'arduino quoi faire) (Commandes prises en charge 'F' - Avant, 'B' - Arrière, 'L' - Gauche, 'R' - Droite, 'S' - Vitesse, 'X' - SetSpeedLeft, 'Y' - SetSpeedRight, 'C' - Stop)
• Paramètre Octet 5 - Pour les commandes de mouvement, cela est interprété comme un intervalle de temps (Paramètre * 100 ms), et pour les commandes de vitesse un pourcentage de 0 à 100

Le code est commenté de manière approfondie et compte tenu de ce framework, l'ajout de commandes supplémentaires devrait être facile. Pour télécharger:

• Téléchargez le fichier zip ci-joint. (05-WEBB-Code Arduino.zip)
• Décompressez dans votre répertoire Arduino Sketch. (par défaut: Mes Documents\Arduino)
• Ouvrez votre environnement de développement Arduino et téléchargez-le sur votre Arduino.

Pour copier et coller

• Copiez le code ci-dessous.
• Coller dans l'environnement de développement Arduino.
• Téléchargez sur votre Arduino.

Annexe: Le programme Arduino

/* * Arduino Controlled Web Connected Robot (WEBB) - Serial Host * Pour plus de détails, visitez: https://www.oomlout.com/serb * * Comportement: L'Arduino écoute son port série pour une commande * au format 254, 88, 88, (COMMANDE), (TEMPS) * Commandes prises en charge - &aposF&apos - 70 - Avant * &aposB&apos - 66 - Arrière * &aposL&apos - 76 - Gauche * &aposR&apos - 82 - Droite * &aposS&apos - 83 - Vitesse * &aposX&apos - 88 - SetSpeedLeft * &aposY&apos - 89 - SetSpeedRight * &aposC&apos - 67 - Stop * Temps pris en charge - 0 - 255 (0 à 25,5 secondes) valeur * 100 millisecondes *sp * Câblage: Signal servo droit - broche 9 * Signal servo gauche - broche 10 * * Licence: Ce travail est sous licence Creative Commons * Attribution-Share Alike 3.0 Unported License. Pour * afficher une copie de cette licence, visitez * https://creativecommons.org/licenses/by-sa/3.0/ * ou envoyez une lettre à Creative Commons, 171 Second * Street, Suite 300, San Francisco, California 94105, * ETATS-UNIS. * */ //----------------------------------------------------------- ----------------------------//DÉMARRAGE DU SERVEUR SÉRIE ARDUINO PRÉAMBULE//Définition des constantes correspondant à chaque commande (également le numéro de code ascii) #define FORWARD 70 //F#define BACKWARD 66 //B#define LEFT 76 //L#define RIGHT 82 //R#define SETSPEED 83 //S#define STOP 67 //C#define SETSPEEDLEFT 88 //X #define SETSPEEDRIGHT 89 //Y/*Les trois octets de contrôle (utilisés pour empêcher le robot de répondre aux *données série aléatoires) actuellement "AAA" */#define checkByte1 65 // "A"#define checkByte2 65 // "A "#define checkByte3 65 // "A" //-------------------------------------- ------------------------------------// DÉBUT DU SERVO ROBOT COMMANDÉ ARDUINO (SERB) PRÉAMBULE#include #define LEFTSERVOPIN 10 //La broche à laquelle le servo gauche est connecté#define RIGHTSERVOPIN 9 //La broche à laquelle le servo droit est connecté Servo leftServo; Servo droitServo; int leftSpeed = 50; //contient la vitesse des robots leftServo //un pourcentage entre 0 et 100int rightSpeed = 100; //maintient la vitesse des robots rightServo //un pourcentage entre 0 et 100// FIN DU ROBOT SERVO CONTROLE ARDUINO (SERB) PREAMBULE //------------------- -------------------------------------------------- -----//Récupère tout void setup() { Serial.begin(9600); //Démarre le port série serbSetup(); //définit l'état de toutes les //broches nécessaires et ajoute des servos à votre croquis}//Le programme principal loopvoid loop() { serbPollSerialPort(); //regarde en permanence le port série //s'il y a des données, il les traite}//------------------------------ -----------------------------------------//DÉMARRAGE DES ROUTINES DU SERVEUR SÉRIE ARDUINO/ * * Traite les commandes envoyées au port série arduino&aposs */void serbPollSerialPort(){ int dta; //variable pour contenir l'octet série if (Serial.available() >= 5) { //si 5 octets sont dans le tampon (longueur pf une requête complète) dta = Serial.read(); if (dta = checkByte1){ //Vérifie le premier octet de contrôle dta = Serial.read(); if (dta = checkByte2){ //Vérifie le deuxième octet de contrôle dta = Serial.read(); if (dta = checkByte3){ //Vérifie le troisième octet de contrôle int command = Serial.read(); //Le quatrième octet est la commande int param1 = Serial.read(); //Le cinquième octet est param1 interpretCommand(command, param1); //envoie la requête analysée à it&aposs handler } } } }}/* * Prend la commande et le paramètre et les transmet au robot */void interpretCommand(int command, int param1){if (command == FORWARD){goForward(); délai (param1 * 100); goStop();} //si en avant else if(commande == BACKWARD){goBackward(); délai (param1 * 100); goStop();} //si en arrière else if(commande == LEFT){goLeft(); délai (param1 * 100); goStop();} //si gauche else if(commande == RIGHT){goRight(); délai (param1 * 100); goStop();} //si à droite else if(commande == SETSPEED){setSpeed(param1);} //si réglage de la vitesse else if(commande == STOP){goStop();} //si stop else if(command == SETSPEEDLEFT){setSpeedLeft(param1);} //si réglage de la vitesse à gauche else if(command == SETSPEEDRIGHT){setSpeedRight(param1);} //si réglage de la vitesse à droite else{ //si commande non reconnue faire un peu de shimmey va à gauche(); retard (150); aller à droite(); retard (150); goStop(); }}//----------------------------------------------- --------------------------//DÉBUT DES ROUTINES DE SERVO ROBOT (SERB) CONTRLÉ PAR ARDUINO/* * configure votre arduino pour adresser votre SERB en utilisant les routines incluses*/void serbSetup(){ setSpeed(leftSpeed); pinMode(LEFTSERVOPIN, OUTPUT); //définit la broche de signal d'asservissement gauche //pour sortir pinMode (RIGHTSERVOPIN, OUTPUT); //définit la broche du signal servo droit //pour sortir leftServo.attach(LEFTSERVOPIN); //attache le servo gauche rightServo.attach(RIGHTSERVOPIN); //attache le servo droit goStop();}/* * définit la vitesse du robot entre 0-(arrêté) et 100-(pleine vitesse) * REMARQUE: la vitesse ne changera pas la vitesse actuelle, vous devez changer la vitesse * puis appelez-en un des méthodes go avant que les changements ne se produisent.*/ void setSpeed(int newSpeed){ setSpeedLeft(newSpeed); //définit la vitesse à gauche setSpeedRight(newSpeed); //définit la vitesse de droite}/* * Définit la vitesse de la roue gauche */void setSpeedLeft(int newSpeed){ if(newSpeed >= 100) {newSpeed = 100;} //si la vitesse est supérieure à 100 //faites-le 100 if(newSpeed = 100) {newSpeed = 100;} //si la vitesse est supérieure à 100 //fait 100 if(newSpeed <= 0) {newSpeed = 0;} //si la vitesse est inférieure à 0 make // it 0 rightSpeed = newSpeed * 0.9; // met la vitesse à l'échelle pour qu'elle soit }/* * envoie le robot vers l'avant */void goForward(){ leftServo.write(90 + leftSpeed); rightServo.write(90 - rightSpeed);} /* * renvoie le robot en arrière */void goBackward(){ leftServo.write(90 - leftSpeed); rightServo.write(90 + rightSpeed);} /* * envoie le robot à droite */void goRight(){ leftServo.write(90 + leftSpeed); rightServo.write(90 + rightSpeed);}/* * envoie le robot left */void goLeft(){ leftServo.write(90 - leftSpeed); rightServo.write(90 - rightSpeed);}/* * arrête le robot */void goStop(){ leftServo.write(90); rightServo.write(90);}//FIN DES ROUTINES DE SERVO ROBOT CONTRLÉ PAR ARDUINO (SERB)//---------------------------- ------------------------------------------------

Étape 4: Logiciel - Robot Laptop (WebServer)

(Processing est un langage et un environnement de programmation open source avec lesquels il est très facile de démarrer. Pour plus de détails, visitez Processing) Le logiciel qui s'exécute sur l'ordinateur portable du robot est également assez simple. Il s'agit d'un serveur Web plutôt rudimentaire (à l'écoute des demandes de pages Web provenant d'un navigateur Web), d'une petite interface utilisateur (pour la configurer) et de fonctionnalités permettant de transmettre les commandes reçues du serveur Web à l'Arduino. Pour installer rapidement: (sur les fenêtres)

• Téléchargez le fichier zip ci-dessous (06-WEBB-Processing Webserver (windows exe).zip)
• Décompressez-le et exécutez le fichier.exe (_WEBB_WebServer_RobotComputer.exe)

Pour modifier en cours de traitement:

• Téléchargez le fichier zip ci-dessous (06-WEBB-Processing Webserver (source files).zip)
• Décompressez n'importe où sur votre ordinateur.
• Ouvrez l'environnement de traitement et ouvrez (_WEBB_WebServer_RobotComputer.pde)

Tester:

• Exécutez le programme.
• Dans la case #1, il y aura une liste des ports de communication disponibles sur votre ordinateur (cliquez sur celui auquel votre Arduino est connecté. (votre robot se contractera plusieurs fois au fur et à mesure que l'ordinateur se connecte, et un point cyan apparaîtra à côté du port de communication)
• Dans la case #2, testez pour voir si votre Arduino est connecté. Cliquez sur l'une des flèches et espérons que votre robot se déplacera dans la direction cliquée pendant une demi-seconde.
• Dans la case #3, cliquez sur le bouton "Démarrer" pour démarrer le serveur Web.
• Ouvrez un navigateur Web (sur l'ordinateur portable du robot) et visitez https://127.0.0.1:12345/ControlPage.html (espérons que la page Web de contrôle avec des boutons apparaîtra) -Détails sur l'utilisation de cette page à l'étape suivante -

Qu'est-ce qui se passe:

• Le serveur Web écoute le port 12345 pour les requêtes http (ce qui est envoyé lorsque vous saisissez l'adresse d'une page Web)
• Il répond à deux types de requêtes.

1. Il écoute "ControlPage.html" et enverra la page Web de contrôle 2. Il écoute les requêtes de la forme "/request?command=F&param1=100" (ces commandes sont analysées et envoyées à l'Arduino (cet exemple entraînerait dans le robot qui avance pendant 10 secondes)Annexe: (Le code du serveur Web)

/* * Robot connecté au Web contrôlé par Arduino (WEBB) - Serveur Web * Pour plus de détails, visitez: https://www.oomlout.com/serb * * Comportement: Le programme écoute les requêtes http (page Web) sous la forme * "/request ?command=F&param1=100" puis les transmet à * Arduino * Commandes prises en charge - &aposF&apos - 70 - Avant * &aposB&apos - 66 - Arrière * &aposL&apos - 76 - Gauche * &aposR&apos - 82 - Droite * &aposS&apos - 83 - Vitesse * &aposX&apos - 88 - SetSpeedLeft * &aposY&apos - 89 - SetSpeedRight * &aposC&apos - 67 - Stop * param1&aposs - 0 - 255 (0 à 25,5 secondes) valeur * 100 millisecondes * * sert également la page Web de contrôle au navigateur si vous demandez ControlPage.html * * Opération: 1. Cliquez sur le port Comm auquel votre Arduino est connecté * 2. Utilisez les boutons de test pour voir si votre arduino écoute * (se déplacera dans la direction cliquée pendant une demi-seconde) * 3. Cliquez sur Démarrer et votre serveur Web soyez à l'écoute des demandes * * * Licence: Ce travail est sous licence Creative Commons * Attribu Licence non-portée à l'identique 3.0. Pour * afficher une copie de cette licence, visitez * https://creativecommons.org/licenses/by-sa/3.0/ * ou envoyez une lettre à Creative Commons, 171 Second * Street, Suite 300, San Francisco, California 94105, * ETATS-UNIS. * */import processing.serial.*; // importer la bibliothèque série pour utiliser Serial (pour parler à Arduino) import processing.net.*; //importe la bibliothèque net pour utiliser le serveur (pour parler à Internet)/* Variables liées au port série */int serialPortIndex = -1; //l'index du port série que nous utilisons dans Serial.list() listString commOptions; //Une variable pour stocker Serial.list() afin qu'il n'y ait pas besoin d'interroger //les ports série chaque fois que nous souhaitons le référencer (l'interrogation provoque un //saut dans les servos arduino)Serial serialPort; //Rend le port série adressable tout au long de cette esquisse/* Variables liées aux graphiques et au rendu */PFont font; //rend la police publique de sorte qu'elle n'a besoin d'être chargée qu'une seule fois (Arial-72)/* Variables liées au réseau */Server wServer; //Le serveur qui gère les requêtes Webint port = 12345; //Le port que le serveur écoute toint cycleCount = 0; //Compte le nombre d'exécutions de la boucle de dessin (utilisée pour //animer le texte "en cours d'exécution") /* Variables utilitaires */ PImage bg; //L'image d'arrière-plan actuellement \WEBB-background.png/* * Variables liées aux boutons * (les boutons sont implémentés très grossièrement, les cadres de délimitation sont stockés et le graphique et le texte sont * dessinés sur l'image d'arrière-plan) ie. le déplacement des variables de bouton ne déplacera pas l'apparence des boutons */Button comm1; Bouton comm2; Bouton comm3; Bouton comm4; //Les boutons pour choisir le bon port sérieButton up; Bouton à droite; Bouton gauche; Button down;//Les boutons de direction pour tester si le robot répondButton webServer; //Le bouton pour démarrer le serveur Web/* * configure tout */void setup() { frameRate(5); // Ralentit un peu l'esquisse afin qu'elle ne soit pas aussi éprouvante pour le système bg = loadImage("WEBB-background.png"); // Charge l'image d'arrière-plan (stockée dans le dossier sketch) size (700, 400); //Définit la taille de la fenêtre d'esquisse font = loadFont("ArialMT-72.vlw"); //Charge la police que nous utiliserons dans ce sketch commOptions = Serial.list(); //Sonde les ports série et obtient une liste des ports disponibles //(faire cela une seule fois empêche le robot de trembler à chaque fois qu'il est interrogé //le port série est interrogé) defineButtons(); //Définit les cadres de délimitation pour chaque bouton background(bg); //Peint l'image d'arrière-plan (cette image contient tous les graphiques des boutons)}/* La boucle principale des croquis */void draw() { if(cycleCount==0){ //-- appelle les routines de dessin drawCommBox(); // Dessine les éléments dans la Comm Box (box 1) drawTestBox(); // Dessine tous les éléments de la zone de test (case 2) drawWebServerBox(); // Dessine tous les éléments dans la WebServer Box (boîte 3) } //-- appelle les routines de travail pollWebServer(); //Sonde le serveur Web pour voir si des requêtes sont arrivées via le réseau}//------------------------------- ----------------------------------------------//Début de les routines de dessin (séparées juste pour rendre le code plus agréable à lire)/* * La routine de mise à jour de dessin (exécutée à chaque cycle) pour les éléments de la boîte de communication (boîte 1) */void drawCommBox(){ fill(0, 0, 0); //Définir le remplissage en noir textFont(font, 15); //Définir la police à la bonne taille pour(int i = 0; i 0){running = running + ".";} //le nombre de points est basé sur cycleCount if((cycleCount / 1) > 1){ running = running + ".";} if((cycleCount / 1) > 2){running = running + ".";} if((cycleCount / 1) > 3){cycleCount=0;} text(running, 520, 210); } cycleCount++; //Chaque fois que cycleCount est incrémenté de un} //End of Draw Routines//---------------------------------------------- -------------------------------//------------------ --------------------------------------------//Routines de démarrage de service/ * * mousePressed est appelé chaque fois que la souris est enfoncée ceci * vérifie si la souris est à l'intérieur de l'une des zones de délimitation des boutons * et si c'est le cas, la routine appropriée est appelée*/void mousePressed(){ if(comm1.pressed()) { updateSerialPort(0);} //Modifications apportées au port de communication à l'index 0 dans Serial.list() else if(comm2.pressed()) {updateSerialPort(1);} //Modifications apportées au port de communication à l'index 1 dans Serial.list() else if(comm3.pressed()) {updateSerialPort(2);} //Modifications apportées au port de communication à l'index 2 dans Serial.list() else if(comm4.pressed()) {updateSerialPort(3);} //Modifications apportées au port de communication à l'index 3 dans Serial.list() else if(up.pressed()) {sendRobotCommand("F", 5);} //Envoie une commande pour déplacer le robot vers l'avant de 0,5 secondes else if(left.pressed()) {sendRobotCommand("L", 5);} / /Envoie une commande pour déplacer le robot vers la gauche pendant 0,5 seconde else if(right.pressed()) {sendRobotCommand("R", 5);} //Envoie une commande pour déplacer le robot vers la droite pendant 0,5 seconde else if(down. pressed()) {sendRobotCommand("B", 5);} //Envoie une commande pour déplacer le robot vers l'arrière pendant 0,5 seconde else if(webServer.pressed()) {startWebServer();} //Démarre le webServer cycleCount = 0; arrière-plan (bg); // Repeint l'image d'arrière-plan (cette image contient tous les graphiques des boutons) draw();}/* * Appelé une fois une exécution, il vérifie le serveur pour voir s'il y a des connexions en attente * s'il y a une connexion en attente, il tire la requête et la transmet à la routine parseRequest(String) * pour supprimer le texte supplémentaire. Ceci est ensuite envoyé à la routine interpretRequest(String) pour * appeler la routine d'action appropriée (c'est-à-dire envoyer des instructions au robot).* * Une demande est transmise en entrant l'adresse et le port de l'ordinateur dans un navigateur Web * Pour la machine locale "https://127.0.0.1:12345/request?command=F&param1=100" * * Exemple de demande: * GET /request? command=F&param1=100 HTTP/1.1 * User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/525.19 (KHTML, like Gecko) * Accept: *//* * Accept-Language: en-US, en * Accept-Charset: ISO-8859-1, *, utf-8 * Accept-Encoding: gzip, deflate, bzip2 * Host: 127.0.0.1:12345 * Connection: Keep-Alive * * Exemple de réponse (pour la requête traitée) * HTTP/1.1 200 OK * Connexion: close * Content-Type: text/html * * commande: F param1: 100 */void pollWebServer(){ if(wServer != null){ //Si le webServer est en cours d'exécution Client request = wServer.available(); //Charge le prochain client en ligne dans le //serveur (null si aucune demande en attente) if(request != null){ //s'il y a un processus de demande, il String fullRequest = request.readString(); //Stocker le contenu de la requête sous forme de chaîne String ip = request.ip(); //Stocker l'adresse IP des clients sous forme de chaîne String requestString = parseRequest(fullRequest.toUpperCase()); //Enlevez toutes les //informations supplémentaires en ne laissant que la chaîne de requête (texte après GET) //(passe en majuscules pour faciliter le test des chaînes) if(requestString.indexOf("REQUEST?") != -1){ //Vérifie si la requête a "REQUEST?" Réponse de chaîne = interpretRequest(requestString); //Envoie la requête à l'interpréteur de requête request.write("HTTP/1.1 200 OK\nConnexion: close\nType de contenu: text/html\n\n" + réponse); //Envoie la réponse un 200 pour dire que la demande a été //traitée et la chaîne "réponse" comme réponse wServer.disconnect(request); //Déconnecte le client }else if(requestString.indexOf("CONTROLPAGE") != -1){ //Si la demande concerne la page Web de contrôle String webPageArray = loadStrings("WEBB-ControlPage.html"); //Charge la page web du contrôle à partir de \data\WEBB-ControlPage.html //(chargé sous forme de tableau de lignes) String webPage =""; // Pour faciliter l'édition, la page Web a été laissée avec // des sauts de ligne, donc cette boucle for supprime ces lignes for(int i = 0; i portIndex){ // si le portIndex transmis est un index valide dans Serial.list() //(c'est-à-dire pas l'option trois dans une liste de deux) serialPortIndex = portIndex; //définissez la variable serialPortIndex sur le nouvel index de port série //(utilisé pour afficher le point à côté du port actif) } if(serialPortIndex != -1){ //vérifiez qu'un port a été choisi précédemment si (serialPort != null){serialPort.stop();} //si un port série est déjà utilisé, arrêtez-le avant d'en charger un nouveau serialPort = new Serial(this, Serial.list()[serialPortIndex], 9600); //Créez un nouvel objet Serial pour communiquer avec l'Arduino 9600 Baud }}/* * Prend une chaîne de requête (ex: "request?command=F&param1=100") et supprime la commande * et param1 et la transmet au arduino (l'ajout de paramètres supplémentaires ou de commandes non arduino serait effectué ici) */String interpretRequest(String requestString){ String returnValue = "OK"; //Prépare une commande String variable returnValue; //Les trois lignes suivantes extraient la valeur après "command=" //(la ligne supplémentaire est au cas où le paramètre de commande est //à la fin de la requête et non suivi d'un & if(requestString.indexOf("COMMAND=") != -1){ command = requestString.substring(requestString.indexOf("COMMAND=") + "COMMAND=".length());} else{command = "Z";} if(command.indexOf(" &") != -1){ command = command.substring(0, command.indexOf("&"));}else{command = command;} String param1String; //Les trois lignes suivantes extraient la valeur après "param1= " //(la ligne supplémentaire est au cas où le paramètre de commande est à //la fin de la requête et n'est pas suivi d'un & if(requestString.indexOf("PARAM1=") != -1){ param1String = requestString.substring (requestString.indexOf("PARAM1=") + "PARAM1=".length());} else{param1String = "0";} if(param1String.indexOf("& ") != -1){ param1String = param1String.substring(0, param1String.indexOf("&"));} else{param1String = param1String;} int param1 = Integer.parseInt(param1String); //Transforme la chaîne param1 en un entier sendRobotCommand(commande, param1); //Envoie la commande à la routine qui l'envoie à l'Arduino returnValue = "command: " + command + " param1: " + param1; //pour le moment, juste la commande analysée mais l'envoi //en tant que html afin que le formatage puisse être inclus return returnValue;}/* * Prend une commande (actuellement une lettre) et un paramètre (un octet 0-255) et l'envoie au arduino * qui écoute et reste * Commandes actuellement prises en charge * F -*/void sendRobotCommand(String command, int param1){ println("command: " + command + " time: " + param1); Chaîne checkString = "AAA"; if(serialPort != null){ serialPort.write(checkString + commande); serialPort.write(byte(param1)); }}//Fin de l'installation/routines peu communément appelées//----------------------------------- -------------------------------------------------- //Exemple de bouton et de code RectButton de l'exemple de processing.org avec quelques modifications //apporté principalement pour simplifier et supprimer l'animation de survol //https://processing.org/learning/topics/buttons.html (2008-09-23) class Button{ int x, y; int largeur, hauteur; Button(int ix, int iy, int iwidth, int iheight) { x = ix; y = iy; largeur = ilargeur; hauteur = ihauteur; } booléen pressé() { if(overRect()) { return true; } else { return false;} } boolean overRect() { if (mouseX >= x && mouseX = y && mouseY <= y+height) { return true; } else { return false; } }}

Étape 5: Logiciel - (page Web)

Eh bien, nous avons presque terminé, il ne reste plus qu'à parler à votre robot. Pour parler: (sur un réseau local -sur Windows-)

• Découvrez l'adresse IP locale de l'ordinateur portable. Pour ce faire, allez dans "Démarrer\Programmes\Accessoires\Invite de commandes" et lorsque la fenêtre du terminal s'ouvre, tapez "ipconfig". Notez "Adresse IP" et dirigez-vous vers un autre ordinateur sur votre réseau local.
• Ouvrez un navigateur Web, tapez "https:// (ip de l'ordinateur robot):12345/ControlPage.html
• La page Web de contrôle doit se charger, dans la zone "Adresse IP", saisissez l'adresse IP des ordinateurs du robot.
• Commencez à contrôler votre robot.

Pour faire parler: (sur Internet) Maintenant que vous l'avez fait fonctionner localement, il suffit de quelques pas pour qu'il parle sur Internet.

• (étape la plus difficile) Configurer la redirection de port - Votre ordinateur doit écouter Internet plutôt que simplement le réseau local. Pour ce faire, vous devez indiquer à votre routeur de transmettre certaines requêtes à l'ordinateur contrôlant le robot. C'est un peu complexe et va bien au-delà de la portée de ce Instructable. Cependant, si vous visitez PortForward.com, ils vous donneront tout ce que vous devez savoir sur la configuration de votre routeur (vous devez transférer le port 12345 vers votre ordinateur portable robot)
• Découvrez ensuite votre IP Internet (visitez WhatIsMyIP.com)
• Enfin, lancez Skype, configurez un appel vidéo et demandez à votre interlocuteur de visiter "https://(Internet IP):12345/ControlPage.html"
• Tapez l'adresse IP Internet dans la case "Adresse IP" de la page Web de contrôle et votre robot connecté au Web est piloté à distance.

Étape 6: Terminé

Eh bien c'est ça. J'espère que vous vous amusez à conduire votre robot de loin. Si vous rencontrez des problèmes avec le logiciel ou le matériel, n'hésitez pas à laisser un commentaire et j'essaierai de vous aider. Si vous souhaitez découvrir des projets plus intéressants, essayez de visiter: oomlout.com