Onthouden van random nummers en deze vergelijken

janzzen · September 8, 2022, 2:44pm

Hallo Arduino profs,

Ik begin de aanhef maar zo, aangezien ik al twee dagen (!!) bezig ben met het aanpassen van een code en dat lukt me niet. Ik ben absoluut geen prof en met de vele voorbeelden op websites en youtube, kom ik er helemaal niet meer uit. Onderstaande code zal voor menig Arduino-ist rommelig overkomen, maar het werkt, althans, ten delen.

Wat er nu gebeurt en wat er moet gebeuren...
Als butPin1 en butPin2 worden geschakeld, gaat er een trein vertrekken. Via een random nummer wordt er één van de 11 sporen gekozen en vrijgegeven. Na 20 seconde worden de wissels geschakeld naar het spoor waar de trein is vertrokken. De trein doet een rondje over de modelspoorbaan, komt terug het station in en activeert een volgende trein, ook weer met een random nummer via randomSeed.

Wat er NU gebeurt is dat een trein best nóg een keer geselecteerd kan worden uit die 11 random nummers. Gevolg is dat dezelfde trein nóg een keer een ronde maakt.

Wat er eigenlijk móet gebeuren is dat de voorgaande 4 random-nummers (treinen), worden onthouden zodat deze niet achter elkaar gaan rijden. Er blijven dan nog 7 random nummers over.

Hoe die ik dit nu? Ik heb via-via en via internet een code in elkaar gezet, dat werkt, ik krijg alleen die vergelijkingen niet gedaan en de sketch onthoud ook niks. Ik heb gekeken naar een array, maar dat gaat mijn programmeerkennis helemáál te boven, ik snap er werkelijk geen hout van. Ik had gehoopt met INT wat waardes te kunnen wijzigen IN de loop, maar blijkbaar kan dit niet, werkt dit niet of wellicht is het uitgesloten dat dat kan.

Nou, met angst en beven, dé code...

#define AAN LOW             // Definities omkeren, AAN is LOW
#define UIT HIGH            // Definities omkeren, UIT is HIGH
#define ON true             // Definities, ON is True
#define OFF false           // Definities, OFF is False

#include <LiquidCrystal_I2C.h>    //Library voor LCD-display

LiquidCrystal_I2C lcd(0x27, 20, 4);   //Display-grootte opgeven met 0x27 als standaard adres

#include <EEPROM.h>               //Library voor RandomSeed

const uint8_t butPin1 = 2;     //Rijsensor M-rails vóór inrit van het schaduwstation
const uint8_t butPin2 = 4;     //Rijsensor M-rails vóór inrit van het schaduwstation

uint8_t butState1 = AAN;       //Status rijcontact 1
uint8_t butState2 = AAN;       //Status rijcontact 2
uint8_t traceFlag = OFF;       //Traceflag standaard uit


const uint8_t seed_addr = 0;
unsigned long seed;


int randNum = 0;
int randNumOld = 0;
int randNumOld2 = 0;
int randNumOld3 = 0;


