Ta sig ur kod-loopen

[fosfor]

Hej!

Jag har en kod här som gör att min motor stannar på en position från en motors rotary encoder, vilket är meningen. Den stannar i 1.5 sekund.
Problemet är bara att den står och loopar om sig själv, denna 1.5 sekund, hela tiden. Likaså meddelandet står och visas igen, igen, igen.
Så när jag ska köra bort ifrån denna position så blir det (som värst) 1.5 sekunds delay från att jag trycker på knappen till
att motorn börja röra sig igen. Vilket gör att jag måste stå och hålla in "kör" knappen en stund innan den reagerar, vilket medför ett lite "hackigt handhavande" av själva funktionen.

Jag skulle vilja att när den väl kört denna loop så tar den sig ur den redan efter en omgång, dvs 1.5 sekund och inget mer plus att
den inte ska behöva stå och visa meddelandet på displayen mer än den korta första gången den visas.

Hur skulle jag kunna "dirigera" ut mig från denna loop? Så att den bara "står still" och väntar på knapptryckning istället,
och så den sen då reagerar direkt när jag trycker på knappen utan att det blir nåt 1.5 seks delay?

Jag vill så att säga att denna kod körs One time only när den hamnat på den positionen.
Om jag tagit mig Ur positionen, och sen in igen samma visa, att den reagerar endast den gången, i totalt 1.5 sek.

// Trevlig långhelg alla!

Kod: Markera allt

  {
    if ( UserStopPulseCount != 0 && PulseCount >= UserStopPulseCount - 15 && PulseCount <= UserStopPulseCount + 15 )
    {
      digitalWrite(controlPin1, LOW);
      digitalWrite(controlPin2, LOW);
      lcd.setCursor(0, 1);
      lcd.print("Users Stop");
      Serial.println("Users programmed STOP activated");
      delay(1500);

    }
  }       //Går till raderna ovan

[Klas-Kenny]

Jag ser ingen loop, du har antagligen missat att klistra in ett stycke kod i början...

Men gissningsvis så är break; efter delayen, det du söker.

[SeniorLemuren]

Jag antar att det är själva huvudloopen du talar om och inte en loop just i din if-sats. Det gör ju att så länge if är sann så gör den ju om det hela vid varje programloop.

Sätt in din If-sats innanför en If-sats som kollar om t.ex. en variabel stopactivated == false. I ditt program använder du ju :

Kod: Markera allt

Serial.println("Users programmed STOP activated");

skapa en variabel stopactivated och sätt den till false när du startar programmet.
sätt sedan stopactivated till true i din if-sats.

Alternativt kan du ju lägga in vilkoret stopactivated !=true i din befintliga if-sats

[fosfor]

KlasKenny: Jag testade placera break; lite här och där i kodsnutten utan någon framgång. Den accepteras inte vid verifieringen?


SeniorLemuren: Hum ok... Det låter vettigt, jag tror jag förstår hur du menar.
Men kommer den inte loopas endå? Om den står kvar på positionen så att säga.
Fast ja, hmm, knepigt.
Jag tänkte att den loopar den lilla snutten kod, men det är väl så att den helt enkelt loopar hela koden med samma resultat som följd.
Hur fasen får man den att förstå att den bara ska gå just där bara en gång?

[Klas-Kenny]

Du får nog posta mer av din kod för att det ska gå att ge riktigt vettiga svar...

[ffredrik]

Här behövs en nybörjarkurs i c-programmering, annars blir det bara trial-and-error.

[fosfor]

Här är hela koden.
Och ja det har varit väldigt mycket trial n error

Kod: Markera allt

//  ---- MOTOR CONST INTARNA  - DESSA GÅR TILL H-BRYGGAN ----
const int controlPin1 = 7;
const int controlPin2 = 6;
const int enablePin = 9;

#include <Wire.h>                   // Tillåter I2C kommunikation - Pins A4 (SDA), A5 (SCL)
#include <LiquidCrystal_I2C.h>      // Denna aktiverar LCD
#include <EEPROM.h>                 // Denna aktiverar EEPROM minnet

