besoin d'aide programmation arduino

Pour le B, il te faut les informations liées à ta bobine

C'est a dire, si c'est pour le déclenchement, je suis quasiment sure que c'est une tension négative qui commande le thyristor. Mais je ne peut pas l'affirmer car je n'ai n'ai pas pu générer de signal négatif. je réfléchi a une solution.

Je viens de faire un essai avec une diode en sortie de capteur pour récupérer que le négatif du signal et cela fonctionne. Donc la bobine est commandé par la tension négative.

Je trouve cela étrange de commander un thyristor avec une tension négative (vu que normalement c'est un courant positif entre la Gate et tla cathode qui va polarisé les transistors) mais soit. Une tension négative, c'est bien mais l'ordre de grandeur c'est mieux . Et ensuite est-ce que tu as une source dans ton montage actuellement pour pouvoir activer ton thyrsistor ou pas du tout ?

Je viens de faire un essai avec une diode en sortie de capteur pour récupérer que le négatif du signal et cela fonctionne. Donc la bobine est commandé par la tension négative.

Personnellement je n'ai pas compris ce qui a été essayé, ( montage effectué ? ) je ne sais pas non plus " ce qui marche " = ( Quelle est l'action que tu observes ? Tu arrives à activer la bobine ? )

Il me semble que le code de Mike (pour Turboseb) permettait de détecter les fronts montant et d'appliquer un pulse en sortie (déphasé en fonction de la fréquence). Donc dans un premier temps tu peux déjà utiliser ce code (quitte à modifier la fonction qui calcule le déphasage pour retourner une valeur constante et voir si ça marche). Et techniquement pour détecter un front montant, on doit juste trouver les changements d'états et regarder l'état final.
 

#define INPUTPIN 2
#define OUTPUTPIN 5

#define DELAISPULSE 500 // 500us

bool nouveauPulse = false;
bool pulseEnCours = false;
uint32_t tempsProchainPulse = 0;
bool oldEtat = LOW;
uint32_t oldTemps = 0;

void setup() {
   pinMode(INPUTPIN, INPUT);
   pinMode(OUTPUTPIN, OUTPUT);
}

void loop() {
   uint32_t temps = micros();
   if ( !nouveauPulse ) {
      bool etat = digitalRead(INPUTPIN);
      if ( etat != oldEtat ) {
         oldEtat = etat;
         if (etat) {
            uint32_t delaisInterChange = temps - oldTemps;
            tempsProchainPulse = temps + decalagePulse(delaisInterChange);

            oldTemps = temps;
            nouveauPulse = true;
         }
      }
   } else {
      if ( temps >= tempsProchainPulse ) {
         if (!pulseEnCours) {
            digitalWrite(OUTPUTPIN, HIGH);
            pulseEnCours = true;
         } else if ( temps >= tempsProchainPulse + DELAISPULSE) {
            digitalWrite(OUTPUTPIN, LOW);
            nouveauPulse = false;
            pulseEnCours = false;
         }
      }
   }
}

uint32_t decalagePulse (uint32_t delaisInterChange) {
   if ( delaisInterChange < XX )
      return XXXX ;
   else if ( delaisInterChange < XX )
      return XXXX ;
   else if ( delaisInterChange < XX )
      return XXXX ;
}

 

 
 
 
Voici le code modifié permettant de faire un pulse de 500us avec un déphasage temporelle variable suivant uniquement sur front montant au lieu de front montant et descendant. 

Il faut modifier la fonction décalage pulse en fonction du besoin.

In c'est le pin de l'arduino utilisé 

Voici l’intérieur de la bobine, le générateur étant remplacé par une batterie 12v.

Du coup maintenant que l'étape A est valide et au vu du schémas que tu as posté et des différentes info que j'ai je propose ce test pour l'étape B. 

avec ce code : 

 

#define INPUTPIN 2
#define OUTPUT1PIN 3
#define OUTPUT2PIN 4

#define DELAISPULSE 500 // 500us

bool nouveauPulse = false;
bool pulseEnCours = false;
uint32_t tempsProchainPulse = 0;
bool oldEtat = LOW;
uint32_t oldTemps = 0;

void setup() {
   pinMode(INPUTPIN, INPUT);
   pinMode(OUTPUT1PIN, OUTPUT);
   pinMode(OUTPUT2PIN, OUTPUT);
   digitalWrite(OUTPUT1PIN, HIGH);
   digitalWrite(OUTPUT2PIN, LOW);
}