void setup() {

    lcd.init();
    lcd.backlight();

      lcd.setCursor(1, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 1.
      lcd.print("* Schaduwstation *");    // Print deze tekst
      lcd.setCursor(1, 1);                // Plaats de cursor op de tweede lijn en op positie 1.
      lcd.print("by Roland");    // Print deze tekst
      lcd.setCursor(1, 3);                // Plaats de cursor op de vierde lijn en op positie 1.
      lcd.print("v3.6 - 08-09-2022");    // Print deze tekst vóórdat er een trein vertrekt
      
  
    pinMode(butPin1, INPUT_PULLUP);
    pinMode(butPin2, INPUT_PULLUP);

  for ( uint8_t thisPin = 22; thisPin < 54; thisPin++) {  //Selectie van pinnen voor output (LET OP: één meer dan er fysieke pinnen zijn!)
    digitalWrite(thisPin, UIT);                           //Pinnen (relais) moeten UIT blijven/staan
    pinMode(thisPin, OUTPUT);                             //Alle geselecteerde pinnen dienen als output
  }

    seed = EEPROM.read(seed_addr);
    EEPROM.write(seed_addr, seed+1);
    randomSeed(seed);
  
}

void loop() {
butState1 = digitalRead(butPin1);
butState2 = digitalRead(butPin2);

int randNumOld2 = randNumOld3;
int randNumOld1 = randNumOld2;
int randNumOld = randNumOld1;
int randNum = randNumOld;


    if ((butState1 == AAN && butState2 == AAN) && (traceFlag == OFF)) {
    
    //HIERONDER: Random output van 42 TOT MAXIMAAL 53.  LET OP...!!! Eén nummer HOGER dan aantal actieve sporen!!!
    //ATTENTIE! Bij gebruik van minder dan 11 sporen, het laatste getal wijzigen!
    //Dus, 7 sporen in gebruik, dan 42 t/m 49 invullen, bij 9 sporen is het 42 t/m 51.
    //Bij 3 sporen wordt het dus 42 t/m 45.


    
    randNum = random(42, 53);     //Selecteer een willekeurig nummer tussen deze twee



    if ((randNum == randNumOld) or (randNum == randNumOld1) or (randNum == randNumOld2) or (randNum == randNumOld3)) {
      randNum = random(42, 53);
    } // 1

    if ((randNum == randNumOld) or (randNum == randNumOld1) or (randNum == randNumOld2) or (randNum == randNumOld3)) {
      randNum = random(42, 53);
    } // 2

    if ((randNum == randNumOld) or (randNum == randNumOld1) or (randNum == randNumOld2) or (randNum == randNumOld3)) {
      randNum = random(42, 53);
    } // 3

    if ((randNum == randNumOld) or (randNum == randNumOld1) or (randNum == randNumOld2) or (randNum == randNumOld3)) {
      randNum = random(42, 53);
    } // 4

    if ((randNum == randNumOld) or (randNum == randNumOld1) or (randNum == randNumOld2) or (randNum == randNumOld3)) {
      randNum = random(42, 53);
    } // 5

 
    
    digitalWrite(randNum, AAN);   //Willekeurig relais aan
    traceFlag = ON;               //TraceFlag aan


    //Hier onder is 20 seconde wachttijd ingebouwd.
    //Het display telt af van 20 naar 0, dus elke seconde een bericht naar LCD-display.

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd: 20 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd: 19 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd: 18 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd: 17 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd: 16 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd: 15 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd: 14 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd: 13 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd: 12 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd: 11 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd: 10 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd:  9 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd:  8 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd:  7 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd:  6 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd:  5 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd:  4 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd:  3 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd:  2 sec.");
      delay(1000);

      lcd.clear();
      lcd.setCursor(0, 0);                // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");        // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd:  1 sec.");
      delay(1000);


      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Trein vertrokken.");
      lcd.setCursor(0, 1);
      lcd.print("Geen actie meer.");
      lcd.setCursor(0, 3);
      lcd.print("Wissels schakelen...");


    digitalWrite(randNum, UIT);   //Willekeurig relais weer uit
    delay(1500);

      

      if (randNum == 42){         //ALS willekeurig nummer 42 is...dan...
    delay(50);                    //Delay vóóraf, (test of nu alle relais worden meegenomen)
    digitalWrite(23, AAN);        //Spanning wissel x inschakelen
    delay(150);                   //Tijd dat de wissels bekrachtigd worden (ca. 150ms is genoeg)
    digitalWrite(23, UIT);        //Spanning wissel x uitschakelen
    delay(50);
    digitalWrite(24, AAN);
    delay(150);
    digitalWrite(24, UIT);
    delay(50);
    digitalWrite(27, AAN);
    delay(150);
    digitalWrite(27, UIT);
    delay(50);
    digitalWrite(28, AAN);
    delay(150);
    digitalWrite(28, UIT);
    delay(50);
    digitalWrite(30, AAN);
    delay(150);
    digitalWrite(30, UIT);
    delay(50);
    digitalWrite(32, AAN);
    delay(150);
    digitalWrite(32, UIT);
    

//    lcd.clear();
//    lcd.setCursor(0, 1);
//    lcd.print("WISSELS GESCHAKELD");
//    delay(1000);

      }
 
    else if (randNum == 43){
    delay(50);
    digitalWrite(23, AAN);
    delay(150);
    digitalWrite(23, UIT);
    delay(50);
    digitalWrite(24, AAN);
    delay(150);
    digitalWrite(24, UIT);
    delay(50);
    digitalWrite(27, AAN);
    delay(150);
    digitalWrite(27, UIT);
    delay(50);
    digitalWrite(28, AAN);
    delay(150);
    digitalWrite(28, UIT);
    delay(50);
    digitalWrite(30, AAN);
    delay(150);
    digitalWrite(30, UIT);
    delay(50);
    digitalWrite(33, AAN);
    delay(150);
    digitalWrite(33, UIT);


//    lcd.clear();
//    lcd.setCursor(0, 1);
//    lcd.print("WISSELS GESCHAKELD");
//    delay(1000);

  }
  
    else if (randNum == 44){
    delay(50);
    digitalWrite(23, AAN);
    delay(150);
    digitalWrite(23, UIT);
    delay(50);
    digitalWrite(24, AAN);
    delay(150);
    digitalWrite(24, UIT);
    delay(50);
    digitalWrite(27, AAN);
    delay(150);
    digitalWrite(27, UIT);
    delay(50);
    digitalWrite(28, AAN);
    delay(150);
    digitalWrite(28, UIT);
    delay(50);
    digitalWrite(31, AAN);
    delay(150);
    digitalWrite(31, UIT);
    delay(50);
    digitalWrite(34, AAN);
    delay(150);
    digitalWrite(34, UIT);


//    lcd.clear();
//    lcd.setCursor(0, 1);
//    lcd.print("WISSELS GESCHAKELD");
//    delay(1000);
    
  }
    else if (randNum == 45){
    delay(50);
    digitalWrite(23, AAN);
    delay(150);
    digitalWrite(23, UIT);
    delay(50);
    digitalWrite(24, AAN);
    delay(150);
    digitalWrite(24, UIT);
    delay(50);
    digitalWrite(27, AAN);
    delay(150);
    digitalWrite(27, UIT);
    delay(50);
    digitalWrite(28, AAN);
    delay(150);
    digitalWrite(28, UIT);
    delay(50);
    digitalWrite(31, AAN);
    delay(150);
    digitalWrite(31, UIT);
    delay(50);
    digitalWrite(35, AAN);
    delay(150);
    digitalWrite(35, UIT);

//    lcd.clear();
//    lcd.setCursor(0, 1);
//    lcd.print("WISSELS GESCHAKELD");
//    delay(1000);
    
  }
    else if (randNum == 46){
    delay(50);
    digitalWrite(23, AAN);
    delay(150);
    digitalWrite(23, UIT);
    delay(50);
    digitalWrite(24, AAN);
    delay(150);
    digitalWrite(24, UIT);
    delay(50);
    digitalWrite(27, AAN);
    delay(150);
    digitalWrite(27, UIT);
    delay(50);
    digitalWrite(29, AAN);
    delay(150);
    digitalWrite(29, UIT);

//    lcd.clear();
//    lcd.setCursor(0, 1);
//    lcd.print("WISSELS GESCHAKELD");
//    delay(1000);

  }
    else if (randNum == 47){
    delay(50);
    digitalWrite(23, AAN);
    delay(150);
    digitalWrite(23, UIT);
    delay(50);
    digitalWrite(24, AAN);
    delay(150);
    digitalWrite(24, UIT);
    delay(50);
    digitalWrite(26, AAN);
    delay(150);
    digitalWrite(26, UIT);
    delay(50);
    digitalWrite(36, AAN);
    delay(150);
    digitalWrite(36, UIT);


//    lcd.clear();
//    lcd.setCursor(0, 1);
//    lcd.print("WISSELS GESCHAKELD");
//    delay(1000);
    
  }
    else if (randNum == 48){
    delay(50);
    digitalWrite(23, AAN);
    delay(150);
    digitalWrite(23, UIT);
    delay(50);
    digitalWrite(24, AAN);
    delay(150);
    digitalWrite(24, UIT);
    delay(50);
    digitalWrite(26, AAN);
    delay(150);
    digitalWrite(26, UIT);
    delay(50);
    digitalWrite(37, AAN);
    delay(150);
    digitalWrite(37, UIT);

//    lcd.clear();
//    lcd.setCursor(0, 1);
//    lcd.print("WISSELS GESCHAKELD");
//    delay(1000);
    
  }
    else if (randNum == 49){
    delay(50);
    digitalWrite(23, AAN);
    delay(150);
    digitalWrite(23, UIT);
    delay(50);
    digitalWrite(25, AAN);
    delay(150);
    digitalWrite(25, UIT);
    delay(50);
    digitalWrite(41, AAN);
    delay(150);
    digitalWrite(41, UIT);
    delay(50);
    digitalWrite(38, AAN);
    delay(150);
    digitalWrite(38, UIT);

//    lcd.clear();
//    lcd.setCursor(0, 1);
//    lcd.print("WISSELS GESCHAKELD");
//    delay(1000);

  }
    else if (randNum == 50){
    delay(50);
    digitalWrite(23, AAN);
    delay(150);
    digitalWrite(23, UIT);
    delay(50);
    digitalWrite(25, AAN);
    delay(150);
    digitalWrite(25, UIT);
    delay(50);
    digitalWrite(41, AAN);
    delay(150);
    digitalWrite(41, UIT);
    delay(50);
    digitalWrite(39, AAN);
    delay(150);
    digitalWrite(39, UIT);

//    lcd.clear();
//    lcd.setCursor(0, 1);
//    lcd.print("WISSELS GESCHAKELD");
//    delay(1000);

  }
    else if (randNum == 51){
    delay(50);
    digitalWrite(23, AAN);
    delay(150);
    digitalWrite(23, UIT);
    delay(50);
    digitalWrite(25, AAN);
    delay(150);
    digitalWrite(25, UIT);
    delay(50);
    digitalWrite(40, AAN);
    delay(150);
    digitalWrite(40, UIT);

//    lcd.clear();
//    lcd.setCursor(0, 1);
//    lcd.print("WISSELS GESCHAKELD");
//    delay(1000);

  }
  
    else if (randNum == 52){
    delay(50);
    digitalWrite(22, AAN);
    delay(150);
    digitalWrite(22, UIT);

//    lcd.clear();
//    lcd.setCursor(0, 1);
//    lcd.print("WISSELS GESCHAKELD");
//    delay(1000);

  }
  }
 
  //Reset het boeltje
  if (traceFlag == ON) {
      digitalWrite(randNum, UIT);
      traceFlag = OFF;


    lcd.clear();
    lcd.setCursor(1, 0);
    lcd.print("* Schaduwstation *");
    lcd.setCursor(1, 1);                // Plaats de cursor op de tweede lijn en op positie 1.
    lcd.print("by Roland");    // Print deze tekst
    lcd.setCursor(0, 3);                // Plaats de cursor op de vierde lijn en op positie 0.
    lcd.print("Wacht op trein...");     // Print deze tekst

  }
  
}

Zou iemand mij kunnen helpen met het onthouden van de laatste 4 random nummers? Deze moeten voordat er een NIEUW random-nummer wordt gegenereerd, eerst worden vergeleken met de voorgaande 4 en (indien hetzelfde random nummer wordt getrokken) moet er dan een nieuw random-nummer worden gegenereerd.

Ik hoop dat iemand me op weg kan helpen, ik kan het niet vinden...

hmeijdam · September 8, 2022, 7:44pm

Kijk even naar dit voorbeeld (draai het even op je Arduino).

Ik gebruik een do....while loop waarin ik hem nieuwe random nummers laat uitreiken zolang het nieuwe nummer gelijk is aan een van de oude 4 nummers. Zodra er een random nummer is uitgereikt wat NIET gelijk is aan een van de vorige 4 mag hij doorgaan.

Het || teken is een logische OR (of in het nederlands)

int randNum = 0;
int randNumOld1 = 0;
int randNumOld2 = 0;
int randNumOld3 = 0;
int randNumOld4 = 0;

void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000); 
  