// ---- Dessa används för sparning i EEPROM - 2018-04-16 ---------------------
// ---- Testade ta bort se vad som händer   - 2018-04-23 - Dessa rader verkar inte behövas
// struct MyObject{
//   float field1;
//   byte field2;
//   char name[10];
// };

// ---- DESSA TILLHÖR GRAFIK O PULSRÄKNINGEN ---------------------
// ---- Testar avaktivera 2018-04-23 - Denna rad verkar inte behövas
// char lineText[] = "  Hoy! Denna text syns ingenstans.  ";

// ---- VARIABLER
// exempel:   int pinName = 13      int är typ av variabeln ~ pinName är namnet ~ namnets värde är 13
// Senare i programmet kan man hänvisa till denna variabel med namnet, då kommer dess värde letas upp och användas
// exempel: float varName=val       varName är float namnet ~ val är värdet du assignar till den variabeln

int sensor01;               // Integer är din primära datatyp för nummersparning
int sensor02;
int stepOld;
int step;
long PulseCount;            // --- Long är förlängda storleks variabler för sparning av nummer. 32 bits (4 bytes).
long UserStopPulseCount;    // --- Denna ser till att räkningen är stadig


// ---- MOTOR TEST INT - VARIABLER ---------------------------------------------------------------------------------
int intest1Pin = 4;        // KNAPP 1   -  Kabel GRÅ    - Går åt plus hållet    - UPP
int intest2Pin = 5;        // KNAPP 2   -  Kabel GRÖN   - Går åt minus hållet   - NER
int intest3Pin = 10;       // KNAPP 3   -  Kabel SVART  - SPARA POSITION        - Minnet SPARA
int intest4Pin = 11;       // KNAPP 4   -  Kabel BLÅ    - VISA SPARAD POSITION  - Minnet RADERA
int intest5Pin = 16;       // KNAPP 5   -  Kabel GRÖN   - Truddelutt 1
int intest6Pin = 17;       // KNAPP 6   -  Kabel RÖD    - Truddelutt 2

int stopsensor1Pin = 12;   // SENSOR 1  -  Kabel GRÖN   - Enskild sensor - STOPPAR NER
int stopsensor2Pin = 8;    // SENSOR 2  -  Kabel GRÅ    - Enskild sensor - STOPPAR UPP
int stopsensor3Pin = 15;   // SENSOR 3  -  Kabel ROSA   - Enskild sensor - TOTALSTOPP
int val = 0;
int tonePin = 13;          // --- BEEPER ---


// ---- Dessa används för sparning i EEPROM - 2018-04-16 ---------------------
float f = 0.00f;        //Variable to store data read from EEPROM. F är namnet 0.00f är värdet
int eeAddress = 0;      //EEPROM address to start reading from


// I2C - DESSA TILLHÖR GRAFIK O PULSRÄKNINGEN - initialize the library with the numbers of the interface pins
// 0x27 adressen hittades via I2C scanner på den med svart tejp - De andra hade 0x3F
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// Aktivera denna rad härunder, och av-avaktivera den ovanför, om någon av de andra I2C displayerna ska användas
// LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);


// DESSA TILLHÖR GRAFIK O PULSRÄKNINGEN
#define SENSOR_A 3
#define SENSOR_B 2

void checkState()       // Void används bara i en funktions deklaration. Den indikerar att funktionen förväntas returnera ingen info till funktionen från vilken den var kallad
{
  sensor01 = digitalRead(SENSOR_A);
  sensor02 = digitalRead(SENSOR_B);

  if (sensor01 == 1 && sensor02 == 1) {
    step = 0;
    if (stepOld == 1) {
      PulseCount--;
    }
    if (stepOld == 3) {
      PulseCount++;
    }
    stepOld = 0;
  }

  if (sensor01 == 0 && sensor02 == 1) {
    step = 1;
    if (stepOld == 2) {
      PulseCount--;
    }
    if (stepOld == 0) {
      PulseCount++;
    }
    stepOld = 1;
  }

  if (sensor01 == 0 && sensor02 == 0) {
    step = 2;
    if (stepOld == 3) {
      PulseCount--;
    }
    if (stepOld == 1) {
      PulseCount++;
    }
    stepOld = 2;
  }

  if (sensor01 == 1 && sensor02 == 0) {
    step = 3;
    if (stepOld == 0) {
      PulseCount--;
    }
    if (stepOld == 2) {
      PulseCount++;
    }
    stepOld = 3;
  }
}


