224 réponses à ce sujet

[michel]

Bonjour à tous les membres ,

merci encore sandro tu as simplifié ma formule .

je galérais avec la fonction map du coup j'ai fait la formule que tu as vu mais je pensait la refaire en float  .

j'ai utilisé  ta formule alfa_1 = 360*now.day()/maxday;

d'avance merci .

bon dimanche , merci pour tes bons conseils et le lien .

[attachment=11042:IMG_1658.JPG]

[michel]

bonjour,

avant de revenir vers vous ,j'ai tester deux code pour moteur pas à pas .

tous deux commander par un potentiomètre et un map .

le 1 er
#include <Stepper.h>

int nombreDePas = 48*64;

Stepper monMoteur(nombreDePas, 9,11,10,12); // l'interface branchée sur les sorties 9 a 12 de l'Arduino

int valeurActuelle;
int valeurPrecedente;

void setup()
{
    monMoteur.setSpeed(9); // Vitesse Maxi de déplacement
    
}

void loop ()
{
   valeurActuelle = map(analogRead(A0), 0, 1023, 0, 2050); // Pour faire 1 tour complet
   //valeurActuelle = analogRead(A0); // Pour le positionner en fonction du potentiomètre
    monMoteur.step(valeurActuelle - valeurPrecedente);
    valeurPrecedente = valeurActuelle;
}

à chaque position du potard le moteur vibre .
 

[michel]

le deuxieme ne vibre pas à chaque position du moteur mais plus complexe .

j'aimerais à chaque fois qu'un jour me calcule un angle faire bouger le moteur du même angle .

j'avais penser à modifier à ce niveau la