do randNum = random(42, 53);     //Selecteer een willekeurig nummer tussen deze twee
// en blijf dit herhalen zolang er een randNum is gelecteerd dat gelijk is aan randNumOld1 of aan RandNumOld2 of.....
while ((randNum == randNumOld1) || (randNum == randNumOld2) || (randNum == randNumOld3)|| (randNum == randNumOld4));

// Nu hebben we een randNum die niet gelijk is aan een van de vorige 4
// dus even printen
Serial.println(randNum);

// en nu gaan we de historie van randNum een plekje opschuiven. De niewe wordt randnumOld1 en nummer 4 knikkert er uit.
  randNumOld4 = randNumOld3;
  randNumOld3 = randNumOld2;
  randNumOld2 = randNumOld1;
  randNumOld1 = randNum;
  
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

Trouwens. Nette openingspost heb je gemaakt. Heldere vraagstelling, context gegeven over je spoorbaan en de hele code in code tags. Dat zien we zat slechter.

[edit] in de haast nog even een fout gemaakt maar nu verbeterd. Je moet het opschuiven van de oude nummers wel in de volgorde 4,3,2,1 doen en niet 1,2,3,4

janzzen · September 9, 2022, 8:38am

Wauw, hoe simpel kan het zijn... do en while...

Eerst even reageren op de laatste alinea's, dank voor de complimenten, vaak is het zo dat als ik iets in m'n hoofd heb, het maar moeilijk op papier komt, da's dus nu wel gelukt, haha!

