Bonjour à tous, je rencontre un problème pour la commande d'un moteur pas à pas bipolaire avec une carte Arduino. Je vous explique brièvement ma situation :
Mon moteur pas à pas dispose d'un axe autour du quel est enroulé un fil. Je dispose d'un dipôle fournissant un tension variable. Cette tension prend un nombre finis de valeurs (16 au total). Pour limiter les aléas dus à la précision j'ai choisi de définir plutôt des intervalles de tension. Cette tension va être lue par ma carte Arduino. Ensuite, pour chaque valeur de tension, mon moteur doit avoir déroulé une certaine longueur de fil (relativement à la position de départ, à savoir quand 0mm de fil est déroulé). J'ai donc créé une liste qui donne (dans le bon ordre) les longueurs déroulées associées à chaque intervalle de tension lue. Le programme va donc lire la tension, regarder si elle se trouve dans un des intervalles que j'ai défini, et si oui, calculer le nombre de pas nécessaires (par rapport à l'état initial) pour dérouler la longueur associée. Ensuite, le programme fait la différence entre la position actuelle en pas et la position à atteindre, et le moteur se déplace d'autant de pas que la différence (dans le bon sens grâce à une condition sur le signe de la différence). La tension étant amenée à varier durant l'utilisation, l'opération est en loop.

Or quand je lance mon code, le fil se déroule une seule fois, puis plus rien, alors que je fais pourtant à nouveau varier la tension.

Mon Arduino est une UNO R3
Mon moteur est un stepper bipolaire.
Mon hacheur est un L298N
Mon alimentation est de 15V

Je peux vous communiquer mes branchements si besoin même si je pense qu'ils sont bons étant donné que l'opération s'effectue une fois à chaque lancement. Je pense que le problème réside dans le code mais je n'arrive pas à l'identifier.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include <AccelStepper.h>
 
// Définitions des pins de contrôle
#define IN1 8
#define IN2 9
#define IN3 10
#define IN4 11
#define EN1 6
#define EN2 5
#define POT_PIN A0
 
// Initialisation des étapes du moteur
int stepsPerRevolution = 200; // Ajuster selon les spécifications du moteur
float mmPerStep = (8.0 * 3.14159) / 200.0; // Diamètre de l'axe (8 mm) converti en mm par pas
 
// Listes des intervalles de tension et des longueurs de fil correspondantes
float debutIntervalles[] = {0,1,2,3,4}; // Début des intervalles de tension
float finIntervalles[] = {1,2,3,4,5};   // Fin des intervalles de tension
float longueurs[] = {3,5,6,9,10};         // Longueurs de fil déroulées correspondantes en mm
 
// Variables pour la position
long targetPosition = 0;
long currentPosition = 0;
 
void setup() {
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  pinMode(EN1, OUTPUT);
  pinMode(EN2, OUTPUT);
 
  digitalWrite(EN1, HIGH);
  digitalWrite(EN2, HIGH);
 
  Serial.begin(9600);
}
 
// Fonction pour faire un pas du moteur
void stepMotor(int step) {
  switch (step) {
    case 0:
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, LOW);
      digitalWrite(IN3, HIGH);
      digitalWrite(IN4, LOW);
      break;
    case 1:
      digitalWrite(IN1, LOW);
      digitalWrite(IN2, HIGH);
      digitalWrite(IN3, HIGH);
      digitalWrite(IN4, LOW);
      break;
    case 2:
      digitalWrite(IN1, LOW);
      digitalWrite(IN2, HIGH);
      digitalWrite(IN3, LOW);
      digitalWrite(IN4, HIGH);
      break;
    case 3:
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, LOW);
      digitalWrite(IN3, LOW);
      digitalWrite(IN4, HIGH);
      break;
  }
}
 
// Fonction pour faire tourner le moteur jusqu'à la position cible
void moveToPosition(long target) {
  long stepsToMove = target - currentPosition;
  int direction = stepsToMove > 0 ? 1 : -1;
 
  stepsToMove = abs(stepsToMove);
 
  for (long i = 0; i < stepsToMove; i++) {
    stepMotor((currentPosition + i * direction) % 4);
    delay(10); // Ajuster pour contrôler la vitesse
  }
 
  currentPosition = target;
}
 
void loop() {
  int potValue = analogRead(POT_PIN);
  float voltage = potValue * (5.0 / 1023.0);
 
  // Map la tension lue aux intervalles de longueur de corde
  for (int i = 0; i < sizeof(debutIntervalles) / sizeof(debutIntervalles[0]); i++) {
    if (voltage >= debutIntervalles[i] && voltage < finIntervalles[i]) {
      targetPosition = longueurs[i] / mmPerStep;
      break;
    }
  }
 
  moveToPosition(targetPosition);
  delay(50);
}