Probleem met delay

[bertjenl Profiel Privébericht]

Mogelijk is dat probleem opgelost. de sketch wordt nu wel gecompileerd


const int knop = 2;
const int pin = 13;
const int sensor = 5;
const int pinMo = 11;
const int relais = 12;

int knopState = 0;
int sensorState = 0;
int relaisState = HIGH;

unsigned long previousMillis = 0;

const long interval = 1800000;


void setup() {

pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
pinMode(2, INPUT_PULLUP);
pinMode(5, INPUT);
}


void loop() {
digitalWrite(12, LOW); // relais aan
delay(15000); // 15 sec draaien
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
previousMillis = currentMillis;
if (relaisState == LOW) {
relaisState = HIGH;
} else {
relaisState= LOW;
}


digitalWrite(relais, relais);

knopState = digitalRead(knop);


if (knopState == LOW) {
// turn 13 of:
digitalWrite(13, LOW);
} else {
// turn 13 on:
digitalWrite(13, HIGH);

}
// read the state of of the sensor value:
sensorState = digitalRead(sensor);

//check if the sensor is pressed
//if it is the sensorState is LOW:
if (sensorState == LOW) {
// turn 11 of:
digitalWrite(11, LOW);
} else {
// turn 11 on:
digitalWrite(11, HIGH);
}
}
}

[bertjenl Profiel Privébericht]

Dit is best wel leuk om te doen

[Koepel Profiel Privébericht]

Je hebt nu delay() en millis() door elkaar, dus niet alle voordelen van een sketch met millis().

Ik ging proberen het om te zetten, maar ik weet niet precies wat je wilt.
De knop zet alleen pin 13 aan of uit ?
De sensor zet alleen de 'Mo' aan of uit ?
En het relais doet maar net waar het zin in heeft ?
Kun je ook beschrijven waar die delays voor waren ? Als het relais aangaat, dan 15 seconden aan. Daarna 30 minuten uit en dan gewoon weer aan of naar een sensor kijken ?

[bertjenl Profiel Privébericht]

Ik ben aan het proberen om een filter op automaat te laten draaien 15 sec aan nergens naar kijken.
30 minuten wachten kijken naar sensor en of drukknop dan weer de cyclus opnieuw. En dan wordt het ook nog de bedoeling dat als de sensor of drukknop wordt geactiveerd dat de trommel 15 sec gaat draaien en onder het draaien nergens naar kijkt. Dus daar leek me daar de delay functie wel mooi voor en voor de 30 minuten wachten de millis.

[shooter Profiel Privébericht]