void loop() {
   uint32_t temps = micros();
   if ( !nouveauPulse ) {
      bool etat = digitalRead(INPUTPIN);
      if ( etat != oldEtat ) {
         oldEtat = etat;
         if (etat) {
            uint32_t delaisInterChange = temps - oldTemps;
            tempsProchainPulse = temps + decalagePulse(delaisInterChange);

            oldTemps = temps;
            nouveauPulse = true;
         }
      }
   } else {
      if ( temps >= tempsProchainPulse ) {
         if (!pulseEnCours) {
            digitalWrite(OUTPUT1PIN, LOW);
            digitalWrite(OUTPUT2PIN, HIGH);
            pulseEnCours = true;
         } else if ( temps >= tempsProchainPulse + DELAISPULSE) {
            digitalWrite(OUTPUT1PIN, HIGH);
            digitalWrite(OUTPUT2PIN, LOW);
            nouveauPulse = false;
            pulseEnCours = false;
         }
      }
   }
}

uint32_t decalagePulse (uint32_t delaisInterChange) {
   if ( delaisInterChange < XX )
      return XXXX ;
   else if ( delaisInterChange < XX )
      return XXXX ;
   else if ( delaisInterChange < XX )
      return XXXX ;
}

je pars du principe que la masse sur la bobine du TCI c'est uniquement un signal de commande et pas un signal de puissance... Et donc en mettant cette référence sur un GPIO de l'arduino et pas à la masse on doit pouvoir faire "illusion d'un signal négatif". 

à tester donc, je suis pas sûr à 100% ...  Si je me trompe sur le principe c'est adieu la nano ...

Oups la Nano. 

Bon visiblement mon hypothèse était mauvaise et la masse servait à faire passer du courant ...  Dommage ça aurait simplifié le montage... 
Du coup au vu des informations données il va te falloir un convertisseur de tension négatif de ce genre : 

un qui fournit -5V ça serait bien

https://fr.aliexpres...2823027942.html

https://fr.aliexpres...1131999268.html

Le GND et 12V de ta batteries se brancheront sur l'entré de ton convertisseur 

et il faudra alimenter ta arduino avec ce convertisseur la sortie de ce convertisseur et le GND BATTERIE en mettant le -5V du convertisseur sur le GND ARDUINO   et le GND BATTERIE sur le 5V ARDUINO .... 

Ainsi tu auras bien un potentiel de 5V sur l'entré 5V GND de ta arduino , et ta arduino fournira une tension " -5V 0 " sur ses sortie d'après le référentiel GND BATTERIE ...

Pour tester le déphasage tu peux utiliser cette fonction de décalage qu'on pourra améliorer un peu plus tard. 

Pour le test j'ai ajusté l'effet visuel afin d'allumer la petite led qui est sur l'arduino ( pin 13 ) lorsque le délais est " court "  = que ton moteur va plus vite que les 150 hz et faire qu'elle s'éteint quand ton moteur ralentit suffisamment

uint32_t decalagePulse (uint32_t delaisInterChange) {
  if ( delaisInterChange < 6666 ) {  // 6666 µs  = 0.006s environ 150 hz ( calcul : 1000 * 1000 * 1 / 150) 
    digitalWrite(13, HIGH);
    return 100 ; 
  }
  else {
    digitalWrite(13, LOW);
    return 4000;
  }
}

Merci Mike, cela fonctionne. 

Top si ça fonctionne ! 

Et pour la suite quand tout fonctionnera et que tu voudras passer sur un attiny85 pour faire le truc en beaucoup plus petit tu pourras suivre ce lien : 
https://create.ardui...uino-uno-afb829

Ci-dessous, une avancée du codage.

Mais connaîtriez vous une solution pour avoir un décalage linéaire au lieu d'une marche a chaque changement d'état?

Merci.

#define INPUTPIN 2
#define OUTPUTPIN 5

bool nouveauPulse = false;
bool pulseEnCours = false;
uint32_t tempsProchainPulse = 0;
bool oldEtat = LOW;
uint32_t oldTemps = 0;

void setup() {
   pinMode(INPUTPIN, INPUT);
   pinMode(OUTPUTPIN, OUTPUT);
   digitalWrite(OUTPUTPIN, HIGH);
}