// VOID SETUP - KÖRS BARA EN GÅNG I BÖRJAN, EN FÖRBEREDELSE, LOOP ÄR EXEKVERING OCH GÖR DET MESTA JOBBET
// DESSA TILLHÖR GRAFIK O PULSRÄKNINGEN
// Void används bara i en funktions deklaration. Den indikerar att funktionen förväntas returnera ingen info till funktionen från vilken den var kallad

void setup()
{
  Serial.begin(9600);                      // Sätter data rate i bits per sekund (baud) för serial data transmission.
  lcd.begin(16, 2);                        // set up the LCD's number of columns and rows:
  lcd.setCursor(0, 0);                     // Print a message to the LCD.
  lcd.print("                ");
  lcd.setCursor(0, 1);
  lcd.print("                ");

  attachInterrupt(0, checkState, CHANGE);
  attachInterrupt(1, checkState, CHANGE);
  PulseCount = 0;
  EEPROM.get(0, UserStopPulseCount);    // Denna håller koll på räkning och radering av pulser. Adressen är 0.


  // TEST MOTOR  - VOID SETUP ---------------------------------------------------------------------------------
  pinMode(intest1Pin, INPUT);         //Declarar denna som input  UNO input är 4         Knapp 1   Grå     UPP
  pinMode(intest2Pin, INPUT);         //Declarar denna som input  UNO input är 5         Knapp 2   Grön    NER
  pinMode(intest3Pin, INPUT);         //Declarar denna som input  UNO input är 10        Knapp 3   Svart   SPARA POSITION
  pinMode(intest4Pin, INPUT);         //Declarar denna som input  UNO input är 11        Knapp 4   Blå     TA BORT POSITION
  pinMode(intest5Pin, INPUT);         //Declarar denna som input  UNO input är 16 (A2)   Knapp 5   Grön    Truddelutt 1
  pinMode(intest6Pin, INPUT);         //Declarar denna som input  UNO input är 17 (A3)   Knapp 6   Röd     Truddelutt 2
  pinMode(stopsensor1Pin, INPUT);     //Declarar denna som input  UNO input är 12                  Grön
  pinMode(stopsensor2Pin, INPUT);     //Declarar denna som input  UNO input är 8                   Grå
  pinMode(stopsensor3Pin, INPUT);     //Declarar denna som input  UNO input är 15 (A1)             Rosa
  pinMode(tonePin, OUTPUT);           //Declarar denna som output UNO input är 13        Högtalare / Beeper

  //  ---- LCD start presentationen
  {
    lcd.setCursor(2, 0);
    lcd.print("PROTOTYPE");
    Serial.println("Boot initialized");
    delay(500);
    // lcd.clear();

    lcd.setCursor(11, 1);
    lcd.print("1");
    delay(100);

    lcd.setCursor(11, 1);
    lcd.print("10");
    delay(100);

    lcd.setCursor(11, 1);
    lcd.print("100");
    delay(900);
    lcd.clear();

    lcd.setCursor(2, 0);
    lcd.print("Prototype 1.0");
    delay(200);

    lcd.setCursor(0, 1);
    lcd.print("www.");
    delay(100);

    lcd.setCursor(12, 1);
    lcd.print(".se");
    delay(100);

    lcd.setCursor(0, 1);
    lcd.print("www.PROTOTYPE.se");
    delay(250);

    lcd.setCursor(0, 1);
    lcd.print("www.PROTOTYPE.se");
    Serial.println("unit is active");

    delay(800);
    lcd.clear();
  }
}


void loop()

