[Résolu] Recopie signale avec modification période en sortie.

Bonjour,

j'ai un petit problème avec la recopie d'un signal.

Le signale d'entrée est à 62Hz avec une période à 1 de 12ms et à 0 de 4ms et peut atteindre 751hz avec une période à 1 de 1ms et 0 0.33ms.

la recopie simple fonctionne très bien je retrouve ce signale en sortie.
Le problème c'est que je voudrais pouvoir allonger la période à 0 de 0 à 30%.
Et là c'est le drame! :fearful: ma sortie passe à 1 et reste à 1 ne passe jamais à 0.

voici le bout de code

const int PIN_SIGNAL_2 = 12;
const int PIN_COMMANDE_1 = 13;
const int SENSINJ = LOW;

void setup()
{
  pinMode(PIN_SIGNAL_2, INPUT);
  pinMode(PIN_COMMANDE_1, OUTPUT);
}

void loop()
{
  noInterrupts();
  unsigned long duration = pulseIn(PIN_SIGNAL_2,SENSINJ);
  float test = duration* 0.3;
  int ETAT = digitalRead(PIN_SIGNAL_2);
  if (ETAT == LOW){
    digitalWrite(PIN_COMMANDE_1, LOW);}
  else{
    delayMicroseconds(test);
    digitalWrite(PIN_COMMANDE_1, HIGH);
   interrupts();}
}

dans mon esprit ça fonctionne mais pas reellement.

Bon j'ai pas encore reçue mon arduino je fait sur tinkercad pour le moment c'est peut etre ça.[Résolu]

Si on enlève les interruptions, delayMicroseconds() n'est plus remis à jour. Du coup cette instruction ne finira jamais et le programme ne va pas plus loin.

vileroi:
Si on enlève les interruptions, delayMicroseconds() n'est plus remis à jour. Du coup cette instruction ne finira jamais et le programme ne va pas plus loin.

Merci pour la réponse.

J'ai retiré le noInterrupts() et Interrupts() mais toujours le même problème, la sortie passe à 1 quand le signale d'entrée passe à 1 et reste à 1.

Je crois avoir cerner mon problème.

pulseIn

quand je fait

const int PIN_SIGNAL_2 = 12;
const int PIN_COMMANDE_1 = 13;
const int SENSINJ = LOW;
unsigned long duration;

void setup()
{
  pinMode(PIN_SIGNAL_2, INPUT);
  pinMode(PIN_COMMANDE_1, OUTPUT);
}

void loop()
{


int ETAT = digitalRead(PIN_SIGNAL_2);
  if (ETAT == 1){
    digitalWrite(PIN_COMMANDE_1, HIGH);}
  else{
    digitalWrite(PIN_COMMANDE_1, LOW);}
}

ça recopie mon signal.

mais quand je fait

const int PIN_SIGNAL_2 = 2;
const int PIN_COMMANDE_1 = 1;
const int SENSINJ = LOW;
unsigned long duration;

void setup()
{
  pinMode(PIN_SIGNAL_2, INPUT);
  pinMode(PIN_COMMANDE_1, OUTPUT);
}

void loop()
{

  duration = pulseIn(PIN_SIGNAL_2,SENSINJ);
int ETAT = digitalRead(PIN_SIGNAL_2);
  if (ETAT == 1){
    digitalWrite(PIN_COMMANDE_1, HIGH);}
  else{
    digitalWrite(PIN_COMMANDE_1, LOW);}
}

ma sortie passe à l’état 1 et ne passe pas à l'état 0.

là je sèche mes connaissances sont dépassées :grinning: .

hello
si j'ai bien compris, tu cherches à recopier un signal d'une entrée vers une sortie
lorsqu'il est à 1, tu mets la sortie à 1
lorsqu'il passe à zéro, tu maintiens la sortie à 1 d'un tiers de la durée du signal.