een digitaal signaal is dus een boolean, die kan true,false, 0,1 HIGH,LOW zijn.
ofwel een int kan niet HIGH zijn, wel 1 (dat is ook HIGH.
verder gebruik je relais 2 keer als pinnummer en als state dat gaat ook niet.
digitalWrite (relais,HIGH) bijv is wel goed.

en nu moet je echt een stukje lezen over timers, anders kom je er niet uit.
(en ja ik weet hoe het moet, maar jij wilt het leren)

[Koepel Profiel Privébericht]

Het gebruik van millis() is even wennen hoor.

Bij gebruik van millis() zonder delay, kun je dingen blijven toevoegen, die los staan van de andere.
Ook wordt het eenvoudig om een state-machine te maken. Dat is een sketch die wordt gestuurd door een variabele (die heet vaak 'state'), en die wordt gewijzigd om naar het volgende onderdeel te gaan.

De millis() geeft de tijd in milli-seconden aan. Als je millis() opvraagt, dan heb je de tijd van dat moment, ik noem dat een "timestamp". Een stempel met de tijd.
Door alles met "unsigned long" te berekenen, en er voor op te passen dat de berekende waarde niet negatief wordt, dan blijft alles goed werken, ook met een rollover. Een rollover is wanneer de millis() waarde van 0xFFFFFFFF door rolt naar 0x00000000.

Hieronder staat een voorbeeld sketch.
Ik laat de pomp na 30 minuten weer opnieuw 15 seconden draaien, en de knop en sensor kunnen tijdens die 30 minuten ook de 15 seconden starten. Dat gaat dan meteen in.

cpp code

// ----------------------------------------
// De gebruikte pinnen
// ----------------------------------------
const int knopPin = 2;
const int ledPin = 13;
const int sensorPin = 5;
const int pinMo = 11;
const int relaisPin = 12;


unsigned long previousMillis = 0UL;
const unsigned long interval = 30UL * 60UL * 1000UL;   // 30 minutes (30 * 60 seconden * 1000 milli)
int relaisState;      // globale variabele, onthoud de status van het relais. HIGH is uit, LOW is aan.

unsigned long previousMillisLed = 0UL;
int ledState;

void setup() 
{
  // ----------------------------------------
  // Zet de pinnen
  // ----------------------------------------
  pinMode( ledPin, OUTPUT);
  pinMode( relaisPin, OUTPUT);                 // dit wordt OUTPUT en LOW, is dat de bedoeling ?
  pinMode( pinMo, OUTPUT);
  pinMode( knopPin, INPUT_PULLUP);
  pinMode( sensorPin, INPUT);

  // ----------------------------------------
  // Initialiseer de variabelen
  // ----------------------------------------
  relaisState = LOW;                         // het relais staat aan.
}


void loop() 
{
  // ----------------------------------------
  // Eerste deel van de code in de loop(), haal alle informatie op
  // ----------------------------------------

  // een enkele 'currentMillis' voor de hele code in de loop()
  unsigned long currentMillis = millis();          

  // Lees de knop
  int knopState = digitalRead(knopPin);

  // check if the sensor is pressed
  int sensorState = digitalRead(sensorPin);


  
  // ----------------------------------------
  // Tweede deel van de code in de loop(), verwerk de informatie
  // ----------------------------------------

  if( relaisState == LOW)
  {
    // Het relais is aan, kijk of er 15 seconden verstreken zijn.
    if( currentMillis - previousMillis >= 15000UL)        // 'UL' is 'unsigned long'
    {
      previousMillis = currentMillis;        // onthoudt deze tijd om hierna de 30 minuten te kunnen gaan doen.
      digitalWrite( relaisPin, HIGH);        // relais uit
      relaisState = HIGH;                    // high is uit;
    }
  }
  else
  {
    // Het relais is uit, kijk of de 30 minuten wachttijd om zijn, of dat de knop of de sensor aktief wordt.
    if( currentMillis - previousMillis >= interval || knopState == LOW || sensorState == LOW)
    {
      previousMillis = currentMillis;       // onthoudt deze tijd om hierna de 15 seconden te kunnen doen.
      digitalWrite( relaisPin, LOW);        // relais aan
      relaisState = LOW;
    }
  }
  

  // ----------------------------------------
  // Grapje toevoegen, een led laten knipperen.
  // Op deze manier kun je nog veel meer toevoegen.
  // ----------------------------------------
  
  if( currentMillis - previousMillisLed >= 500UL) 
  {
    previousMillisLed = currentMillis;
    
    if( ledState == LOW)
    {
      digitalWrite( ledPin, HIGH);
      ledState = HIGH;
    }
    else
    {
      digitalWrite( ledPin, LOW);
      ledState = LOW;
    }
  }
}

Kun je deze voorbeeld code vergelijken met wat je zelf hebt, en dan zelf een manier vinden die bij je past ?

Ik heb consequenter gebruik van spaties and haakjes. Meer commentaar. De nummer van een pin heeft 'Pin' in de naam. De loop() is gesplitst in twee afzonderlijk stukken (verzamel alle informatie, en verwerk de informatie). De 30 minuten is geen magisch getal meer, maar ik schrijft dat uit en laat de compiler de waarde berekenen.
Haal er maar uit wat je een goed idee vind. Het belangrijkste dat jij begrijpt wat je eigen sketch doet, zodat je het kunt wijzigen en uitbreiden.

[bertjenl Profiel Privébericht]

Koepel bedankt dit is even iets anders dan ik heb. Maar een paar vraagjes (stuk of ..........) de tijd 30*60*1000UL als ik het goed begrijp is dit de tijd in millis maar ik zie ook OUL staan dit is ..

[bertjenl Profiel Privébericht]

Ik heb de sketch geüpload in een sim maar krijg een foutmelding die ik niet terug kan vinden
PARSE ERROR:0UL badly formed numeric constant
En heren ik ben pas 4 dagen(niet fulltime) bezig met arduino dus vergeef mijn onkunde een beetje

[Koepel Profiel Privébericht]

Simulaties werken niet...
Bij forum.arduino.cc zijn alleen maar problemen met simulaties. Ik heb nog niemand gehoord die aangaf dat het goed werkte. Die simulatie-programma's kunnen een OpAmp simuleren, en dat was het zo'n beetje.

Een "unsigned long" voor een Arduino Uno or Nano is 32 bits.
Ik doe het zo:
unsigned long x = 123UL;
De 'UL' achter het getal geeft voor de compiler aan dat de '123' als een unsigned long opgevat moet worden.
Dat doe ik vooral voor mezelf, zodat ik kan zien waar ik mee bezig ben

Een normale integer kan tot zo'n 32767, dus als je 100000 wilt gebruiken, dan moet er toch al een 'L' of 'UL' achter. De compiler gebruikt standaard 16 bits integer, en raakt al snel de kluts kwijt als je 100000 gebruikt. Met 100000L or 100000UL snapt de compiler het wel.

Een 0UL (nul, 'U', 'L') is normaal in 'c'. Wat raar dat de simulator daar over struikelt. Vul gewoon een nul in. Of heb je een 'O' gebruikt, in plaats van een nul ?

Wat vind je van de opbouw van mijn voorbeeld ? Lijkt het je logisch ?

[bertjenl Profiel Privébericht]

Kijk daarom zit ik nu op een forum, tips, opbouwende kritiek, voorbeelden hoe het zou kunnen, hulp met ervaringen van anderen en mensen die ook meer ervaring hebben met bv sim
Koepel hartelijk bedankt voor de hulp hier kan ik verder mee stoeien.
zonder het voorbeeld was ik maanden verder geweest denk ik. De arduino is besteld en verwacht dat deze maandag binnen zal komen. Zodoende dacht ik het te proberen met een sim programma als deze binnen is zal ik het programma in de arduino laden en kijken wat deze doet. Als ik het programma goed snap of begin te snappen zal deze ook pin 13 aansturen (Led ) dit is denkelijk de grap. Zal deze met wat gestoei veranderen in een externe LED. mooi signaal dat het werkt
ga in de sim eerst kijken of ik het in dit prgramma werkend kan krijgen
P.S.
ik vind het nog steeds leuk