{
  // DESSA TILLHÖR GRAFIK O PULSRÄKNINGEN
  // LCD set the cursor to column 0, line 1 (note: line 1 is the second row, since counting begins with 0):

  lcd.setCursor(0, 0);

  lcd.print("Pulses:");
  if (PulseCount > -1) {
    lcd.print(" ");
  }

  if (PulseCount < 10 && PulseCount > -10) {
    lcd.print(" ");
  }

  if (PulseCount < 100 && PulseCount > -100) {
    lcd.print(" ");
  }

  lcd.print(PulseCount);
  if (sensor01 == 1) {
    lcd.print(" HIGH");
  }
  else {
    lcd.print(" LOW ");
  }

  lcd.setCursor(0, 1);

  if (sensor02 == 1) {
    lcd.print("            HIGH");
  }
  else {
    lcd.print("            LOW ");
  }


  // ---- INTEST PIN 3 - SPARAR
  // ---- SPARAR POSITION TILL EEPROM - FUNGERAR! ---- Använder knapp 3 på breadboard

  {
    val = digitalRead(intest3Pin);         // Knapp 3 - Denna ska spara position i minnet
    if (val == HIGH) {                     // Kollar om knappen är tryckt
      UserStopPulseCount = PulseCount;
      EEPROM.put(0, UserStopPulseCount);   // Skriver PulseCount numret till minnet, adressen är 0

      lcd.setCursor(0, 1);                 // Dessa två rader skriver till LCD, i detta fall är 0,1 rad 2
      lcd.print(PulseCount);
      delay(750);
      lcd.setCursor(0, 1);
      lcd.print("Pos. SAVED");
      Serial.println("Saving liftposition to memory");
      delay(750);
    }
  }


  // ---- INTEST PIN 4 - RADERAR positionen från minnet/EEPROM
  {
    val = digitalRead(intest4Pin);         // Knapp 4 - Ska radera minnet
    if (val == HIGH) {                     // Kollar om knappen är tryckt
      UserStopPulseCount = 0;
      EEPROM.put(0, UserStopPulseCount);   //
      lcd.setCursor(0, 1);                 // Dessa två rader skriver till LCD, i detta fall är 0,1 rad 2
      lcd.print("Pos. erased");
      Serial.println("Erasing position from memory");
      delay(1000);
    }
  }


  // ---- FUNGERAR! Dessa rader stoppar motorn 1 sek när den är inom värdet, gäller både UPP och NED
  {
    if ( UserStopPulseCount != 0 && PulseCount >= UserStopPulseCount - 15 && PulseCount <= UserStopPulseCount + 15 )
    {
      digitalWrite(controlPin1, LOW);
      digitalWrite(controlPin2, LOW);
      lcd.setCursor(0, 1);
      lcd.print("Users Stop");
      Serial.println("Users programmed STOP activated");
      delay(1500);
    }
  }       //Går till raderna ovan


  // ---- INTEST PIN 5 - TEST för melodi!
  {
    val = digitalRead(intest5Pin);         // Knapp 5 - TEST - Ska spela melodi eller ljud
    if (val == HIGH) {                     // Kollar om knappen är tryckt
      lcd.setCursor(0, 1);                 // Dessa två rader skriver till LCD, i detta fall är 0,1 rad 2
      lcd.print("Button 5");
      Serial.println("Playing tone on button 5!");
      delay(200);

      // -- Dessa tre rader nedanför gör pipljudet när användarens programmerade stopp aktiveras
      tone(tonePin, 600);
      delay(50);
      tone(tonePin, 950);
      delay(70);
      tone(tonePin, 680, 125);
      delay(100);
      tone(tonePin, 600);
      delay(50);
      tone(tonePin, 950);
      delay(70);
      tone(tonePin, 720, 125);
      delay(800);
      noTone(tonePin);
      delay(100);
    }
  }

  // ---- INTEST PIN 6 - TEST för melodi!
  {
    val = digitalRead(intest6Pin);         // Knapp 6 - TEST - Ska spela melodi eller ljud
    if (val == HIGH) {                     // Kollar om knappen är tryckt
      lcd.setCursor(0, 1);                 // Dessa två rader skriver till LCD, i detta fall är 0,1 rad 2
      lcd.print("Button 6");
      Serial.println("Playing tone on button 6!");
      delay(200);

      // -- Dessa tre rader nedanför gör pipljudet när användarens programmerade stopp aktiveras
      tone(tonePin, 600);
      delay(50);
      tone(tonePin, 720);
      delay(70);
      tone(tonePin, 680);
      delay(100);
      tone(tonePin, 600);
      delay(50);
      tone(tonePin, 950);
      delay(70);
      tone(tonePin, 880, 125);
      delay(800);
      noTone(tonePin);
      delay(100);
    }
  }


  //  ---- MOTORNS VOID LOOP - KNAPPSTYRNINGEN TILL MOTORERNA ----
  // intest 1 ÅKER UPP
  // intest 2 ÅKER NER
  // stopsensor1Pin heter stoppsensorn som hindrar UPP
  // stopsensor2Pin heter stoppsensorn som hindrar NED
  // stopsensor3Pin heter stoppsensorn som hindrar UPP eller NED

  {
    // ---- ÅKER UPP
    val = digitalRead(intest1Pin);         // UPP - Läser input värde
    if (val == HIGH)                       // Checkar om knappen trycks
    {
      digitalWrite(controlPin1, HIGH);
      digitalWrite(controlPin2, LOW);


      // ---- UPP o NER HINDRAS av denna sensor, denna kod stoppar när man kör upp
      {
        val = digitalRead(stopsensor3Pin);
        if (val == HIGH) {
          digitalWrite(controlPin1, LOW);

          // -- Dessa 3 rader visar USER STOP när sensorn stoppar nedgång - delay ställer flimret men slöar också ner visningen av pulsräkningen ------
          lcd.setCursor(0, 1);
          lcd.print("User Stop");
          Serial.println("User removeable module defined stop 1");
          delay(50);

          // -- Dessa tre rader nedanför gör pipljudet när UPP & NER stopsensorn (ovan) täcks
          tone(tonePin, 600);
          delay(50);
          tone(tonePin, 950);
          delay(70);
          tone(tonePin, 800, 125);
          delay(800);
          noTone(tonePin);
        }
      }

      // ---- UPP HINDRAS av denna sensor
      {
        val = digitalRead(stopsensor2Pin);         // Sensor 2 som stoppar motorn, likaså sensor 3 vars uppgift är att stoppa både upp och ner
        if (val == HIGH) {
          digitalWrite(controlPin1, LOW);

          // -- Dessa 3 rader visar UPSTOP när sensorn stoppar nedgång - delay ställer flimret men slöar också ner visningen av pulsräkningen ------
          lcd.setCursor(0, 1);
          lcd.print("Up Stop");
          Serial.println("Upper security sensor reached Can only go down");
          delay(50);

          // -- Dessa tre rader nedanför gör pipljudet när stopsensorn (ovan) täcks påvägen UPP
          tone(tonePin, 880);
          delay(125);
          tone(tonePin, 400, 125);
          delay(650);
          noTone(tonePin);
        }

        // ---- Dessa rader visar UP när nedåtknapp trycks NED - delay ställer flimret men slöar också ner visningen av pulsräkningen ------
        lcd.setCursor(0, 1);
        lcd.print("Up");
        Serial.println("Lift going up at full speed");
        delay(50);
      }
    }


    // ---- ÅKER NER ----
    else {
      val = digitalRead(intest2Pin);         // NER - Läser input värde
      if (val == HIGH) {                     // Checkar om knappen trycks
        digitalWrite(controlPin1, LOW);
        digitalWrite(controlPin2, HIGH);


        // -- UPP o NER HINDRAS av denna sensor, denna kod stoppar när man kör ner
        {
          val = digitalRead(stopsensor3Pin);         // TEST
          if (val == HIGH) {
            digitalWrite(controlPin2, LOW);

            // -- Dessa 3 rader visar STOP när sensorn stoppar nedgång - delay ställer flimret men slöar också ner visningen av pulsräkningen ------
            lcd.setCursor(0, 1);
            lcd.print("User Stop");
            Serial.println("User removeable module defined stop 2");
            delay(50);

            // -- Dessa tre rader nedanför gör pipljudet när UPP & NER stopsensorn (ovan) täcks
            tone(tonePin, 600);
            delay(50);
            tone(tonePin, 950);
            delay(70);
            tone(tonePin, 800, 125);
            delay(800);
            noTone(tonePin);
          }
        }


        // ---- NER HINDRAS av denna sensor
        {
          val = digitalRead(stopsensor1Pin);         // Sensorn 1 som stoppar motorn, likaså sensor 3 vars uppgift är att stoppa både upp och ner
          if (val == HIGH) {
            digitalWrite(controlPin2, LOW);

            // -- Dessa 3 rader visar DOWN STOP när sensorn stoppar nedgång - delay ställer flimret men slöar också ner visningen av pulsräkningen ------
            lcd.setCursor(0, 1);
            lcd.print("Down Stop");
            Serial.println("Lower security sensor reached Can only go up");
            delay(50);

            // -- Dessa tre rader nedanför gör pipljudet när stopsensorn (ovan) täcks påvägen ner
            tone(tonePin, 880);
            delay(125);
            tone(tonePin, 400, 125);
            delay(650);
            noTone(tonePin);
          }

          // -- Dessa 3 rader visar DOWN när nedåtknapp trycks NED - delay ställer flimret men slöar också ner visningen av pulsräkningen ------
          lcd.setCursor(0, 1);
          lcd.print("Down");
          Serial.println("Lift going down at full speed");
          delay(50);
        }

        // -- Dessa två rader stoppar motorn när man släpper knappen
      }  else
      {
        digitalWrite(controlPin1, LOW);
        digitalWrite(controlPin2, LOW);
      }


    }   // Går till Åker ner
  }     // Går till Åker upp
}       // Går till puls o grafikräkning - Högst upp

