Posté par
- 04 novembre 2016 - 09:15
Reçu !! Mes premières soudures depuis ... 20 ans, mon premier câblage I2C. Ça méritait d'être dit 
Pour en brancher 2 sur le même I2C, il faut définir l'adresse par logiciel et utiliser le pin XSHUT du lidar.
La solution, trouvée là : https://github.com/p...rduino/issues/1
La lib arduino et des exemples de code :
https://github.com/p...vl53l0x-arduino
Posté par
- 02 novembre 2016 - 01:51
Et si on prend des robots de la communauté, on peut demander l'autorisation à chacun.
On pourrait refaire la même image j'en suis sûr.
Posté par
- 02 novembre 2016 - 08:29
Je sais pas encore. Mon but est de faire une tourelle 360° pour pas cher. Je les mettrai dos à dos sur un servo. Elle pourra être lente. Le prix est la priorité.
Posté par
- 13 octobre 2016 - 07:19
Hypothèses :
On se met dans l'hypothèse à vide ou avec une charge inférieur à son max, et sans butée sur l'amplitude 0 à 180° et la commande en vitesse vise à réduire la vitesse max. On va donc supposer que le servo n'est pas gêné, qu'il fonctionne bien, qu'il est bien à la position commandée.
Rappel de l'énoncé :
Tout ce que sait faire un servo c'est aller à la position commandée aussi vite qu'il peut. Donc pour le faire aller moins vite, il faut le commander sur des positions intermédiaires. Comme dit dans l'énoncé.
Ma solution au défi ...
Pour résoudre le défi, je propose d'échantillonner en utilisant la boucle principale de l'arduino.
Une vitesse, c'est une distance (ici angulaire) parcourue en temps donné. Admettons qu'on veuille parcourir un secteur angulaire de 180° en 10s, par exemple. Soit une vitesse de 18°/s.
Pour expliquer, on va calculer la position toutes les secondes :
Au départ (à 0s), on est à l'angle de départ (0°). => servo1.write(0);
A 1s, on est à 1x18° => servo1.write(18);
A 2s, on est à 2x18° => servo1.write(36);
...
A 10s, on est à 10x18° => servo1.write(180); // on est arrivé.
C'est un calcul proportionnel de la position en fonction du temps écoulé.
Dans le code arduino :
On va commencer par mémoriser l'heure de départ en ms avec la fonction
unsigned long startTimestamp = millis().
Dans la boucle loop(), on va utiliser la fonction map pour calculer la position en fonction du temps écoulé.
Temps écoulé :
unsigned long timePosition = millis() - startTimestamp;
Calcul de l'angle proportionnellement au temps écoulé :
long angle = map(timePosition, 0, 10, 0, 180);
Avant de commander le servo, on vérifie qu'on ne sort pas des bornes 0 - 180.
servo1.write(angle);
A propos de la fonction map : elle fait un produit en croix.
Elle traduit proportionnellement une valeur (arg1) d'un champ (arg2 et 3) dans un autre champ (arg4 et 5).
valeur en entrée (temps)
v
Temps 0.....x...........10
angle 0.....x...........180
^
Valeur de sortie (angle)
Dans ce cas, du temps en angle. Au fur et à mesure qu'on avance dans le temps, on obtient l'angle qui correspond à la vitesse voulue.
Avantage de cette solution :
- n'occupe pas d'interrupetion
- le calcul est indépendant le la fréquence de l'arduino. Tant que celui-ci n'est trop occupé à faire autre chose bien sûr.
Mon contenu
Homme
//Bibliothèque :
#include <Servo.h> //Ajoute la librairie Servo
//servo1 :
Servo servo1; //Déclare un nouveau servomoteur nommé servo1
unsigned long startTimestamp;
unsigned long timePosition;
#define MIN 500 // Position 0° en microseconde
#define MAX 2500 // Position 180° en microseconde
void setup()
{
servo1.attach(9, MIN , MAX); //Attache servo1 au pin 9 avec MIN et MAX les extrêmes en
startTimestamp = millis();
}
void loop()
{
timePosition = millis() - startTimestamp;
long angle = map(timePosition, 0, 10, 0, 180);
servo1.write(angle);
}
Cette méthode m'a donné satisfaction pour faire le P'tit Bob cet été. Je suis content de pouvoir le proposer au défi ^^
Source complet : http://www.robot-maker.com/forum/topic/10644-le-ptit-bob-de-path-complet/?p=72156
Posté par
- 06 octobre 2016 - 07:29
Posté par
- 26 septembre 2016 - 11:44
Posté par
- 19 septembre 2016 - 09:03
Posté par
- 09 septembre 2016 - 07:32
Posté par
- 07 septembre 2016 - 07:21
Posté par
- 05 septembre 2016 - 06:10
Posté par
- 20 août 2016 - 03:45
J'en suis pas stade du projet. Je réfléchi à contrer certains faits hostiles (mais fort sympathiques à mon boulot) par une réponse plus ou moins automatisée.
Je cherche un moyen de lancer ces fléchettes via une commande électrique. L'idée serait de projeter à 30m environ.
Il y a l'air comprimé. Cela ne me parait pas très simple à mettre en oeuvre.
Je me disais qu'avec un solénoïde, je pourrai peut-être faire quelque chose mais je n'ai jamais manipulé ces bêtes là et je sais pas quelle énergie mécanique cela peut transmettre pour projeter.
Il y a l'élastique, le ressort que je peux tendre avec une mécanique qui m'échappe encore.
J'ai bien trouvé des gadgets usb mais ils ne sont pas compatible avec les nerf. Je n'ai pas compris quelle mécanique ils utilisent pour projeter dans ces gadgets. Je n'ai rien trouvé de convainquant sur thingverse ou sur instructable alors je me tourne vers vous pour savoir si quelqu'un a déjà joué avec ces fléchettes.
Posté par
- 24 juillet 2016 - 03:06
C'est une vieille demande de Mike qui m'a bien aidé pour Ash.
Je viens de finir la rédaction d'un tuto pour utiliser NodeJS sur raspberry : http://www.robot-maker.com/forum/tutorials/article/91-introduction-a-node-js-sur-pi/
J'ouvre ce sujet pour avoir vos remarques, commentaires, précisions, coquilles.
Merci d'avance.
PS. Si un admin peut déverrouiller le tuto, ce serait sympa.
Posté par
- 12 juillet 2016 - 02:26
Pas de pb, j'ai cru ^^
Là, c'est du code que j'ai pondu. Pour avoir des mouvements plus fluides et simultanés sur les servos.
Je pourrai améliorer le code en sortant les danses dans des classes dédiées. J'aurais aussi voulu éviter la petite fonction d'adaptation lié à ce problème de tableau qui doivent être équilibrés.
Reste à lui ajouter des danses. Là j'occupe 32% du stockage programmes et 30% de la mémoire dynamique.
Le code de la V1.1
Posté par
- 09 juillet 2016 - 10:53
Salut Telson,
Dans Ash, j'ai fait quelque chose qui ressemble : une transmission série. Je vais pas résoudre ton pb mais peut-être, si je t'explique ce que j'ai fait, cela pourra t'aider. Je ne prétend pas que c'est LA solution, c'en est une.
Mon protocole est un peu différent du tien. Je ne transmet que du texte. Pas du binaire. Je trouve cela plus facile à traiter. (mais c'est plus lourd à transmettre). Je crois que c'est donc plus simple pour t'expliquer. Je sépare les trames avec des caractères de fin de ligne. Et à l'intérieur des trames, je sépare les infos par des ':'. C'est très similaire au tien. Mes trames ressemblent à ça :
COMMAND:value[:value[:value[...]]]\n
Lire une trame revient à lire une ligne de texte :
void loop() {
if (Serial.available()>0) {
dataFromPI = Serial.readStringUntil('\n');
parseAndDispatch(dataFromPI);
}
}
Dans parseAndDispatch, j'analyse les données reçues en découpant la trame. Pour faire ça, je cherche la position de chaque séparateur ( : ) et je fais un tableau de string avec ces paramètres.
void parseAndDispatch(String dataFromPI) {
// Dé-sérialiser en analysant la trame
// get Command (première partie de la trame)
int dataLength = dataFromPI.length();
int firstSep = dataFromPI.indexOf(SEPARATOR);
if(firstSep == -1) return; // indexOf retourne -1 s'il ne trouve pas
if(firstSep + 1 >= dataLength) return;
String cmd = dataFromPI.substring(0,firstSep);
// get args (suite de la trame) on découvre le nombre d'arguments
String arrayArgs[MAX_ARGS];
unsigned int index = 0;
while(firstSep + 1 < dataLength && index < MAX_ARGS) {
int secondSep = dataFromPI.indexOf(SEPARATOR, firstSep+1);
// pour le dernier argument
if(secondSep == -1) {
secondSep = dataLength;
}
String arg = dataFromPI.substring(firstSep+1, secondSep);
firstSep = secondSep;
arrayArgs[index] = arg;
index++;
}
// On dispatch
if(cmd == "DIST") {
doDistanceCommand();
}
if(cmd == "SERVOH") {
doServoHCommand(arrayArgs);
}
if(cmd == "SERVOV") {
doServoVCommand(arrayArgs);
}
if(cmd == "MOTOR") {
doMotorCommand(arrayArgs);
}
}
Et, par exemple, le code de la commande du servo horizontal :
void doServoHCommand(String arrayArgs[]) {
int pos = arrayArgs[0].toInt();
servoH.write(pos);
}
Ce code fonctionne bien. C'est avec ça que je pilote le uno depuis le raspberry dans Ash.
Pour blinder un peu le protocole, comme tu as une transmission sans fil et tu peux perdre des données, tu peux ajouter en début de trame la taille de la trame. Cela te permet de vérifier qu'une trame reçue est complète.
Dans mon code, j'ai pris l'hypothèse que l'émetteur est de confiance et qu'il formate toujours les trames correctement 