void loop() {
  valor = alfa_1 // de mon ancien programme alfa_1 = 360*now.day()/maxday;              

  graus = map(valor, 0, 360, 0, 360);

je ne sais pas si cela pourrais convenir .

la c'est super complexe pour moi amateur .d'avance merci .

bonne soirée à tout le monde

 

[code=arduino]
/*
Motor Pas a Pas moviment per valor entrat des d'un potenciòmetre
Gira els graus que li indiquem des del potenciòmetre
El motor necessita de 512 passos per recórrer els 360 graus d'una volta.
                                             360      1
El factor de conversió de graus a voltes és: --- = -------
                                             512   1,42222
Utilitzem el port analògic A0 pel senyal del potenciometre.
El potenciomentre donarà valors entre 0 i 1023, que al motor pas a pas li traduirem en valors entre 0 i 360 graus.
La funció map es basa en la següent fórmula:
(valor_llegit_potenciometre - valor_minim_potenciometre) * (valor_màxim_servo - valor_mínim_servo) / (valor_màxim_potenciometre - valor_mínim_potenciometre) + valor_mínim_servo
O sigui: (valor - 0) * (360-0) / (1023-0) + 0
Robòtica educativa - CRP del Tarragonès
*/

int retard    = 5;   // Temps de retard entre els passos del motor
int numPasos  = 0;   // Guarda en graus el punt on es troba el motor
int graus     = 0;   // Valor en graus de la cadena entrada per l'usuari
int valor     = 0;   // Valor adquirit des del potenciòmetre

void setup() {                
Serial.begin(9600);  // Inicialització del port sèrie a 9600 baudis// inversion de sens 8,11,
pinMode(11, OUTPUT); // Pin 11 conectat a IN4 del mòdul ULN2003
pinMode(10, OUTPUT); // Pin 10 conectat a IN3 del mòdul ULN2003
pinMode(9, OUTPUT);  // Pin  9 conectat a IN2 del mòdul ULN2003
pinMode(8, OUTPUT);  // Pin  8 conectat a IN1 del mòdul ULN2003
pinMode(A0, INPUT);  // Entrada de valor del potenciòmetre
}

void loop() {
  valor = analogRead(0);                 // llegeix el valor del potenciometre (dóna un valor entre 0 i 1023)
  graus = map(valor, 0, 1023, 0, 360);   // escala el valor obtingut del potenciometre al valor que necessita el motor (0 és 0 i 1023 és 360)

  if (graus != numPasos){       
         Serial.print("Valor del potenciòmetre: ");  // Envia per pantalla la posició del motor en graus
         Serial.print(valor);
         Serial.println(" sobre 1024");
         Serial.print("Posició del motor: ");        // Envia per pantalla la posició del motor en graus
         Serial.print(numPasos/1.4222222222);
         Serial.println(" graus");
         Serial.print("Posició demanada: ");         // Envia per pantalla el valor entrat en graus
         Serial.print(graus);
         Serial.println(" graus");
         delay(retard);
         graus = (graus * 1.4222222222);            // Ajusta els 512 passos de cada volta als 360 graus
         while (graus > numPasos){                  // Gira a l'esquerra en graus
            pasEsquerra();
            numPasos = numPasos + 1;
            }
         while (graus < numPasos){                 // Gira a la dreta en graus
            pasDreta();
            numPasos = numPasos -1;
            }
       }  
  atura();                                        // Atura del motor per tal d'evitar que es calenti
}

void pasDreta(){         // Pasos a la dreta
 digitalWrite(11, LOW);
 digitalWrite(10, LOW);  
 digitalWrite(9, HIGH);  
 digitalWrite(8, HIGH);  
 delay(retard);
 digitalWrite(11, LOW);
 digitalWrite(10, HIGH);  
 digitalWrite(9, HIGH);  
 digitalWrite(8, LOW);  
 delay(retard);
 digitalWrite(11, HIGH);
 digitalWrite(10, HIGH);  
 digitalWrite(9, LOW);  
 digitalWrite(8, LOW);  
 delay(retard);
 digitalWrite(11, HIGH);
 digitalWrite(10, LOW);  
 digitalWrite(9, LOW);  
 digitalWrite(8, HIGH);  
 delay(retard);  
}

void pasEsquerra() {        // Pasos a l'esquerra
 digitalWrite(11, HIGH);
 digitalWrite(10, HIGH);  
 digitalWrite(9, LOW);  
 digitalWrite(8, LOW);  
 delay(retard);
 digitalWrite(11, LOW);
 digitalWrite(10, HIGH);  
 digitalWrite(9, HIGH);  
 digitalWrite(8, LOW);  
 delay(retard);
 digitalWrite(11, LOW);
 digitalWrite(10, LOW);  
 digitalWrite(9, HIGH);  
 digitalWrite(8, HIGH);  
 delay(retard);
 digitalWrite(11, HIGH);
 digitalWrite(10, LOW);  
 digitalWrite(9, LOW);  
 digitalWrite(8, HIGH);  
 delay(retard);
}
        
void atura() {         // Atura del motor
 digitalWrite(11, LOW);
 digitalWrite(10, LOW);  
 digitalWrite(9, LOW);  
 digitalWrite(8, LOW);  
 }
	
	[/code]	
			
				

[Mike118]

Quel driver de moteur pas à pas utilisez vous ? 

[michel]

je teste avec

ULN2003A et 28BYJ-48

[michel]

bonjour mike118,

j'ai fait une commande d'angle pour mon turntable qui chaque jour qui passe additionne les angles et j'aimerai commander un moteur pas à pas grâce à cela .

je te met le code

j'utilise un moteur 28BYJ-48 et driver ULN2003A

je ne sais pas comment faire pour positionner le moteur au même angle que sur l’écran .

le moteur ne tourne que dans un seul sens.

je te joins la photo de l'écran aujourd'hui vendredi 10 janvier = 360°x10(day)/(maxday) = 116°

tu pourrais s'il te plait m'aider .

d'avance merci

void draw1(void) {
  DateTime now = RTC.now();
    // center  
 int x2=128/2;  
 int y2=64/2;  
 // radius  
 int r2=22;
 // angle  
 int alfa_1 = 0;
 maxday = EEPROM.read(7);
 alfa_1=360*now.day()/maxday;
 u8g.setPrintPos(1,10);
 u8g.print(EEPROM.read(16));
  EEPROM.update(16,alfa_1);
 u8g.setPrintPos(62,9);
 u8g.print("0");
 u8g.setPrintPos(90,32);
 u8g.print("90");
 u8g.setPrintPos(56,64);
 u8g.print("180");
 u8g.setPrintPos(22,32);
 u8g.print("270");
 u8g.drawLine(x2,y2, x2+r2*sin(1*alfa_1*2*3.14/360), y2-r2*cos(1*alfa_1*2*3.14/360));  
 u8g.drawCircle(x2, y2, r2);
}
       
[attachment=11051:IMG_1673.JPG]

[Sandro]

Bonjour,

du coup, tu as réussi à faire tourner le moteur? Avec le quel des deux codes?

 

Ton moteur, il peut tourner dans les deux sens. Dans le cas du premier code, il suffit de donner un nombre négatif à steps pour faire le nombre de pas en sens inverse. Pour le second code, tu utilise pasDreta pour aller dans un sens et pasEsquerra pour faire un pas dans l'autre sens.

 

Pour positionnement du moteur, si tu sais où tu es, et que tu sais où tu veux aller, il suffit de calculer l'angle à parcourir puis à le convertir en nombre de pas

[michel]

Bonsoir sandro ,

oui j'ai tester les deux codes .

le deuxième et mieux mais beaucoup trop compliquer .

j'aimerai un code épuré juste avec alfa_1 qui commande l'angle .

mais je ne sais pas comment faire pour commander le nombre de pas avec l'angle .

peut-être comme cela .

valor = alfa_1;
graus = map(valor, 0, 360, 0, 360); 

et juste un sens de rotation .

[Sandro]

Bonsoir,

je ne sais pas exactement ce que tu penses que fait la fonction map, mais map(valor,0,360,0,360) te donne juste valor, du coup ça sert à rien.

 

Je te propose le pseudo code suivant, qui permet d'aller à un angle donné (essaye de le transformer en code arduino, si tu n'y arrives pas, mets ton essai et je t'aiderai plus):

aller_a_angle(alpha_cible, numero_de_pas_courant)
{
  numero_de_pas_cible = map (alpha_cible, 0, 360, 0, NOMBRE_TOTAL_DE_PAS_PAR_TOUR);  //ou alors, ce qui revient au même : numero_de_pas_cible = alpha_cible *NOMBRE_TOTAL_DE_PAS_PAR_TOUR / 360;
  nombre_de_pas_a_faire = numero_de_pas_cible - numero_de_pas_courant; //nb : c'est un nombre négatif si on vas vers un angle plus petit que l'angle courant
  steps(nombre_de_pas_a_faire);  //selon le signe, on tourne dans un sens ou dans l'autre
}

Le code que je te donne a juste un petit "défaut" : quand tu as fait presque un tout complet et que tu arrives au mois suivant, tu y vas "en reculant" plutôt qu'en avançant. Ça peut se corriger facilement, mais ça fait un code un petit peu plus long.
 

PS : si tu arrives à écrire tes variables en français ou en anglais, ça rendrait plus facile de comprendre ce que tu veux dire (le catalan, je ne le parles pas, même si j'arrive à deviner un peu, ayant appris l'espagnol à l'école)

[michel]

bonsoir Sandro ,

j’avais penser à position du moteur en degrés par rapport à alfa_1 qui est en degrés également .

je n'ai pas encore tester le programme il dois avoir des erreurs.

je dois passer mon écran en I2C pour récupérer des pins qui seront utiliser pour commander les moteurs .

j'ai vu ce circuit qui commande un moteur en I2C .(stepper ou moteur cc) tu pourrais me donner ton avis .

je te met le lien :http://wiki.seeedstudio.com/Grove-I2C_Motor_Driver_V1.3/

encore un grand merci pour ton aide , je n'y serait pas arriver sans ton aide et tes précieux conseils .

je te souhaite une bonne soirée .

/*   Programme permettant de faire tourner l'axe d'un MOTEUR PAP BIPOLAIRE très lentement  (un pas à la fois), de compter et d'afficher via le moniteur série  d'un ordinateur chaque pas effectué.  Le MOTEUR PAP doit être connecté aux broches 8 à 11 de la carte Arduino.  Programme pouvant servir à tester que les 4 fils du moteur sont  bien connectés. Si c'est le cas, le moteur tournera dans le même sens. */

#include <Stepper.h>                                // Permettra d'utilser des fonctions de la librairie externe Stepper.h,
                                                   // librairie spécifique pour contrôler les MOTEURS PAP.
const int nbrepas360 = 2048;                       // Fixe le nombre de pas pour faire un tour complet, c'est-à-dire 360°.
// 2048 pas *360°= 5,6° par pas                        
Stepper monmoteur (nbrepas360, 8, 9, 10, 11);    // Initialise la librairie Stepper.h
int cptepas = 0;                                // Stockera le nombre de pas compté.
int position_du_moteur=0;
int alfa_1 = 0;
void setup()
{
  Serial.begin(9600);                    // Ouvre le port de communication en série de la carte et initialise sa vitesse.
                                        // Cela permettra d'envoyer des donnés ou des commandes depuis ou vers
                                       // un ordinateur connecté au port série de la carte Arduino.
  delay (5000);                      // Pause de 5 secondes repérer le début de la boucle.
}

void loop()
{
position_du_moteur = cptepas*5.6 ; // position du moteur en degrés
{
  if(position_du_moteur < alfa_1){
  monmoteur.step(+1);                   // Avance de 1 pas.
  Serial.print("nombre de pas:" );    // Affiche dans le moniteur "série"
  Serial.println(cptepas);           // le nbre de pas effectué.
  cptepas++;                        // Incrémente la variable cptepas pour compter les pas.
  delay(500);                      // Pause d'une demi seconde entre chaque pas.
  }
if(position_du_moteur > alfa_1){
  monmoteur.step(-1);                 // recule de 1 pas.
  Serial.print("nombre de pas:" );    // Affiche dans le moniteur "série"
  Serial.println(cptepas);           // le nbre de pas effectué.
  cptepas--;                        // décrémente la variable cptepas pour compter les pas.
  delay(500);                  
   }
  }
}

[Sandro]

Bonsoir,

position_du_moteur = cptepas*5.6 ; // position du moteur en degrés

Attention, si 360° correspond à 2048 pas, alors 1 pas correspond à degrees_pas=360.0/ 2048.0 = 0.17578125°. Du coup il faut multiplier par degrees_pas et pas par 5.6 (pour info, ton 5.6 semble correspondre à 2048/360)

 

De plus, si ton alpha ne tombe pas pile sur un nombre entier de pas (ou s'il y a une erreur d’arrondi dans la multiplication par 5.6), alors tu risque d'osciller entre deux positions voisines.

Si tu veux éviter ça, je te suggère d’appliquer les modifications suivantes :

- transforme la variable position_du_moteur en float (de manière à rréduire les erreurs d'arrondi)

- définit au début de ton programme une constante float degrees_pas=360.0/ nbrepas360

- pour tes deux if, utilise position_du_moteur < alfa_1-0.5*degrees_pas  pour le premier et position_du_moteur > alfa_1 + 0.5*degrees_pas : celà permet de créer une hystérésis de 1 pas (ie une zone de 1 pas où tu ne fera rien)

 

Pour utiliser le LCD en I2C, c'est une bonne idée si tu manque vraiment de pins (si tu veux que je t'aide à vérifier, donne moi ton programme complet actuel, ainsi que la liste de tout ce que tu branche à l'arduino). Sache aussi que les pins A0 à A5 peuvent être utilisés comme des pins numériques normaux au besoin (pour tous ou seulement quelques uns).

 

Pour le driver de moteur en I2C, en soit, à première vue, je suppose que ça fait l'affaire (tant que ton moteur ne consomme pas trop de courant). Par contre, si j'ai bien compris, tu as déjà un driver de moteur pour ton moteur pas à pas. Du coup, surtout si tu passe l'écran en I2C, je ne vois pas l'utilité d'acheter un nouveau driver pour le moteur.

 

Bonne soirée

Sandro

[michel]

bonsoir Sandro ,

merci pour tous tes conseils .

dés que j'aurai fini je reviens te voir .

je te souhaite une bonne soirée  .

[Mike118]

Pour t'aider et te conseiller au mieux pour ton projet il faudrait faire un petit schémas qui indique quel pin est connecté sur quoi. 

Un driver de moteur pas à pas peut fonctionner avec juste 3 fils de signal ... J'ai déjà conseillé de regarder la librairie accelsteper avec les liens qui montrait les tests réalisés par ashira ... 

 

Ce petit driver de moteur pas à pas est très bien et peu cher : https://www.robot-ma...pas-a-4989.html

il faudrait des info supplémentaire sur ton mteur pour vérifier que ce driver convient bien ( courant consommé ) 
 

[michel]

bonjour Mike118,

merci pour ton aide .

je te joins ce que j'ai pu trouver sur ce moteur .

Moteur pas-à-pas unipolaire à 4 enroulements avec réducteur et driver basé sur un ULN2003A permettant de contrôler directement le moteur avec un microcontrôleur (ex: Arduino) sans interface de puissance.
Caractéristiques:

• Alimentation : 5 Vcc
• Résistance: 21 ohms
• Intensité: 25 mA
• Réduction: 1/64
• Nombre de pas par tour: 64 (réduction de 4096 en sortie d'axe)
• Entraxe de fixation: 35 mm
• Axe: Ø5 mm avec double méplat (épaisseur 3 mm)
• Longueur de l'axe: 12 mm

par contre je ne sais pas comment commander ce driver dans l'arduino .

bonne journée.

[Mike118]

Ok je vois quel est ton monteur pas à pas et ton driver.
je te recommande d'utiliser la librairie accelstepper avec le mode : 

HALF4WIRE 

 

doc de la lib : https://www.airspayc...885581b8c434b07

 

ligne de code d'initialisation qu'il faudra faire : 

AccelStepper mystepper(HALF4WIRE, pin1, pin2, pin3, pin4);

[michel]

bonsoir Sandro ,

j'ai une erreur quand je déclare int *degrees_pas = 0,5; (expected unqualified-id before numeric constant)

je suppose que seul les nombres entier fonctionne .

merci pour ton aide .

Bonne soirée.

[Mike118]

essaye à la place ...
 

float degrees_pas = 0.5;

Les chiffres à virgule se font avec des "." et il faut typer avec un type qui prend les chiffre à virgules... (comme  float, double etc ... ) 
 

[Sandro]

Bonsoir,

il y a là plusieurs erreurs :

1) quand tu veux qu'une variable soit un nombre à virgule, tu dois utiliser "float" à la place de "int"

2) Les nombres à virgule s'écrivent "en anglais", c'est à dire avec un point au lieu d'une virgule

3) Si quand tu déclare une variable tu mets une étoile (*) devant le nom (par exemple int *mon_pointeur=...), tu es en train de déclarer un pointeur sur une variable de ce type (ie l'adresse en mémoire d'une variable de ce type, ici l'adresse en mémoire d'un entier de type int). Si tu n'as pas trop compris cette explication, c'est pas grave pour l'instant, les pointeurs sont une notion bien plus avancée que tu verra plus tard.

 

La bonne manière de faire serait donc d'écrire :

float degres_pas=0.5;

A noter que si tu prends une variable de type int et que tu essaye d'y mettre une valeur décimale, le programme vas simplement arrondir à l'entier inférieur : si du coup tu écris

int degres_pas=0.5;

alors tu n'auras pas d'erreur, mais degres_pas vas valoir 0!
 

 

[michel]

Bonjour Sandro et MiKe118,

le résultat espérer n'ai pas au rendez-vous .

le moteur oscille comme tu l'avais prédit même avec les 0.5 degrées en + ou - .

je pense que je vais le refaire avec les pas et non les angles .

avec un void moteur (); dans une seul  direction . 

bonne soirèe à tous les membres .

[Sandro]

Bonjour,

est-ce que tu peux nous mettre ton code? Car normalement il ne devrait pas y avoir d’oscillations.

 

Bonne soirée

Sandro