[lillahuset]

Och ja det har varit väldigt mycket trial n error

Lyssna då på ffredriks råd. Använd gärna en PC när du lär dig så kanske det blir lite effektivare.

[adent]

Du gör ett klassiskt fel.

Allt som finns i din funktion loop() körs om-och-om-igen. Om du lägger en delay() där som du först hade till 1500 så
stannar allt där i 1.5 sekund. (1500ms antar jag). Det kallas för en blockande wait. Du stannar där och blockerar all vidare kodexekvering.

Ett sätt att lösa det på är att bryta isär det. Jämför följande två scenarier:


1. Upprepa: Diska allt färdigt, kolla sedan om det brinner och släck.
2. Upprepa: Diska en sak, kolla sedan om det brinner och släck.

I fall två upptäcker du om det brinner mycket fortare eftersom du bara diskar en sak innan du kollar om det brinner.
I fall ett brinner du kanske inne.

Kod: Markera allt

void loop()
{
   static unsigned char *text;
   static uint32_t timestamp;  // Detta kan vara helt fel men principen.
   static uint16_t blockfor = 0;
   static uint8_t nytext = 0;
  
   if(blockfor == 0)
   {
       if(villkor1)
       {
          text = "Text att visa på displayen för villkor1";   
          blockfor = 1500;  // 0 för icke blockerande, Annars blockera antalet ms.
          nytext = 1;  // flagga att vi har en ny text att visa
       }

       if(villkor2)
       {
          text = "Text att visa på displayen för villkor2";   
          blockfor = 500;  // 0 för icke blockerande, Annars blockera antalet ms.
          nytext = 1;  // flagga att vi har en ny text att visa
       }

       if(villkor3)
       {
          text = "Text att visa på displayen för villkor3";          
          block = 0;  // 0 för icke blockerande, Annars blockera antalet ms.
          nytext = 1;  // flagga att vi har en ny text att visa
       }
   }
   
   if(villkor4)
   {
     // Något som inte kan blockeras, kanske knapptryckningar?
   }
   
   if(nytext == 1)
   {     
      visa(text)      
      nytext = 0;  // texten visad, kvittera.
      timestamp = get_current_time_stamp_in_ms();
   }
   
   if((get_current_time_stamp_in_ms() - timestamp) > blockfor) // Funkar även vid wraparound, bara timestamp och funktionen returnerar samma unsigned-typ.
   {
        blockfor = 0;       
   }
}