Wat betreft de code... ik snap wat'ie doet... maar...
Ik heb vanmorgen gelijk getest of het werkt, maar helaas...

Het gaat denk ik mis met de omzetting van de bufferzone, dus van randNumOld2 naar randNumOld1. Ik had trouwens al de boel omgedraaid, dus Old3 wordt Old4, Old2 wordt Old3 enz. Ik heb die bufferzone verplaatst, naar boven, voordat het if-statement begint, met butPin1 en butPin2. Dan gaan langzaamaan ALLE relais aan en ALLE treinen rijden en wordt het een enorme puinzooi. Gelukkig heb ik dat op tijd gezien, er was wel een kop-staart aanrijding

Bij het verplaatsen van die bufferzone onder het moment dat er random een relais wordt geschakeld, geeft geen resultaat. Dan wordt blijkbaar de hele buffer overgeslagen.

De buffer verplaatsen naar één van de laatste regels, nadat traceFlag uit wordt gezet, heeft ook geen resultaat, dezelfde trein komt dan alsnog doorrijden.

En ja, om de schakeling optimaal te laten werken, moeten er éérst 4 treinen hebben gereden, pas daarna zijn alle nullen vervangen door echte gebruikte waardes.

Helaas, het werkt nog niet helemaal. Wel enorm bedankt voor je tijd alvast, ik ga vandaag proberen hier verder mee te gaan, het moet niet moeilijk zijn en het gebruik van arrays vind ik erg moeilijk en volgens mij is dat ook helemaal niet nodig met dit betrekkelijk makkelijke vraagstuk...

hmeijdam · September 9, 2022, 8:59am

Had je deze wel zo gemaakt?

Bij jou had je het precies verkeerdom. Je ging het aangemaakte randNum overschrijven met randnumOld.

Let op dat als je

a = b;

doet, dat dan de waarde van a gelijk gemaakt wordt aan b. niet andersom

Als dat het niet is, weer even je hele code posten, inclusief de overgenomen do....while

janzzen · September 9, 2022, 9:10am

TUURLIJK! Ja, nu zie ik het...!!!

Ik start nu Arduino op, ga het veranderen en gelijk testen!
Ik reply binnen een half uurtje weer

janzzen · September 9, 2022, 10:12am

Omdat beelden nou eenmaal meer zeggen...
Volgens mij werkt het eindelijk !!!

sterretje · September 9, 2022, 11:32am

Leuk.

Ik heb niet echt naar je originele programma gekeken.

Ik heb vanmorgen wat tijd besteed aan een andere oplossing. Als je variabelen begint te nummeren moet je eigenlijk direct aan arrays gaan denken. De onderstaande code is complexer maar ook meer flexibel; als je ooit een ander schaduw station begint met een ander aantal sporen of je wilt de laatste 4 veranderen naar de laatste 5 is het eenvoudiger aan te passen.

// macro to calculate number of elements in array of any type
#define NUMELEMENTS(x) (sizeof(x) / sizeof(x[0]))

const uint8_t maxRandomRemembered = 4;
const uint8_t maxTracks = 11;

void setup() {
  Serial.begin(115200);
}

void loop() {

  Serial.println(F("===="));
  int x = getRandom();

  if (x == -1) {
    Serial.println(F("Stuck"));
    for (;;)
      ;
  } else {
    Serial.print(F("New number = "));
    Serial.println(x);
  }

  delay(2000);
}

/*
  get a unique number that wasn't use the last maxRandomRemembered times
  Returns:
    -1 if code is buggy, else new random number starting from 1
*/
int getRandom() {
  static int lastFour[maxRandomRemembered];

  int rn;
  bool used = true;

  // endless loop till we find a number that was not in use
  while (used == true) {
    // assume number that we generate was not in use
    used = false;
    // generate new number
    rn = random(1, maxTracks + 1);

    Serial.print(F("Generated number = "));
    Serial.println(rn);

    // check if number already used
    for (uint8_t cnt = 0; cnt < NUMELEMENTS(lastFour); cnt++) {
      if (lastFour[cnt] == rn) {
        Serial.println(F("In use"));
        used = true;
        break;
      }
    }

    // if the new number was not used the last four times
    if (used == false) {

      // find first zero and replace with random number
      for (uint8_t cnt = 0; cnt < NUMELEMENTS(lastFour); cnt++) {
        if (lastFour[cnt] == 0) {
          Serial.print(F("Replacing "));
          Serial.println(cnt);
          lastFour[cnt] = rn;
          printUsedNumbers(lastFour, NUMELEMENTS(lastFour));
          return rn;
        }
      }

      // if we get here, we did not find an empty place
      Serial.println(F("Creating free space"));
      // shift the last three elements one position so the last element can be overwritten
      memmove(lastFour, &lastFour[1], (NUMELEMENTS(lastFour) - 1) * sizeof(int));
      lastFour[3] = rn;

      printUsedNumbers(lastFour, NUMELEMENTS(lastFour));
      return rn;
    }
  }

  // we should never get here unless there's a bug
  return -1;
}

