puls negeren voor bepaalde tijd

IDE gerelateerde berichten
Gebruikers-avatar
Berichten: 631
Geregistreerd: 15 Nov 2015, 11:54

Re: puls negeren voor bepaalde tijd

Berichtdoor Gij Kieken » 04 Apr 2022, 19:26

De code is zeker nog niet afgewerkt, maar het is misschien een begin.
Die variabel vertraging zou ik ook nog in een functie plaatsen om de loop overzichtelijker te maken.
Dan nog iets triggeren om op een andere uitgang een relais te laten blinken of zo.
Ook nog Reset knop voorzien als er een alarm melding doorkomt.


Code: Alles selecteren
/*
   De code is nog niet afgewerkt,
   maar het is misschien al een begin

*/
const byte inPin = 4;
const byte resetPin = 5;
const byte ledPin = 12;

byte inState = HIGH;
byte curInState;
byte ledState = LOW;
byte lastInState = HIGH;

unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 100;
unsigned long previousMillis;
int varTime = 500;
bool enableTimer = false;

// De potmeter
const byte POTpin = A0;
int potValue = 0;

byte notified = LOW;//Een merker voor start variabel vertraging

void setup() {
  Serial.begin(9600);
  pinMode(inPin, INPUT_PULLUP);
  pinMode(resetPin, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);
  pinMode( LED_BUILTIN, OUTPUT);
  digitalWrite(ledPin, ledState);
}

void loop() {
  unsigned long currentMillis = millis();
  curInState = digitalRead(inPin);
  ledState =  funcDebounce (curInState);

  potValue = analogRead(POTpin);//Waarde tussen 0 - 1023
  varTime = map(potValue, 0, 1023, 5000, 30000);//Converteer naar 5 tot 30 sec in millis

  digitalWrite(ledPin, ledState);//update the LED

  //*** Als er een signaal binnenkomt start een variabele vertraging
  //Serial.print("De ledState is : ");
  //Serial.println(ledState);
  if (ledState == HIGH) {
    notified = HIGH;
    if (!enableTimer) {
      previousMillis = currentMillis;  // remember this time
      enableTimer = true;              // enable the timer
      digitalWrite( LED_BUILTIN, HIGH);
    }
  }
  if (enableTimer) {// is the timer running ?
    if ( currentMillis - previousMillis >= varTime) {
      enableTimer = false;// turns itself off, to run only once
      digitalWrite( LED_BUILTIN, LOW);
    }
  }
  if (ledState == HIGH) {//If the input stays triggered Reset the function
    delay(500);
    ledState = LOW;
  }
  //*** Als de vertraging is afgelopen,zet terug een merker en kijk als er input is.
  // Reset een paar zaken en geef indien nodig een Alarm door.
}

//**** Functions ****
/*
   Leest een ingangs signaal in (byte) en
   geeft een antidender signaal terug (byte)
   De ingangspuls moet minimum 100 msec duren
*/
byte funcDebounce (byte myInput) {

  if (myInput != lastInState) {
    // reset the debouncing timer
    lastDebounceTime = millis();
  }
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (myInput != inState) {
      inState = myInput;
      if (inState == LOW) {//only toggle the LED if the new opto state is LOW
        ledState = HIGH;
      }
    }
  }
  lastInState = myInput;
  return ledState;
}


Advertisement

Gebruikers-avatar
Berichten: 11
Geregistreerd: 23 Mrt 2022, 17:40

Re: puls negeren voor bepaalde tijd

Berichtdoor AutonomY » 05 Apr 2022, 11:21

Bedankt allemaal voor het meedenken van het door mij geopperde probleem.
Wat een talent op dit forum! Echte logische denkers! Frits heeft me een werkende Schets geleverd. Deze lijkt nu aan de verwachting te voldoen. Gij Ook bedankt voor je Schets. Deze stop ik in een 2de UNO en ga hier van leren. Jullie enthousiasme heeft me geraakt.
Heel erg bedankt!
Evert

