bonjour,
(changement de sujet )
j'ai actuellement un robot en prototypage, j'ai creer des programmes qui tournent en boucle pour que le robot ce déplace ( carte arduino UNO ), mais j'aimerais controler les déplacements du robot via mon clavier en restant appuyer sur les touches pour qu'il ce deplace, j'ai souvent entendu parler de proccessing mais je n'ai pas trouver mon bonheur...
merci d'avance
Bonjour, oui c'est tout à fait possible mais quelle est donc exactement votre question et de quels composants disposez-vous pour faire communiquer votre PC avec votre carte ?
désolé j'ai changer de sujet j'aimerais essayer avec procesing maintenant
Oui processing peut recevoir des commandes depuis le clavier ou une manette - la question reste Comment comptez vous envoyer ces commandes à votre robot?
je ne sais pas encore si vous avez des propositions je suis ouvert 
Comment pilotez vous Le robot aujourd'hui ?
Pour l'instant le robot tourne en boucle via un programme mais je ne le contrôle pas ...
est-ce que le robot dispose d'un composant de communication sans fil? bluetooth, wifi ou autre radio ?
non pas pour l'instant
En gros c'est relativement simple
--> pour le test par exemple un câble USB relié à l'arduino
--> des modules bluetooth SPP correctement configurés
--> du Zigbee, RF24 etc...
l'important c'est que votre PC puisse envoyer des messages au port série de votre Arduino.
Pour tester mon exemple, mettez simplement le câble USB vers un Arduino Uno (mais fonctionne de manière similaire, en réglant la vitesse en baud au bon niveau) avec d'autres moyens de communications Série
Une fois que vous avez fait cela il faut que, côté PC, votre programme écoute le clavier ou la souris ou la manette, transforme la commande reçue en un ordre que vous envoyez sur le Port Série, par exemple sous forme d'un seul caractère (tient sur 1 octet, c'est pratique) 'U' pour up, 'L' pour LEFT etc.
Eventuellement le code peut écouter aussi le port série, si l'Arduino envoie aussi des messages (utiles pour dessiner une interface par exemple sur le PC) -> il faut donc écrire ce bout de code
Pendant ce temps là l'Arduino dans sa boucle attend des ordres et quand il en reçoit un, il fait ce qu'il faut au niveau des moteurs, éventuellement renvoie un message à Processing et se remet à attendre un ordre.
Voici deux bouts de code assez simple à comprendre si vous avez bossé un peu processing et l'Arduino
Côté Processing;
import processing.serial.*;
Serial arduinoSerial; // The serial port
color c = #000000;
char message = '\0';
boolean updateNeeded = true;
void setup() {
size(100, 100);
// List all the available serial ports:
printArray(Serial.list());
// Open whatever port is the one you're using - here Serial.list()[1]
arduinoSerial = new Serial(this, Serial.list()[1], 115200);
message = '\0';
updateNeeded = true;
arduinoSerial.clear(); // vide le buffer
arduinoSerial.bufferUntil('\n'); // attend '\n' avant d'appeler serialEvent()
}
void draw() {
if (updateNeeded) {
updateNeeded = false;
background(0);
fill(c);
rect(25, 25, 50, 50);
}
}
void keyPressed() {
char previousMessage = message;
if (key == CODED) {
switch (keyCode) {
case UP:
c= #0000FF;
message = 'U';
break;
case DOWN:
c= #80FF00;
message = 'D';
break;
case LEFT:
c= #FF0000;
message = 'L';
break;
case RIGHT:
c= #CC66FF;
message = 'R';
break;
}
}
// sendonly if we got a new command, don't handle multiple keys pressed at once
if (previousMessage != message) {
arduinoSerial.write(message);
previousMessage = message;
updateNeeded = true;
}
}
void mousePressed() {
char previousMessage = message;
switch (mouseButton) {
case LEFT:
c= #0DD0FF;
message = 'l';
break;
case RIGHT:
c= #8EFFE0;
message = 'r';
break;
case CENTER:
c= #FFC0C0;
message = 'c';
break;
}
// sendonly if we got a new command, don't handle multiple keys pressed at once
if (previousMessage != message) {
arduinoSerial.write(message);
previousMessage = message;
updateNeeded = true;
}
}
void mouseReleased() {
keyReleased(); // similar as if a key is a released
}
void keyReleased() {
// whatever key we released (if many were pressed) will send 'S' (stop)
c= #000000;
message = 'S';
arduinoSerial.write(message);
updateNeeded = true;
}
void serialEvent(Serial aPort) {
// read what the Arduino sent us back
while (aPort.available() > 0) print((char) aPort.read());
}
le code se lit assez simplement, on attend des évènement soit clavier (touche appuyée ou relâchée) soit souris (un des 3 boutons appuyé ou relâché) et on envoie une commande correspondante à l'arduino et on dessine un petit rectangle d'une couleur particulière pour chaque action. Quand la fenêtre est noire, c'est qu'on a envoyé l'ordre STOP
la seule ligne à changer éventuellement c'est le 1 dans
arduinoSerial = new Serial(this, Serial.list()[[color=red]1[/color]], 115200);
il faut regarder ce que dit la console Processing qui va afficher tous les ports séries et prendre le N° qui correspond à votre moyen de communication avec votre Arduino.
Côté Arduino - je ne pilote rien côté Arduino, je renvoie juste en texte une chaîne de caractère qui apparaîtra dans la console Processing
void setup() {
Serial.begin(115200);
while (!Serial); // pour certains Arduino on attend que le port Série soit connecté
}
void loop() {
if (Serial.available() > 0) {
int r = Serial.read();
switch (r) {
// the keyboard
case 'U':
Serial.println("UP");
break;
case 'D':
Serial.println("DOWN");
break;
case 'L':
Serial.println("LEFT");
break;
case 'R':
Serial.println("RIGHT");
break;
// The mouse
case 'l':
Serial.println("left");
break;
case 'r':
Serial.println("right");
break;
case 'c':
Serial.println("center");
break;
// upon release
case 'S':
Serial.println("STOP");
break;
}
}
}
Attention vous ne pouvez pas, si vous utilisez un câble USB, avoir le programme processing qui tourne et en même temps la console Arduino ouverte. Toute la communication Série de l'Arduino est renvoyée à votre programme Processing
merci pour les codes, sachant que je suis débutant en la matière et que je découvre proccessing, pour controler un moteur en appuyant sur une touche, dans l'arduino j'ai juste a mettre la fonction de mon moteur apres par exemple : case 'c':
Serial.println("center");
fonctionnement moteur;
break;
Oui - mais uniquement après avoir lu les tutos d'eskimon sur les moteurs sinon vous allez tout griller...
Yes merci, j'avais deja regarder et pour eviter d'utiliser autant de composants j'ai acheter et fait mes test et programme sur des cartes mdd10a de chez cytron
merci pour ton code il marche parfaitement, mais j'aimerais savoir comment faire pour utiliser avec la lettre z par exemple ? je ne trouve pas sur internet... peut etre que je fais mal mes recherches...
Bonjour, j'ai moi même fait un robot arduino que l'on peut piloter avec le clavier via processing. et en plus. on peut visualiser les obstacles sur l’écran grâce à son radar.
Si ça vous intéresses:
http://quentin-fr.ddns.net/realisations/realisation.php?id=19
Bonne chance!!!!!!
sakut, erci pour ton lien, il pourrais m'etre utile pour plus tard, mais j'aimerais controler le robot avec Z = front, s= back, etc .. car mon robot aura 9sens ...
Comment compte tu relier le robot à l'ordinateur? Avec un fil ce n'est pas très pratique surtout si il est mobile. En revanche, tu peux faire du sans fils avec les modules NRF24L01, tu branche un arduino à l'ordinateur relié au NR24L01 qui va faire office de passerelle entre l'app processing et le robot.
Pour l'app processing, tu fais en sorte que lorsque tu appuie sur une touche, tu envoie un caractère sur la voie série pour le recevoir à travers l'arduino. Ensuite tu le traite sous forme d'ordre que tu envois au robot en radio. voila une base pour le code:
//on importe la bibliotheque pour la communication série
import processing.serial.*;
Serial mySerial;
void setup(){
size(300,300);
mySerial = new Serial(this,Serial.list()[0],9600);
mySerial.bufferUntil('\n');
}
void draw(){
background(255);
stroke(0);
fill(0);
textSize(20);
text("Controle du robot",75,25);
if(keyPressed == true){
if(key == 'z')mySerial.write('Z');
if(key == 's')mySerial.write('S');
}
}
Essaie ça dans processing.
le pc sera sur le robot et je controlerais ce pc a distance, comme ca en cas de panne pas besoin de me déplacé jusqu'au robot , merci pour le code j'essaie ca
Donc si j'ai bien compris, tu met un PC(portable?) que tu contrôles en wifi. Je trouve ta solution originale, néanmoins, la batterie du robot va vite se décharger(avec le poids de l'ordinateur).
Bonne chance!!!
pour la batterie il y aura un socle de recharge pour le robot
j'ai essayer ton code mais aucune réaction du robot ( désolé je débute vraiment avec processing ), j'ai du surement faire une erreur....
#define dir_1 2
#define pwm_1 3
#define dir_2 4
#define pwm_2 5
#define dir_3 7
#define pwm_3 6
#define dir_4 8
#define pwm_4 9
int pwm_value;
void setup() {
Serial.begin(9600);
while (!Serial); // pour certains Arduino on attend que le port Série soit connecté
pinMode(pwm_1,OUTPUT);
pinMode(dir_1,OUTPUT);
pinMode(pwm_2,OUTPUT);
pinMode(dir_2,OUTPUT);
pinMode(pwm_3,OUTPUT);
pinMode(dir_3,OUTPUT);
pinMode(pwm_4,OUTPUT);
pinMode(dir_4,OUTPUT);
}
void loop() {
if (Serial.available() > 0) {
int r = Serial.read();
switch (r) {
// the keyboard
if(r == 'Z'){
digitalWrite(dir_1,HIGH); //controls the direction the motor
digitalWrite(dir_2,HIGH);
analogWrite(pwm_2,30);
analogWrite(pwm_1,30);
digitalWrite(dir_3,HIGH); //controls the direction the motor
digitalWrite(dir_4,HIGH);
analogWrite(pwm_3,30);
analogWrite(pwm_4,30);
Serial.println("UP");
break;
}
case 'D':
digitalWrite(dir_1,LOW); //controls the direction the motor
digitalWrite(dir_2,LOW);
analogWrite(pwm_2,30);
analogWrite(pwm_1,30);
digitalWrite(dir_3,LOW); //controls the direction the motor
digitalWrite(dir_4,LOW);
analogWrite(pwm_3,30);
analogWrite(pwm_4,30);
Serial.println("DOWN");
break;
case 'L':
digitalWrite(dir_1,LOW); //controls the direction the motor
digitalWrite(dir_2,HIGH);
analogWrite(pwm_2,30);
analogWrite(pwm_1,30);
digitalWrite(dir_3,HIGH); //controls the direction the motor
digitalWrite(dir_4,LOW);
analogWrite(pwm_3,30);
analogWrite(pwm_4,30);
Serial.println("LEFT");
break;
case 'R':
digitalWrite(dir_1,HIGH); //controls the direction the motor
digitalWrite(dir_2,LOW);
analogWrite(pwm_2,30);
analogWrite(pwm_1,30);
digitalWrite(dir_3,LOW); //controls the direction the motor
digitalWrite(dir_4,HIGH);
analogWrite(pwm_3,30);
analogWrite(pwm_4,30);
Serial.println("RIGHT");
break;
// upon release
case 'S':
analogWrite(pwm_2,0);
analogWrite(pwm_1,0);
analogWrite(pwm_3,0);
analogWrite(pwm_4,0);
Serial.println("STOP");
break;
}
}
}