/*
  print the last used random numbers
  In:
    pointer to array with numbers
    number of elements in the array
*/
void printUsedNumbers(int *ptr, uint8_t numElements) {
  for (uint8_t cnt = 0; cnt < numElements; cnt++) {
    Serial.print(ptr[cnt]);
    Serial.print(F(","));
  }
  Serial.println();
}

Als je ervoor voelt zou ik zeggen "speel er eens mee". Voorbeeld in serial monitor

====
Generated number = 8
Creating free space
10,5,7,8,
New number = 8
====
Generated number = 2
Creating free space
5,7,8,2,
New number = 2
====
Generated number = 2
In use
Generated number = 5
In use
Generated number = 10
Creating free space
7,8,2,10,
New number = 10
====
Generated number = 2
In use
Generated number = 6
Creating free space
8,2,10,6,
New number = 6

hmeijdam · September 9, 2022, 5:34pm

Erg leuk om te zien. Wat een nostalgie. Een Marklin H0 baan meen ik te zien. met die ijzeren railsstukken. Had ik als kind ook. Ik zag op het filmpje volgens mij nog een Krokodil rijden.

Zitten daar nog steeds wisselstroommotoren in en werken die wissels nog met een korte stroompuls om ze om te schakelen? Ik kan wel zeggen dat dat Marklin spul me destijds heeft gedwongen om verstand te gaan krijgen van electriciteit en electronica.

Ik ben het met @sterretje eens, dat je programma nog veel compacter en efficienter kan, maar heb geprobeerd je een oplossing aan te reiken, die niet een grote stap in je denken vergt. Zodat je het zelf in kon bouwen en meteen kunt onderhouden, omdat je snapt wat er gebeurt.

Daarna is het veilig om te gaan spelen met de oplossing van sterretje, want je weet dan dat je altijd kunt terugvallen op je eigen code, mocht het een te steile leercurve zijn om met arrays en aparte aangeroepen functies te gaan werken.

janzzen · September 9, 2022, 6:05pm

Ja, correct, een originele M-Rail baan Metalen rails dus, je hebt ze ook met kunststof dwarsliggers en tegenwoordig ook C-rails, beetje gelijk aan de M-rail maar dan met grijze bedding. De motoren zijn inderdaad veelal wisselstroom, alhoewel ik een aantal locomotieven heb omgebouwd naar digitaal, dus met een decoder erin die aan de ene kant gevoed wordt met wisselstroom en met gelijkstroom de motor aandrijft. Die kunnen trouwens vaak ook nog gewoon analoog bedient worden. Er is een hoop te krijgen in de handel, analoog, digitaal, maar zoals je ziet aan de schakelaars en bedieningspanelen, ik rij analoog, maar het schaduwstation, da's nu geautomatiseerd. Om dát met de hand te gaan bedienen, wordt een hele uitdaging. De wissels hebben inderdaad een pulsje nodig om te schakelen, in mijn code staat die geloof ik op 150ms, ruimschoots voldoende.

Heb vanmiddag een hele tijd boven gezeten op de barkruk en de schakeling zijn werk laten doen. Heb ruim 120 treinen laten rijden, en inderdaad, random nu, geen enkele van de vier is er doorheen geglipt, na één trein kwamen er sowieso vier anderen, en dat was de bedoeling.

Ik ben pas 1,5 jaar bezig met Arduino en codes, ik kende totaal niks van het ding! Wat ik al eerder schreef, via internet, youtube en wat forums zoals deze, uiteindelijk deze code dus gemaakt en vanmiddag dus omgedoopt tot versie 4.0. YES!