Gebruikers-avatar
Berichten: 631
Geregistreerd: 15 Nov 2015, 11:54

Re: puls negeren voor bepaalde tijd

Berichtdoor Gij Kieken » 05 Apr 2022, 19:41

Fijn om te horen dat er plausibel oplossing is voor de uitdaging.
Nu zou het interessant zijn voor de mede forum volgers als je de oplossing mag posten.
@ Frits keep on going.

Berichten: 180
Geregistreerd: 26 Aug 2015, 11:57

Re: puls negeren voor bepaalde tijd

Berichtdoor Frits1956 » 06 Apr 2022, 17:10

Heb het zo eenvoudig mogelijk geschreven zodat iemand met minder programmeer kennis/ervaring kan begrijpen hoe het werkt en daardoor toch aanpassingen kan doen.
Alle aanpassingen zijn bij de constanten te wijzigen. Overzichtelijk, op een duidelijk te herkennen plek in de software waardoor de meest optimale instelling door proberen benaderd kan worden.
Als met een dergelijk programma 80% van de onterechte meldingen eruit gefilterd kan worden is dat al een flinke winst. Het is een utopie om 100% onterechte meldingen te voorkomen lijkt mij.

Over het algemeen zal ik in dit forum met mijn beperkte kennis alleen aanwijzingen en tips geven, opdat de vraagsteller/ster de gelegenheid krijgt zelf na te denken en ervan te leren maar deze situatie rechtvaardigde een uitzondering vond ik.

Code: Alles selecteren
// Library's --------------------------------------------------------


// Constanten -------------------------------------------------------
#define Pulspoort 5         // dit is het pinnummer op de arduino, kan je naar wens wijzigen
#define Belpoort 6          // dit is het pinnummer op de arduino, kan je naar wens wijzigen
#define Resetpoort 7        // dit is het pinnummer op de arduino, kan je naar wens wijzigen
#define Wachttijd 10000     // wachttijd 10 seconden in milliseconden, kan je naar wens wijzigen
#define Rustigtijd 60000    // als er 1 minuut in milliseconden geen geluid is geweest, kan je naar wens wijzigen
#define MaxAantSignals 99   // tot honderd pulsen kunnen worden bewaard
#define NegeerAantSig 5     // aantal signalen minimaal binnen wachttijd moet zijn geweest
#define vertraagtijd 100    // om het lezen van de pulsen wat te vertragen


// globale variabelen -----------------------------------------------
int VlagTeller = 1;
unsigned long Vlaggen [MaxAantSignals];


// Programma --------------------------------------------------------
void setup()
{ Serial.begin(9600);
  pinMode(Pulspoort, INPUT_PULLUP);
  pinMode(Resetpoort, INPUT_PULLUP);
  pinMode(Belpoort, OUTPUT);
}


void loop()
{ if (digitalRead(Pulspoort) == LOW )                 // hier lees je de babyphone en als deze signaal geeft
  { Vlaggen[VlagTeller] = millis();                   // bewaar je de tijd dat het geluid er was
    S_P("pulspoort");                                 // laat op de serial monitor zien welke waarde
    do                                                // voer deze loop uit
    { digitalRead(Pulspoort);                         // blijf de pulspoort uitlezen.....
      if (millis() - Vlaggen[VlagTeller] > Wachttijd) // controleer of het geluid lang aanhoud
      { digitalWrite (Belpoort, HIGH);                // en is de tijd langer dan Wachttijd dan bel je
        S_P ("Bellen 1" );                            // laat op de serial monitor zien welke waarde
      }
    }
    while (digitalRead(Pulspoort) == LOW);            // .... tot het signaal wegvalt
    VlagTeller += 1;                                  // als de puls is gestopt, verhoog je de teller
    delay(vertraagtijd);                              // om het lezen van de pulsen wat te vertragen
  }
  if (millis() - Vlaggen[VlagTeller - 1] >  Rustigtijd) // is er gedurende Rustigtijd geen signaal geweest
  { VlagTeller = 0;                                   // reset de vlagteller
    Vlaggen[VlagTeller] = 0;                          // reset de vlaggen
    S_P("rustig tijd");                               // laat op de serial monitor zien welke waarde
  }
  if (digitalRead(Resetpoort) == LOW)                 // resetknop ingedrukt
  { digitalWrite(Belpoort, LOW);                      // Bel uitzetten
    VlagTeller = 0;                                   // reset de vlagteller
    Vlaggen[VlagTeller] = 0;                          // reset de vlaggen
    S_P ("Bellen uit" );                              // laat op de serial monitor zien welke waarde
  }
  if ((Vlaggen[VlagTeller - 1] - Vlaggen[0] > Wachttijd)
      && (VlagTeller > NegeerAantSig))                // check wachttijd en aantal signalen
  { digitalWrite (Belpoort, HIGH);                    // en is de tijd langer dan Wachttijd dan bel je
    S_P ("Bellen 3" );                                // laat op de serial monitor zien welke waarde
  }
}