si c'est bien ça, la fonction pulseln n'est pas ok car elle est bloquante
lorsqu'elle est exécuté, elle détecte le flanc montant ( dans ton cas) et elle attend un "time out" d'une seconde par défaut ( si tu n'as rien précisé dans son appel.)

dans ton prg: lorsque pin 2 passe à 1, "pulseln" est exécutée (pour une seconde(time out oblige)) et tu n'as pas reporté son état sur la sortie.

testes un truc comme celui ci
attention, moniteur à 1000000 de bauds
et les temps sont en millis car en micros c'était plus difficile de les voir

const int PIN_SIGNAL_2 = 12;
const int PIN_COMMANDE_1 = 13;
const int SENSINJ = LOW;
boolean flag = false;
unsigned long temps_impulsion = 0;
void setup()
{ Serial.begin(1000000);
  pinMode(PIN_SIGNAL_2, INPUT);
  pinMode(PIN_COMMANDE_1, OUTPUT);
}

void loop()
{
  if ((digitalRead(PIN_SIGNAL_2)) && (flag == false)) {
    temps_impulsion = millis();
    flag = true;
    Serial.print("....................debut chrono impulsion "); Serial.println(temps_impulsion);
  }
  if ((!digitalRead(PIN_SIGNAL_2)) && (flag == true)) {
    temps_impulsion = millis() - temps_impulsion;
    flag = false;
    Serial.print("....................fin chrono. impulsion totale "); Serial.println(temps_impulsion);
  }
  

  float test = temps_impulsion * 0.3;
  
  if (digitalRead(PIN_SIGNAL_2))                                        //si signal à 1, on le recopie
  {
    digitalWrite(PIN_COMMANDE_1, HIGH); Serial.print("1 pin 2 \t");Serial.println(millis() - temps_impulsion);
  }
  else {                                                                //sinon si signal = 0, 
    Serial.print("1 maintenu par tempo  "); Serial.println(test);
    delay(test);                                            //on le prolonge d'1/3 de sa durée
    digitalWrite(PIN_COMMANDE_1, LOW); Serial.println("0");
    temps_impulsion = 0; test = 0;
  }
}

dfgh:
hello
si j'ai bien compris, tu cherches à recopier un signal d'une entrée vers une sortie
lorsqu'il est à 1, tu mets la sortie à 1
lorsqu'il passe à zéro, tu maintiens la sortie à 1 d'un tiers de la durée du signal.

si c'est bien ça, la fonction pulseln n'est pas ok car elle est bloquante
lorsqu'elle est exécuté, elle détecte le flanc montant ( dans ton cas) et elle attend un "time out" d'une seconde par défaut ( si tu n'as rien précisé dans son appel.)

dans ton prg: lorsque pin 2 passe à 1, "pulseln" est exécutée (pour une seconde(time out oblige)) et tu n'as pas reporté son état sur la sortie.

testes un truc comme celui ci
attention, moniteur à 1000000 de bauds
et les temps sont en millis car en micros c'était plus difficile de les voir

const int PIN_SIGNAL_2 = 12;

const int PIN_COMMANDE_1 = 13;
const int SENSINJ = LOW;
boolean flag = false;
unsigned long temps_impulsion = 0;
void setup()
{ Serial.begin(1000000);
 pinMode(PIN_SIGNAL_2, INPUT);
 pinMode(PIN_COMMANDE_1, OUTPUT);
}

void loop()
{
 if ((digitalRead(PIN_SIGNAL_2)) && (flag == false)) {
   temps_impulsion = millis();
   flag = true;
   Serial.print("....................debut chrono impulsion "); Serial.println(temps_impulsion);
 }
 if ((!digitalRead(PIN_SIGNAL_2)) && (flag == true)) {
   temps_impulsion = millis() - temps_impulsion;
   flag = false;
   Serial.print("....................fin chrono. impulsion totale "); Serial.println(temps_impulsion);
 }

float test = temps_impulsion * 0.3;
 
 if (digitalRead(PIN_SIGNAL_2))                                        //si signal à 1, on le recopie
 {
   digitalWrite(PIN_COMMANDE_1, HIGH); Serial.print("1 pin 2 \t");Serial.println(millis() - temps_impulsion);
 }
 else {                                                                //sinon si signal = 0,
   Serial.print("1 maintenu par tempo  "); Serial.println(test);
   delay(test);                                            //on le prolonge d'1/3 de sa durée
   digitalWrite(PIN_COMMANDE_1, LOW); Serial.println("0");
   temps_impulsion = 0; test = 0;
 }
}

Merci!! c'est ça mais avec la logique inverse, c'est le temps qu'il est à 0 que je veux rallonger de X temps qui est déjà calculer dans un autre morceau de prog.

Je vais étudier ton code pour inverser la logique.

Encore merci!.

Mon projet complet tourne déjà sur un raspberry sous node-red mais ce qui me fait basculer sur arduino c'est le temps de démarrage de la carte, presque 2 mn sur raspberry.
Mais j'ai déjà tout expliqué dans ma présentation.

logique inverse et qq modifs

const int PIN_SIGNAL_2 = 12;
const int PIN_COMMANDE_1 = 13;
const int SENSINJ = LOW;
boolean flag = false;
unsigned long temps_impulsion = 0;
void setup()
{ Serial.begin(1000000);
  pinMode(PIN_SIGNAL_2, INPUT);
  pinMode(PIN_COMMANDE_1, OUTPUT);
}

void loop()
{
  if ((!digitalRead(PIN_SIGNAL_2)) && (flag == false)) {
    temps_impulsion = millis();
    flag = true;
    Serial.print("....................debut chrono impulsion "); Serial.println(temps_impulsion);
  }
  if ((digitalRead(PIN_SIGNAL_2)) && (flag == true)) {
    temps_impulsion = millis() - temps_impulsion;
    
    Serial.print("....................fin chrono. impulsion totale "); Serial.println(temps_impulsion);
  }
  

  float test = temps_impulsion * 0.3;
  
  if (!digitalRead(PIN_SIGNAL_2))                                        //si signal à 0, on le recopie
  {
    digitalWrite(PIN_COMMANDE_1, digitalRead(PIN_SIGNAL_2)); Serial.print("0 pin 2 \t");Serial.println(millis() - temps_impulsion);
  }
  else 
  {                                                                //sinon si signal = 1, 
    Serial.print("SIGNAL_2 maintenu a 0 par tempo  "); Serial.println(test);
    delay(test);                                                   //on le prolongeà 0 d'1/3 de sa durée
    digitalWrite(PIN_COMMANDE_1, digitalRead(PIN_SIGNAL_2)); Serial.println("1");
    temps_impulsion = 0; test = 0;flag = false;
  }
}

dfgh:
logique inverse et qq modifs

Encore merci!

C'est a peux près ce que j'avais trouvé!

Me reste plus qu'à intégrer tous ça et faire mouliner le tous!