Alternativt ett enklare, men lite fulare sätt:

Kod: Markera allt

void loop()
{
   static unsigned char *text;   
   static uint16_t blockfor = 0;
   static uint8_t nytext = 0;
  
   if(blockfor == 0)
   {
       if(villkor1)
       {
          text = "Text att visa på displayen för villkor1";   
          blockfor = 1500;  // 0 för icke blockerande, Annars blockera antalet ms.
          nytext = 1;  // flagga att vi har en ny text att visa
       }

       if(villkor2)
       {
          text = "Text att visa på displayen för villkor2";   
          blockfor = 500;  // 0 för icke blockerande, Annars blockera antalet ms.
          nytext = 1;  // flagga att vi har en ny text att visa
       }

       if(villkor3)
       {
          text = "Text att visa på displayen för villkor3";          
          block = 0;  // 0 för icke blockerande, Annars blockera antalet ms.
          nytext = 1;  // flagga att vi har en ny text att visa
       }
   }
   
   if(villkor4)
   {
     // Något som inte kan blockeras, kanske knapptryckningar?
   }
   
   if(nytext == 1)
   {     
      visa(text)      
      nytext = 0;  // texten visad, kvittera.      
   }
   
   if(blockfor > 0)
   {
        blockfor--;     // Minska med ett, eftersom vi på raden nedanför väntar 1ms.  
   }

   delay(1);  // Blockerar hårt, men bara 1ms per varv.

}