// Info op Serial Monitor -------------------------------------------
void S_P(String melding)
{ Serial.print (melding);
  Serial.print ( " VlagTeller ");
  Serial.print ( VlagTeller);
  Serial.print ( " millis ");
  Serial.println ( Vlaggen[VlagTeller]);
}

Gebruikers-avatar
Berichten: 631
Geregistreerd: 15 Nov 2015, 11:54

Re: puls negeren voor bepaalde tijd

Berichtdoor Gij Kieken » 06 Apr 2022, 21:14

@Frits,
De code zit mooi in elkaar.
Zodra ik wat tijd vind, maak ik mijn sketch ook af en post deze.

Gebruikers-avatar
Berichten: 631
Geregistreerd: 15 Nov 2015, 11:54

Re: puls negeren voor bepaalde tijd

Berichtdoor Gij Kieken » 07 Apr 2022, 21:32

Bij mij is het op het eerste zicht heel wat omslachtiger.
Met gebruik van hier en daar een pointer zou de code eenvoudiger worden.
Dus gewoon voor de fun dan maar.

Code: Alles selecteren
/*
   Dit is eerder een artisanale relais techniek.
   De Led's dienen enkel als illustratie en controle.
   Er worden twee potmeters gebruikt
   De ene kant aan +5vot, andere kant aan gnd.
   De lopers respectievelijk aan A0 en A1.
   Potmeter A0 dient voor de negeertijd in te stellen.
   Potmeter A1 dient voor de alarmtijd in te stellen.
   Na de alarmtjd Reset de schakeling gereed voor de eventuele
   volgende pulsen.
   Bij een echte Alarm melding moet de relais geReset worden
   via de resetPin.
   Met nog een potmeter en een counter zou je het aantal pulsen
   kunnen instellen wanneer een echte alarm melding moet doorkomen.
*/

const byte inPin = 4;
const byte resetPin = 5;
const byte POTpin = A0;//The variable ignoreTime potmeter
const byte POT1pin = A1;//The variable alertTime potmeter
const byte relaisPin = 9;
const byte ignoreLedPin = 10;
const byte alertLedPin = 11;
const byte optoLedPin = 12;

byte firstBoot = LOW;//Prevents erratic behavior
byte ledState = LOW;//Output of funcDebounce
byte ignoreTime = LOW;
byte alertState = LOW;
byte pulsState = LOW;

unsigned long debounceDelay = 100;//Time the signal should be present

void setup() {
  Serial.begin(9600);
  pinMode(inPin, INPUT_PULLUP);
  pinMode(resetPin, INPUT_PULLUP);
  pinMode(relaisPin, OUTPUT);
  pinMode(ignoreLedPin, OUTPUT);
  pinMode(alertLedPin, OUTPUT);
  pinMode(optoLedPin, OUTPUT);
  pinMode( LED_BUILTIN, OUTPUT);
  digitalWrite(optoLedPin, ledState);
  digitalWrite(ignoreLedPin, ignoreTime);
  digitalWrite(alertLedPin, alertState);
  digitalWrite(relaisPin, LOW);
}