Ik heb destijds veel commentaar gehad op het gebruik van delay ipv millis, maar delay past gewoon beter bij deze schakeling vind ik. Sowieso moet na een vertrekkende trein een wachttijd zitten, omdat de vorige trein éérst het schaduwstation in moet rijden (waar'ie 20sec de tijd voor heeft) en dán pas worden de wissels geschakeld, anders ontspoort de boel, en dat wil je niet in die krappe ruimte eronder.

Ja, ik zou nog wel eens willen weten of die LCD-scherm-code ook korter kan. Nu staan er twintig blokken met in elk blok een genoemde seconde, Wachttijd: 19sec, Wachttijd: 18sec, etc. Maar zo ver was ik nog niet, wellicht kan ik dat zelf ook wel vinden ergens. Dit, met dat randnum onthouden, was echt de hoofdvraag.

Wat er verder nog compacter en efficiënter kan? Ik vermoed de wissel-schakelingen? Dat je die delay's er op de één of andere manier uitfiltert en daar één integer voor aanmaakt en die terug laat komen in je schakeling? Zou natuurlijk wel netter staan. Ja, ik vraag me wel af wat er efficiënter en compacter kan eigenlijk... Suggesties zijn welkom, haha!

Inderdaad, het werken met randNumOld is simpel, ik snap hoe de schakeling werkt en alle lof voor @sterretje, dankjewel voor alle tijd en moeite! Ik ga je code van het weekend eens rustig proberen te ontcijferen. Sterker nog, ik heb nog een Arduino liggen en wat relaiskaarten, dus ik zal het niet laten dat even aan te sluiten en eens te testen. Of nog mooier, ik gooi de code gewoon in de Arduino bij de modelspoorbaan. Het is voor mij écht een hele kluif die code, ik wil graag weten wát het doet en hóe die het doet (iets met autistische aanleg ofzo, hahaha!).

Goed, helaas alweer avond, ik moet zo nog weg en dan wil de vrouw ook nog wat aandacht, dus het is even gebeurt met Arduino's en modelspoor voor vandaag, hi.

Dank nogmaals aan jullie beide!

sterretje · September 10, 2022, 4:50am

Totdat je ook wat anders wilt doen Stel je voor dat je ook het hoofdstation wilt besturen met dezelfde Arduino; je wilt niet 20 seconden wachten voordat je een wissel kunt zetten om een trein binnen te laten komen of te laten vertrekken. Of als je een blok systeem dood dezelfde Arduino wilt besturen; je kunt geen 20 seconden wachten om een trein te laten stoppen voor een rood sein

Als je daar geen behoefte aan hebt kun je inderdaad delay gebruiken.

Mijn oog viel op een stukje van je originele programma waar je het aftellen doet. Er is een vuistregel dat een functie (in jouw geval loop()) op een pagina A4 moet passen als je het uitprint. Ik hoop dat je me wilt vergeven dat ik het aftellen even herschreven heb

Dit is een eerste stap in die richting. Door gebruik te maken van een for-loop kun je dat aftellen behoorlijk inkorten.

void loop()
{
  // eerste gedeelte van je loop() hier
  ...
  ...
    //Hier onder is 20 seconde wachttijd ingebouwd.
    //Het display telt af van 20 naar 0, dus elke seconde een bericht naar LCD-display.

    for (int seconds = 20; seconds > 0; seconds--)
    {
      lcd.clear();
      lcd.setCursor(0, 0);              // Plaats de cursor op de eerste lijn (O) en op positie 0.
      lcd.print("Trein komt binnen!");  // Print deze tekst
      lcd.setCursor(0, 1);
      lcd.print("Trein vertrekt...");
      lcd.setCursor(0, 3);
      lcd.print("Wachttijd: ");
      lcd.print(seconds);
      lcd.print(".");
      delay(1000);
    }

    // hieronder de rest van je loop()
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Trein vertrokken.");
    lcd.setCursor(0, 1);
    lcd.print("Geen actie meer.");
    lcd.setCursor(0, 3);
    lcd.print("Wissels schakelen...");

    ...
   ...
}

Een opmerking aangaande mijn eerdere programma in post #7 voor het willekeurige nummer; het genereert slechts the nummers 1..11. Ik zie nu dat je in je programma ook andere nummers genereert / nodig hebt; daar was geen rekening mee gehouden.

PS:
Ik heb een paar dozen vol met twee-rail gelijkstroom spul van hoofdzakelijk Fleischmann en Roco. Een dag heb ik misschien plek voor een baan zoals die van jou, voor nu blijft dat dromen

sterretje · September 10, 2022, 5:31am

En in de volgende stap kun je het aftellen in een functie gieten die je vanuit loop() aanroept. Ik heb de functie countdown genoemd, je kunt deze ook aftellen noemen.

void countdown()
{
  for (int seconds = 20; seconds > 0; seconds--)
  {
    lcd.clear();
    lcd.setCursor(0, 0);              // Plaats de cursor op de eerste lijn (O) en op positie 0.
    lcd.print("Trein komt binnen!");  // Print deze tekst
    lcd.setCursor(0, 1);
    lcd.print("Trein vertrekt...");
    lcd.setCursor(0, 3);
    lcd.print("Wachttijd: ");
    lcd.print(seconds);
    lcd.print(".");
    delay(1000);
  }
}

En loop() wordt dan

void loop()
{
  // eerste gedeelte van je loop() hier
  ...
  ...
    //Hier onder is 20 seconde wachttijd ingebouwd.
    //Het display telt af van 20 naar 0, dus elke seconde een bericht naar LCD-display.

    countdown();

    // hieronder de rest van je loop()
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Trein vertrokken.");
    lcd.setCursor(0, 1);
    lcd.print("Geen actie meer.");
    lcd.setCursor(0, 3);
    lcd.print("Wissels schakelen...");

    ...
   ...
}

Je kunt ook een functie schrijven die de puls op je wissel spoel zet

/*
  besturing wissel spoel
  In:
    nummer van de pin
*/
void turnoutControl(uint8_t pin)
{
  delay(50);              //Delay vóóraf, (test of nu alle relais worden meegenomen)
  digitalWrite(pin, AAN); //Spanning wissel x inschakelen
  delay(150);             //Tijd dat de wissels bekrachtigd worden (ca. 150ms is genoeg)
  digitalWrite(pin, UIT); //Spanning wissel x uitschakelen
}

En in loop() kun je dan bv dit

    else if (randNum == 51)
    {
      delay(50);
      digitalWrite(23, AAN);
      delay(150);
      digitalWrite(23, UIT);
      delay(50);
      digitalWrite(25, AAN);
      delay(150);
      digitalWrite(25, UIT);
      delay(50);
      digitalWrite(40, AAN);
      delay(150);
      digitalWrite(40, UIT);

      //    lcd.clear();
      //    lcd.setCursor(0, 1);
      //    lcd.print("WISSELS GESCHAKELD");
      //    delay(1000);
    }

vervangen door

    else if (randNum == 51)
    {
      turnoutControl(23);      
      turnoutControl(25);      
      turnoutControl(40);      
      //    lcd.clear();
      //    lcd.setCursor(0, 1);
      //    lcd.print("WISSELS GESCHAKELD");
      //    delay(1000);
    }

janzzen · September 10, 2022, 2:13pm

SOWWWWWWWW!!! Eerst even reageren, dan de code verder inbouwen, haha!

Wat een geweldig duidelijke info/code. Ik had al wel wat gezien en gelezen over functies, maar geen idee hoe ik dit moest toepassen. Met name dat LCD-print verhaal, ja, dat ga je niet redden met één A4 en ik denk ook niet met twee als je die zou uitprinten. Da's de eerste die zo geïmplementeerd gaat worden. Ook de wissel-functie is me geheel duidelijk, dán wordt zo'n code een stuk compacter en efficiënter zoals hmeijdam al aangaf.

Het leuke voor mij is, dat ik NU ook zie HOE het werkt. Veel voorbeelden zijn gemaakt om een ledje aan of uit te zetten, en ik zat dan al weer met de handen in het haar van; 'Ja, en hoe pas ik dat toe op mijn wissels dan????', want die moeten even, 150ms, aangetrokken worden, er moet delay bij en klaar, maar ja... Pas NU is dat duidelijk

Ja, dat random-verhaal, met verschillende nummers (en dus verschillende volgordes van treinen), dat was ook zo'n enorm vraagteken. In de computerlogica bestaat geen random. De standaard random-functie van Arduino zal altijd volgens een vaste sequence werken en dat viel me bij de eerste poging al gelijk op. Die volgorde was (na het aanzetten van de arduino) steeds hetzelfde en op het laatst gewoon voorspelbaar. Uiteindelijk kwam er een collega van mij met het idee om een klokmodule op de arduino aan te sluiten, die uit te lezen en dan met de getallen die daaruit kwamen, kon ik dan random nummers genereren. Alleen vertelde hij er niet bij hoe... dat wist'ie zelf ook niet... handig!

Gezien de code die ik in de openingspost heb geplaatst, zie je duidelijk dat er nog het een en ander te verbeteren is. Het zijn codes die ik gevonden heb en uitgebreid heb, zoals dat LCD-print. En dan nu een klokmodule erop en getallen uitlezen... geen idee hoe.

Na lang zoeken zag ik een post met randsomSeed en een willekeurige library die je kon inlezen en aan de hand daarvan wordt de boel nu wel random volgens mij. Ik kan in elk geval geen vaste sequence vinden, ook gisteren niet toen ik dus ruim 120 treinen heb laten rijden. Als er al twee treinen tweemaal achter elkaar aan komen, is dat (volgens mij) echt toeval, en dat kan, want er blijven nu slechts 7 treinen over om uit te kiezen, want 11 - 4 voorgaande treinen is 7...

Wat betreft het uitbreiden van de Arudino met een andere code voor andere functies... Op dit moment zit de Arduino Mega bijna vol. Er hangen nu al 32 relais aan waarvan er 31 gebruikt worden. Dat zijn dus al 31 pinnen die gebruikt zijn. Samen met pinnen voor de ingangen en displays, is er haast geen ruimte meer. In de toekomst wil ik nog wel dat de verlichting, zoals lampjes in huisjes, straatlantaarns en de autootjes (waar ook licht in zit), ook geschakeld wordt door Arduino, maar daar ga ik wel een andere voor gebruiken, ik heb een paar Uno's en een paar Mega's besteld op Ali, toen nog voor een spotprijsje, vlak voor de invoering van de BTW-regels...

En nee, het herschrijven van de code is geen punt, het levert jullie beide zelfs een vermelding in de comments op bij de desbetreffende code, met dank aan
Nou, ik ga eens kijken waar ik de functies zélf neer moet zetten, ik neem aan onder void setup, maar dat vind ik nog wel uit

Dank voor de hulp zo op de vroege morgen, je was er vroeg bij @sterretje!

Ik laat het even weten als het gelukt is.
Roland.

Ps; Ook ik heb lange tijd moeten wachten voor ik weer wat kon met modeltreinen, die hebben twintig jaar in de doos gezeten. Dit is een mooi plekkie op een betrekkelijk kleine (en met name lage) zolder, maar met 4,30mx1,20 kan ik aardig uit de voeten, zeker met twee lagen zoals nu en er komt dus nog een kleine derde laag op.

hmeijdam · September 10, 2022, 8:49pm

Er zijn ook nog wel IC's die ervoor kunnen zorgen dat je met 6 uitgangen op je Arduino 16 relais kunt aansturen.
https://robojax.com/learn/arduino/?vid=robojax_16ch_relay_multiplexer

Met zo'n treinbaan heb je volgens mij nooit genoeg schakelende uitgangen, want er is altijd nog wel iets bij te verzinnen.

janzzen · September 11, 2022, 9:49am

Klopt! Die site van Robojax is echt leuk en handig, daar heb ik ook al veel naar gekeken.

Inderdaad, je kunt je Arduino tot haast oneindig veel relais uitbreiden, dat had ik al begrepen. Het schijnt dan wel dat hoe meer je erop aansluit, des te langer het duurt voor het juiste relais geschakeld wordt. Volgens een collega zou dat met een Mega wel meevallen omdat'ie sneller is/zou zijn dan een Uno.

Anyway, dát hoeft in dit geval niet. Want, en dat is nog niet ter sprake gebracht, er gaat in het schaduwstation ook wel eens wat verkeerd. Een trein die te hard binnen rijdt, kan ontsporen, of er gebeuren ontsporingen door de rails die iets uit elkaar is komen te liggen door de vele treinen die er overheen gereden zijn en in dat geval moet ik wel ingrijpen en ook de Arduino stilleggen. Als er op de contactrails waar butPin1 en butPin2 op zijn aangesloten, een trein of een wagon blijft staan, zal de Arduino elke 20 seconde wissels gaan schakelen. Niet handig als ik net bezig ben om de wagons in de krappe ruimte weer op de rails en op het juiste spoor probeer te krijgen.

Daarnaast zie je in het filmpje een soort printje óp de Arduino zitten. De schakelrail zorgt namelijk voor een 16 Volt wisselspanning. Die wordt op dat printje gelijk gericht naar een gelijkspanning, vervolgens omgezet naar 5 Volt gelijkspanning en daarmee worden twee optocouplers tegelijk aangestuurd die aan de andere kant weer verbonden zijn met pen 2 en pen 4 van de Arduino (butPin2 en butPin4 in de code). Op die manier wordt de boel dus aangestuurd, of beter, wordt de loop in gang gezet.

Dat wordt overigens bewust met twee pinnen gedaan, omdat ik met één pin veel last had van EMI. Door de verschillende wisselstroom spoelen komt er nogal wat 'rotzooi' vrij op de kabels en begon het schaduwstation vanzelf te schakelen. Dat leidde tot chaos, echt chaos! Testen met andere pull-up weerstanden, kabels afschermen, de Arduino inpakken in aluminiumfolie, het mocht niet baten. Na lang nadenken heb ik toen twee inputs gemaakt en wonderbaarlijk was het hele probleem daarna over.

Je wilt niet wéten wat een kabelbende het is aan de achterkant van de Arduino. Ik had de wissels mooi genummerd, maar door een latere wijziging en het verleggen van de wissels, is de volgorde van de te schakelen wissels behoorlijk verwarrend geworden. Gelukkig heb ik alles gedocumenteerd en kan ik zo nakijken welke wissel op welk relais zit.

Voor de verlichting, daar wil ik straks gewoon een andere Arduino voor gebruiken. Zo blijven de twee zaken mooi gescheiden natuurlijk. De verlichting zal ook met één druk op de knop langzaam aan gaan. Eerst wat straatlantaarns (per wijk of per gebied), dan een lichtje in een gebouw, dan wat autootjes die hun lampen aan zetten, reclameverlichting langs de weg die aan gaat, enz enz. Omdat dit een zelfde principe is als de wisselschakeling (met wat delay zo her en der) en random nummering, kan zelfs de verlichting elke keer een ander patroon volgen om aan te gaan. Met de geleerde truc van de functies, kan de code weer efficiënt worden en met de random-vergelijking gaat dat helemaal goed komen natuurlijk.

En inderdaad, je kan áltijd wel weer iets schakelen.

Versie 4.1 met geoptimaliseerde code werkt in elk geval. Ik kwam er al vrij snel achter dat de functies helemaal bovenin, nog boven void setup moeten staan, anders pakt de compiler ze niet en geeft'ie een foutmelding. Ergens ook wel logisch natuurlijk achteraf, haha!

Nou, ik kan in elk geval weer verder met het ontwerpen van de licht-schakeling, maar dat zal eerder een winterprojectje worden, en dan daarbij, eerst maar eens wat verdere aankleding doen op de baan

Nogmaals super bedankt voor alle hulp en inzichten!

Roland.

sterretje · September 11, 2022, 12:21pm

Ja, als je overal delay() gebruikt zal dat inderdaad het geval zijn Voor ieder wissel 200ms.

Je moet een andere collega vinden Een Mega heeft dezelfde architectuur als een Uno en draait ook nog eens op dezelfde klok snelheid (16 MHz).

Uiteraard. Daarom heb je vast een zeker ook een noodknop die alles spanningloos maakt.

Dat kun je voorkomen door niet te kijken of een pin hoog of laag is maar door te kijken of een pin van hoog naar laag (of van laag naar hoog) gaat. In het engels state change detection en er is een voorbeeld in the IDE.

Veel plezier er verder mee.

janzzen · September 12, 2022, 11:38am

Ik voel versie 4.2 aankomen... Ik heb het gezien inderdaad, Change State Detection! Daar ga ik vandaag zeker eens even mee aan de slag, dat is niet heel moeilijk volgens mij en lost wéér een probleem op. Alhoewel, de grootste problemen zijn al opgelost en mocht dat Change State niet lukken, dan is er inderdaad nog de noodknop om de boel stil te leggen. Als ik achter de baan zit en er gebeurt wat, dan moet de boel wel direct spanningsloos kunnen worden gemaakt.

Nou, nogmaals dank, ik kan weer verder sleutelen en genieten van de (nu echt) random treinen die hun ronde gaan doen

system · March 11, 2023, 11:39am

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
Random één pin aan na het maken van contact... Nederlands	26	2912	June 22, 2021
ipv nummer een woord Nederlands	4	839	May 6, 2021
arduino met ardublock Nederlands	1	918	May 6, 2021
sms ontvangen op scherm met arduino Nederlands	4	1172	May 6, 2021
keuze's laten maken Nederlands	16	9718	May 6, 2021

Onthouden van random nummers en deze vergelijken

Related topics