[fosfor]

Hmm....

Alltså jag skulle ju vilja ta 1.5 sek stoppet ut ur "loopen", funkar det att lägga den i Void Setup istället?

Och när jag är i den sparade positionen, så ska den fatta att den inte behöver göra nåt mer.
Men å ena sidan när den är utanför den sparade positionen så måste den förstå att den kan gå in i 1.5 sek stoppet igen.

Är lösningen att placera 1.5 sek stoppet utanför loopen, skapa nån slags integer som kan va true eller false som ser till att
bestämma över huruvida loopen får gå in i 1.5 stoppet eller inte?

Svårt att förklara märker jag, hoppas ni förstår.

[fosfor]

adent:

Skulle vara jätteuppskattat om du kan förklara vad som är skillnaden mellan de olika platserna i minnet.
Och exakt vad koden du skrivit ner Betyder och Gör?
Alltså vad i koden är det som säger att den siffran ska hit, och den siffran ska dit?
Kan jag namnge dessa "minnesplatser" som t.ex.
- Siffra1
- Siffra2

Om du kikar på min kod längre upp i tråden. Jag kan ju spara en position där, vad är det som är skillnaden och vad måste göras
för att jag ska kunna låt säga spara två eller tre positioner. Hur vet programmet skillnaden?
Har alla samma adress men olika namn? Hur fungerar det?

?

[ffredrik]

Som sagt: Utan en nybörjarkurs i C kommer du aldrig vidare. Du saknar helt grunderna.

[johano]

Jag håller med.
Det blir ungefär som att du försöker bygga en bil och frågar vad skruvar&muttrar används till.

/j

[sodjan]

Det normala med allt som har med fördröjningar eller tidtagning att göra
är att använda timers. Du sätter upp timern med lämpliga värden och
startar den. Sen kan du göra vad du vill under tiden. Om den behöver
stoppas eller kanske startas om, så gör du bara det. Om timern "går ut"
så kan den direkt anropa en "timer interrupt" funktion som då gör det
som ska göras i det fallet.

Är det inte Arduino som du använder? Jag är övertygad om att det
finns bra info på Arduinos dokumentations sidor kring timers...

[arvidb]

https://www.arduino.cc/en/Tutorial/Variables
https://www.arduino.cc/en/Reference/FunctionDeclaration