void loop() {
  /*
     De funcDebounce onderdrukt eventuele stoorpulsjes en
     geeft een puls terug, ook als de ingang getriggerd blijft.
     Hoe groter deBounceDelay, des te meer korte pulsjes worden
     onderdrukt.
  */
  ledState =  funcDebounce (digitalRead(inPin), debounceDelay);
  /*
    Geef de puls van funcDebounce door aan funcTimer
    na de variabel tijd blijft ignoreTime HOOG
  */
  ignoreTime = funcTimer (ledState, alertState);
  /*
     Maak hier een puls van een continue signaal
  */
  pulsState = funcPuls(ignoreTime);
  /*
     Na afloop van de funcPuls,
     start een alarmtijd fase
  */
  alertState = funcAlertTimer (pulsState);
  /*
     Tijdens de Alarm fase, kijken of er terug een ingangssignaal is.
     Er kan ook nog een counter gebruikt worden om pas na n-aantal pulsen
     een alarmRelais te triggeren.
  */
  if (alertState == HIGH) {
    if (ledState == HIGH) { //Hier kunnen meerdere voorwaarden, b.v. een counter
      digitalWrite(relaisPin, HIGH);
    }
  }

  //*** Reset een paar variabelen
  digitalWrite(optoLedPin, ledState);//update the LED
  if (ledState == HIGH) {//If the input stays triggered Reset the function
    delay(500);
    ledState = LOW;
  }
  if (pulsState == HIGH) {//If the input stays triggered Reset the function
    delay(500);
    pulsState = LOW;
  }
  if (digitalRead(resetPin) == LOW) {// RESET de AlarmRelais
    digitalWrite(relaisPin, LOW);
  }
}//**** End of void Loop()

//**** Functions ****
/*
   FUNCTION funcDebounce
   Leest een ingangs signaal (byte) en
   geeft een antidender signaal terug (byte)
   De ingangspuls moet minimum 100 msec duren
*/
byte funcDebounce (byte myInput, unsigned long debounceDelay) {
  static unsigned long lastDebounceTime;
  static byte inState;
  static byte lastInState;
  if (myInput != lastInState) {
    lastDebounceTime = millis();//reset the debouncing timer
  }
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (myInput != inState) {
      inState = myInput;
      if (inState == LOW) {//only toggle the LED if the new opto state is LOW
        ledState = HIGH;
        firstBoot = HIGH;//We are in the running
      }
    }
  }
  lastInState = myInput;
  return ledState;
}
//****************************
/*
   FUNCTION funcTimer
   Geeft een continue uitgangssignaal
   na een variabel tijdsvertraging
   op de dalende flank van het ingangssignaal
*/
byte funcTimer (byte ingang, byte alarmState) {
  unsigned long currentMillis = millis();
  static unsigned long previousMillis;
  static bool enableTimer;
  int varTime = map(analogRead(POTpin), 0, 1023, 1000, 5000);//Read potmeter
  if (ingang == LOW && firstBoot == HIGH) {//input should be INPUT_PULLUP
    if (!enableTimer) {
      previousMillis = currentMillis;//remember the time
      enableTimer = true;            //enable the timer
      ignoreTime = HIGH;
      digitalWrite( ignoreLedPin, HIGH);
    }
  }
  if (enableTimer) {//is the timer running ?
    if (currentMillis - previousMillis >= varTime) {
      if (enableTimer && ingang) {
        enableTimer = false;//turns itself off , to run only once
      }
      digitalWrite( ignoreLedPin, LOW);
      ignoreTime = LOW;
    }
  }
  return ignoreTime;
}
//*********************************
/*
   FUNCTION funcPuls
   Leest een ingangs signaal (byte) en
   geeft een puls signaal terug (byte)
   De ingangspuls moet minimum 10 msec duren
*/
byte funcPuls (byte myInput) {
  static unsigned long lastDebounceTime;
  static byte inState;
  static byte lastInState;
  if (myInput != lastInState) {
    lastDebounceTime = millis();//reset the debouncing timer
  }
  if ((millis() - lastDebounceTime) > 10) {
    if (myInput != inState) {
      inState = myInput;
      if (inState == LOW) {//only toggle the LED if the new opto state is LOW
        pulsState = HIGH;
      }
    }
  }
  lastInState = myInput;
  return pulsState;
}
//************************************
/*
  FUNCTION alertTimer
  Geeft een puls na variabel vertraging

*/
byte funcAlertTimer (byte ingang) {
  unsigned long currentMillis = millis();
  static unsigned long previousMillis;
  static bool enableTimer;
  //*** Hier veranderen naar POTpin, was enkel als test, minder draden ***
  int varTime = map(analogRead(POTpin), 0, 1023, 1000, 5000);//Read A1 potmeter
  if (ingang ==  HIGH) {
    if (!enableTimer) {
      previousMillis = currentMillis;//remember the time
      enableTimer = true;            //enable the timer
      alertState = HIGH;
      digitalWrite( alertLedPin, HIGH);
    }
  }
  if (enableTimer) {//is the timer running ?
    if (currentMillis - previousMillis >= varTime) {
      if (enableTimer) {
        enableTimer = false;//turns itself off , to run only once
      }
      digitalWrite( alertLedPin, LOW);
      alertState = LOW;
    }
  }
  return alertState;
}

