Bonjour à tous 
,
Je suis actuellement en stage en entreprise et je dois remettre en marche une machine qui est gérée par une carte Arduino MEGA 2560.
Je me suis donc mit à l'Arduino avec le peu de notion que j'avais.
Pour vous mettre dans le contexte :
Cette machine est un banc à essai d'arbre à un came, elle permet de relever le profil des cames.
Elle fonctionne de la manière suivante:
L'arbre est mit en rotation grâce à un moteur électrique, un comparateur vient lécher la came et me donne donc son profil. De plus, il y a un encodeur rotatif qui permet d'envoyer un signal carré à ma carte arduino et lui dit donc quand il faut enregistrer la valeur de mon comparateur (à chaque front montant du signal carré émis par le comparateur).
Mon problème est le suivant:
Lorsque je lance le programme, il est sensé s’arrêter au bout de 1000 points (fronts montant). cependant le moteur ne s’arrête pas.
J'ai l'impression que le programme ne détecte pas les fronts montants de mon encodeur. De plus, le retour de mon encodeur est branché sur la cosse SCL 21 de ma carte.
Je met ci joint le code Arduino.
Si vous avez des solution ou des problème que je n'aurais pas vu je suis preneur!!!!!
Je me répète mais je suis tout nouveau dans le monde de la programmation..
// Commande moteur
#define VR_PIN 52
#define ALM_PIN 50
#define RUN_PIN 46
#define STA_PIN 48
// Connexion Encodeur rotatif
// Pulse sur INT0 (== D2)
#define PULSE_INT INT2
#define PULSE_PIN 21
// Connexion Comparateur digital
//mic REQ line goes to pin 5 through q1 (arduino high pulls request line low)
#define REQ_PIN 5
//mic Data line goes to pin 4
#define DAT_PIN 4
//mic Clock line goes to pin 3
#define CLK_INT INT1 // Interrupt 1 => pin 3
#define CLK_PIN 3
//Gestion PULSE
#define DECIMATION_PULSE 4
#define NB_PTS 1000
byte compteur_decimation = DECIMATION_PULSE;
int compteur_pulse = 0;
void Pulse();
// Gestion reception des bits sur front montant de CLK
#define NB_NIBBLES 13 // Nombre de quartets transmis par requête
byte compteur_bit; // Compteur de bit dans chaque quartet
byte compteur_nibble = NB_NIBBLES;
byte SeqCapture=0; // Buffer données mesurée
byte SeqTransmit=0; // Buffer données transmises
byte SequenceNibble[2][NB_NIBBLES]; // Tableau mémoire tampon
void Clock();
// Gestion transmission
volatile boolean GoTransmit = false;
void Transmit();
volatile boolean Running = false;
void Pulse()
{
if ( --compteur_decimation == 0 )
{
digitalWrite(RUN_PIN, HIGH); // Arrêt du moteur
delay(10); // Délai de stabilisation mécanique
digitalWrite(REQ_PIN, HIGH); // Requête au comparateur
compteur_bit = compteur_nibble = 0;
compteur_decimation = DECIMATION_PULSE;
attachInterrupt( CLK_INT, Clock, FALLING ); // Activation de la synchronisation avec l'horloge de la transmission du comparo
}
if ( ++compteur_pulse >= NB_PTS)
{
detachInterrupt( PULSE_INT ); // Désactivation de la détection des impulsions du codeur
}
}
// Gestion reception des bits sur front descendant de CLK
void Clock()
{
if ( compteur_nibble < NB_NIBBLES )
{
bitWrite( SequenceNibble[SeqCapture][compteur_nibble], compteur_bit, digitalRead( DAT_PIN ) ); // Ecriture bit par bit de la valeur reçue
if ( ++compteur_bit == 4 )
{
// 4 bits de fait, on passe au quartet suivant en repartant au 1er bit
compteur_bit = 0;
++compteur_nibble;
// Si on a lu 13 quartets, il faut indiquer à loop() qu'il faut transmettre
if ( compteur_nibble == NB_NIBBLES )
{
SeqTransmit = SeqCapture; // on indique que le buffer a transmettre c'est le buffer courant
SeqCapture = 1 - SeqCapture; // et on change de buffer courant pour la prochaine capture
GoTransmit = true; // go
detachInterrupt( CLK_INT ); // plus besoin de CLK
}
}
}
digitalWrite(REQ_PIN, LOW); // reset request
}
void setup()
{
Serial.begin(9600);
pinMode(REQ_PIN, OUTPUT);
digitalWrite(REQ_PIN, LOW); // set request at high
pinMode(CLK_PIN, INPUT);
digitalWrite(CLK_PIN, HIGH); // enable internal pull ups
pinMode(DAT_PIN, INPUT);
digitalWrite(DAT_PIN, HIGH); // enable internal pull ups
pinMode(PULSE_PIN, INPUT);
memset( SequenceNibble, 0, sizeof(SequenceNibble) );
pinMode(VR_PIN, OUTPUT);
pinMode(ALM_PIN, OUTPUT);
pinMode(RUN_PIN, OUTPUT);
pinMode(STA_PIN, OUTPUT);
digitalWrite(RUN_PIN, HIGH); // Moteur arrêté à l'état initial
digitalWrite(ALM_PIN, LOW);
digitalWrite(VR_PIN, LOW);
digitalWrite(STA_PIN, LOW);
}
void loop()
{
if ( !Running && Serial.available() ) // Reception de la commande du PC pour le lancement de l'acquisition
{
byte cmdByte = Serial.read();
if ( cmdByte > 0 ) // Start
{
digitalWrite(ALM_PIN, LOW);
Running = true;
compteur_decimation = DECIMATION_PULSE;
compteur_pulse = 0;
attachInterrupt( PULSE_INT, Pulse, RISING ); // Activation de la détection des impulsions du codeur
delay(100);
digitalWrite(ALM_PIN, HIGH);
digitalWrite(RUN_PIN, LOW); // Premier démarrage du moteur
}
}
if ( GoTransmit )
{
char buf[14]; // "= " + signe + 6 chiffres + point décimal + '\0' terminal = 9 caractères
// Nibble[4] : 0='+', 1='-
buf[0] = (SequenceNibble[SeqTransmit][4] < 1) ? '+' : '-'; // Détermination du signe sur le 4ème quartet de la valeur
// Nibble[5..10] : chiffres, Nibble[11] : position du point décimal
byte decimal_point = 1; // 5 - SequenceNibble[SeqTransmit][11];
byte pos = 1;
for(int chiffre = 0 ; chiffre < 4 ; chiffre++ )
{
buf[pos++] = SequenceNibble[SeqTransmit][chiffre+7]+'0';
// on insère le point décimal (transformé en virgule pour excel fr) au bon endroit
if ( chiffre == decimal_point )
buf[pos++] = ',';
}
buf[pos] = '\0'; // Caractère de fin de ligne
Serial.println(buf); // Envoi de la valeur traitée au PC
memset( SequenceNibble[SeqTransmit], 0, sizeof(SequenceNibble[SeqTransmit]) ); // Réinitialisation de la mémoire tampon
GoTransmit = false;
delay(20); // Délai d'acquisition
digitalWrite(RUN_PIN, LOW); // Redémarrage moteur
}
if (compteur_pulse >= NB_PTS)
digitalWrite(RUN_PIN, HIGH); // Arrêt moteur
}