void loop() {
   uint32_t temps = micros();
   if ( !nouveauPulse ) {
      bool etat = digitalRead(INPUTPIN);
      if ( etat != oldEtat ) {
         oldEtat = etat;
         if (etat) {
            uint32_t delaisInterChange = temps - oldTemps;
            tempsProchainPulse = temps + decalagePulse(delaisInterChange);

            oldTemps = temps;
            nouveauPulse = true;
         }
      }
   } else {
      if ( temps >= tempsProchainPulse ) {
            digitalWrite(OUTPUTPIN, LOW);
            digitalWrite(OUTPUTPIN, HIGH);
            nouveauPulse = false;
      }
   }
}
uint32_t decalagePulse (uint32_t delaisInterChange) {
  if ( delaisInterChange > 8570 ) {  // 6666 µs  = 0.006s environ 150 hz ( calcul : 1000 * 1000 * 1 / 150)
    return 500 ;
  }
  else if ( delaisInterChange > 7500  ) {
    return 1000 ;
  }
  else if ( delaisInterChange > 6666  ) {
    return 2000 ;
  }
  else if ( delaisInterChange > 6000  ) {
    return 3000 ;
  }
  else {
    return 300;
  }
}

Est-ce que tu voudrais garder la même pente pour chacune de tes "étapes" ?

La pente ne peut pas être la même puisque les valeurs de retard sont différentes. Mais peut être que je me trompe ou que j'ai mal compris la question.

Bon du coup pour la dernière partie voilà le code que je te propose de tester.

C'est censé gérer aussi bien les décalages positifs que négatif et la variation du décalage est linéaire. 
Pour ajuster les courbes il faut que tu modifies les valeurs dans le tableau ins et outs. 
Si tu modifie le nombre de valeur, pense à modifier la variable NBINSANDOUT . 
Il faut bien entendu autant de ins que de outs pour que ça marche ... 

#define INPUTPIN 2
#define OUTPUTPIN 5

bool nouveauPulse = false;
uint32_t tempsProchainPulse = 0;
bool oldEtat = LOW;
uint32_t oldTemps = 0;

#define NBINSANDOUT 5
uint16_t ins[NBINSANDOUT] = {5000, 6000, 6666, 7500, 8500 };  // temps en microsecondes entre deux pulses ( doit forcément être rangé par ordre croissant)
int16_t outs[NBINSANDOUT] = {300, 3000, 2000, 1000, 500 };    // décalage en microsecondes désiré (peut être négatif ou positif)

void setup() {
  pinMode(INPUTPIN, INPUT);
  pinMode(OUTPUTPIN, OUTPUT);
  digitalWrite(OUTPUTPIN, HIGH);
}

void loop() {
  uint32_t temps = micros();
  bool etat = digitalRead(INPUTPIN);  
  if ( etat != oldEtat ) {    // Si modification de l'état du capteur
    if (etat) {               // Cas d'un front montant du capteur
      uint32_t delaisInterChange = temps - oldTemps; // cas du débordement des uint32 non géré ? Est ce un problème ?
      int16_t decalage = decalagePulse(delaisInterChange);
      if(decalage < 0 ) {
        if (nouveauPulse)       // On gère le cas où on devait déjà faire un pulse ... pour éviter de sauter un pulse.
          fairePulse();
        tempsProchainPulse = temps + delaisInterChange + decalage;
        oldTemps = temps;
        nouveauPulse = true;
      } else {
        tempsProchainPulse = temps + decalage;
        oldTemps = temps;
        nouveauPulse = true;
      }
    }
    oldEtat = etat;
  } else {
    if ( nouveauPulse && temps >= tempsProchainPulse )
     fairePulse();
  }  
}

void fairePulse() {
  digitalWrite(OUTPUTPIN, LOW);
  digitalWrite(OUTPUTPIN, HIGH);
  nouveauPulse = false;
}

int16_t decalagePulse(uint16_t value) {
 int16_t out;
 uint8_t nbInMax = NBINSANDOUT - 1;

 if(value <= ins[0])
  out = outs[0];
 else if(value > ins[nbInMax])
  out = outs[nbInMax];
 else {
  for(uint8_t i = 0; i < nbInMax; i++) {
   if(value <= ins[i + 1]) {
    out = map(value, ins[i], ins[i + 1], outs[i], outs[i + 1]);
    break;
   }
  }
 }
 return out;
}