Je suis Débutant en électronique, je souhaiterais réaliser une sculpture mettant en jeu de l’électronique et un télécran. Je suis parvenu à trouver pas mal de projet similaire au mien sur instructables et sur des blogs, je me suis donc fourni en matériel adéquate c'est à dire une carte arduino uno et un shield de commande de chez adafruit AdaFruit Motor Shield Utiliser — MCHobby - Wiki ainsi que deux moteurs pas à pas de 5V. Voilà pour le début. Je parviens à commander les moteurs via l'IDE arduino, et le bricolage qui consistera à connecter ceux-ci au télécran ne devrait pas poser de problème.
Mon cahier des charges est le suivant :
-Je souhaiterais que les moteurs dessinent le signe infini sur le télécran.
-Le dessin devrait se répéter indéfiniment.
Je me suis donc penché sur la question d'abord en cherchant du côté de Grbl mais il semblerait que le pont en H de chez Adafruit ne sois pas compatible de plus je souhaiterais que le montage soit autonome c'est à dire que l'algorithme soit stocké dans la carte arduino puis exécuté bêtement indéfiniment.
J'ai exploré cette piste Algorithme de tracé d'arc de cercle de Bresenham — Wikipédia mais mes connaissances mathématique sont beaucoup trop faibles pour aller plus loin.
C'est pourquoi je me tourne vers vous pour savoir si quelqu'un souhaiterait m'aider pour élaborer la programmation de cette sculpture.
Merci Christian_R
Effectivement Le lemniscate de Bernouilli serait parfait comme motif pour mon tracé, par contre mon niveau en mathématique étant particulièrement bas, il me faudrait encore de l'aide afin de transposer ces équations en algorithm utilisant les librairies Arduino motor stepper. Quoiqu'il en soit je te remercie pour l'élévation de ma culture.
Bien cordialement
Comment sont branchés les moteurs ?
Il faut indiquer au programme quels Pins on doit activer.
Chercher d'abord à un faire tourner un, puis deux, avant de rajouter les autres instructions.
Christian_R:
Comment sont branchés les moteurs ?
Il faut indiquer au programme quels Pins on doit activer.
Chercher d'abord à un faire tourner un, puis deux, avant de rajouter les autres instructions.
If you want more intelligent control, check out the AccelStepper library (in the Downloads section) which has some concurrent stepper motor control examples"
Je vais tenter de comprendre les détails des exemples AccelStepper library
Merci pour ta réponse fdufnews
Ok mais les valeurs qui me sont données dans le moniteur série sont les mêmes que les lignes
oldx = x;
oldy = y;
soient placées avant ou après
Merci pour ta réponse fdufnews
Ok mais les valeurs qui me sont données dans le moniteur série sont les mêmes que les lignes
oldx = x;
oldy = y;
soient placées avant ou après
Peut être que la console te donnes la même chose (ce qui n'est pas étonnant puisque le print est à la fin) par contre vu des lignes motorA.step et motorB.step ce n'est pas pareil dans un cas la différence est systématiquement nulle dans l'autre c'est l'écart d'une itération à l'autre
Christian_R:
Il faut mémoriser oldx et oldy juste avant de recalculer les nouveaux x et y.
Idéalement il faudrait aussi initialiser explicitement t, oldx, oldy dans le void setup ()
Salut Christian R
Initialiser explicitement tu veux dire quelque chose de ce genre :
void setup()
{
Serial.begin(9600);// set up Serial library at 9600 bps
oldx = 0;
oldy = 0;
t = 0;
}
En même temps dans le code original processing il y'avait cette ligne line(x * 300, y * 300, oldX * 300, oldY * 300); j'ai donc testé en appliquant la multiplication à x et y et les valeurs qui me sont retournées dans le moniteur série sont plus grande. En y regardant bien mes moteurs tourne mais sur des pas très petits puis se bloquent je ne saisis pas très bien pourquoi mais c'est fascinant
Peut être saurez vous m'aiguiller encore
Peut être que la console te donnes la même chose (ce qui n'est pas étonnant puisque le print est à la fin) par contre vu des lignes motorA.step et motorB.step ce n'est pas pareil dans un cas la différence est systématiquement nulle dans l'autre c'est l'écart d'une itération à l'autre
[/quote]
Merci fdufnews
ça doit te paraître très simple comme remarque mais comme j'essais d'apprendre c'est très utile même si je ne suis pas encore parvenu à faire tourner mes moteurs pour obtenir ce que je veux je persiste :%
Peux tu ajouter un Serial.println(oldx - x); pour voir ce qui se passe sur les moteurs ?
Il faudra sans doute mettre un facteur d'échelle : multiplier (oldx - x) par une constante pour avoir l'amplitude de mouvement voulue.
Christian_R:
Peux tu ajouter un Serial.println(oldx - x); pour voir ce qui se passe sur les moteurs ?
Il faudra sans doute mettre un facteur d'échelle : multiplier (oldx - x) par une constante pour avoir l'amplitude de mouvement voulue.
En vérité avec
void loop()
{
t++;
if (t > 360){
t = 0;
cc = c;
c = random(-0.1, 0.1);
dd = d;
d = random(-0.1, 0.1);
}
x = a * sin(radians(t)) + (t * c + (360 - t) * cc) / 360;
y = b * sin(radians(t)) * cos(radians(t)) + (t * d + (360 - t) * dd) / 360;
motorA.step((oldx - x)*10,FORWARD,SINGLE);
motorB.step((oldy - y)*10,FORWARD,SINGLE);
oldx = x;
oldy = y;
delay(500);
Serial.println(oldx-x);
}
Le moniteur Série retourne 0.00 pour (oldx-x) quand tu parlais de multiplication par une constante tu voyais quelque chose comme cela
motorA.step((oldx - x)*10,FORWARD,SINGLE);
motorB.step((oldy - y)*10,FORWARD,SINGLE);
oldx = x; //<----- là tu mets oldx = x
oldy = y;
delay(500);
Serial.println(oldx-x); // <--- donc là comme oldx et x sont égaux la différence est nulle
Là bon
motorA.step((oldx - x)*10,FORWARD,SINGLE);
motorB.step((oldy - y)*10,FORWARD,SINGLE);
Serial.println(oldx-x); // <--- là oldx vaut la valeur de x à la précédente itération
oldx = x;
oldy = y;
delay(500);
OK merci fdufnews je saisis mieux l'importance de l'ordre des éléments désolé de vous tendre les nerfs de la sorte
le moniteur retourne ces valeurs : 0.00
0.02
0.03
0.05
0.07
0.09
0.10
0.12
0.14
0.16
0.17
0.19
0.21
0.22
0.24
0.26
0.28
0.29
0.31
etc.
Par contre je me posais la question du coefficient multiplicateur, je ne vois pas trop où l'appliquer car avec 512 pas pour un tour comment vais-je pouvoir sortir quelque chose avec des valeur comme celle-ci?
Je me suis permis de tester aussi ça
et cette fois les valeurs sont plus élevés 0.00
17.45
34.90
52.34
69.76
87.16
104.53
121.87
139.17
156.43
173.65
190.81
207.91
224.95
241.92
258.82
275.64
292.37
Mais cela semble être très ralenti et pas de mouvement du moteur même minime enfin peut être que je veux aller trop vite
merci en tout cas
x = a * sin(radians(t)) + (t * c + (360 - t) * cc) / 360;
y = b * sin(radians(t)) * cos(radians(t)) + (t * d + (360 - t) * dd) / 360;
x =
a * sin(radians(t)) <-------- pour variant de 0 à 360 sin(t) est compris entre -1 et +1 et comme a = 1 ce terme est donc compris entre -1 et +1
(t * c + (360 - t) * cc) / 360; <-c=0 et cc=0 donc ce terme est nul
Au bout du compte x compris entre -1 et +1.
Pour y je te laisse faire la calcul
Si tu veux un mouvement notable il faut jouer sur a, b, c, cc, d et dd pour modifier la forme.
a et b vont dilater la forme alors que le autres termes vont jouer sur son positionnement.
Au passage, les variables cc et dd ne sont pas initialisées ce qui fait qu'à la première itération de la boucle elles pourraient avoir une valeur quelconque.
x = a * sin(radians(t)) + (t * c + (360 - t) * cc) / 360;
y = b * sin(radians(t)) * cos(radians(t)) + (t * d + (360 - t) * dd) / 360;
x =
a * sin(radians(t)) <-------- pour variant de 0 à 360 sin(t) est compris entre -1 et +1 et comme a = 1 ce terme est donc compris entre -1 et +1
+ (t * c + (360 - t) * cc) / 360; <-c=0 et cc=0 donc ce terme est nul
Au bout du compte x compris entre -1 et +1.
Pour y je te laisse faire la calcul
Si tu veux un mouvement notable il faut jouer sur a, b, c, cc, d et dd pour modifier la forme.
a et b vont dilater la forme alors que le autres termes vont jouer sur son positionnement.
Au passage, les variables cc et dd ne sont pas initialisées ce qui fait qu'à la première itération de la boucle elles pourraient avoir une valeur quelconque.
J'étais véritablement d'une grande naïveté :. merci de ton éclaircissement fdufnews
Pour Y je dirais =0 vu les valeurs données à t,d et dd
Par contre tout ceci constitue un nombre important de variable, et je ne pourrais pas empiriquement m'amuser à tester des valeurs.
Comment puis-je savoir en prenant en compte la mécanique d'un télécran quelles valeurs appliquer à telle variables?
En fait je m'interroge sur la facilité d'être véritablement créatif avec arduino lorsque l'on ne bénéficie pas d'une formation initiale poussée
Rien est facile évidement mais je crois que nous ne pourrons pas encore pendant très longtemps nous passer de vos savoir faire et conseils merci
Il faut compter combien de tours de moteurs il faut pour traverser tout l'écran, séparément dans les deux sens X et Y.
Les équations du Lemniscate sont prévues pour une courbe de largeur 2a selon X horizontal, donc il y aura juste une règle de 3 pour agrandir la courbe.
Commence par tracer un simple rectangle avant de passer à plus compliqué.