Gebruikers-avatar
Berichten: 11
Geregistreerd: 23 Mrt 2022, 17:40

Re: puls negeren voor bepaalde tijd

Berichtdoor AutonomY » 08 Apr 2022, 10:42

Bedankt voor je digitale ambacht,...
Het is zowat een boek in vergelijking met het programma van Frits :-)
Zodra ik m'n 2de UNO binnen heb zal ik deze ook inladen en gaan leren begrijpen.
Die potmeters is ook een geestige vinding.

Berichten: 180
Geregistreerd: 26 Aug 2015, 11:57

Re: puls negeren voor bepaalde tijd

Berichtdoor Frits1956 » 12 Apr 2022, 23:22

Inmiddels al duidelijkheid of een van de voorgestelde programma's aan de wensen voldoet?

Gebruikers-avatar
Berichten: 11
Geregistreerd: 23 Mrt 2022, 17:40

Re: puls negeren voor bepaalde tijd

Berichtdoor AutonomY » 13 Apr 2022, 23:45

Oh nee Frits,... ik heb niet de tijd gehad om er verder aan te werken. We hebben een volle dag met het mannetje. Ook zit ik nog op onderdelen te wachten om het af te ronden. Ik laat zeker wat horen als het zover is. Het is spannend of onrustig te noemen om geen alarm te hebben. Het 'ding' moet er komen. Wat ik net ontdekt heb is dat het LED'je van de babyphone wellicht te laat oplicht. Ik zal dan het geluid moeten 'aftappen'. Daar zal ik dan een transistor schakeling voor moeten gebruiken naar de Arduino?

Gebruikers-avatar
Berichten: 11
Geregistreerd: 23 Mrt 2022, 17:40

Re: puls negeren voor bepaalde tijd

Berichtdoor AutonomY » 29 Apr 2022, 17:01

Hoi Gij,
ik ben er aan toe om jouw lijst te gaan testen. Welke potmeterswaarden moet ik nemen?

[quote="Gij Kieken"]De code is zeker nog niet afgewerkt, maar het is misschien een begin.
Die variabel vertraging zou ik ook nog in een functie plaatsen om de loop overzichtelijker te maken.
Dan nog iets triggeren om op een andere uitgang een relais te laten blinken of zo.
Ook nog Reset knop voorzien als er een alarm melding doorkomt.

VorigeVolgende

Terug naar Arduino IDE

Wie is er online?

Gebruikers in dit forum: Bing [Bot] en 6 gasten