Pause mit millis wenn geschaltet wird.

[i_make_it]

Es fällt mir etwas schwer zu verstehen auf was genau Du raus willst.

Pause mit millis wenn geschaltet wird.

Der Befehl zum Pausieren/Anhalten eines arduino Programms ist schon delay.

Hallo,
ich weiß, es gibt etliche Anweisungen.
Aber alle sind mit "Blink".

Falls Du mit anweisung C++ befehle meinst, "Blink" ist nicht Teil der Arduino C++ Sprache.
"Blink" ist ein Code Beispiel so wie am PC oft "Hello world".

Wie Hawe schon geschrieben hat, fragt millis nur einen Timer ab, genauer den freilaufenden Timer der seit dem Einschalten des µC läuft.
Bei jedem Aufruf erhält man also die "Uptime" des µC in ms.
Ein übliches vorgehen ist, eine variable mit dem wert von milis zu befüllen, dann zu verhindern, das die Variable ständig überschrieben wird und vom Millis aufruf den Wert der Variabel abzuziehen. Das Ergebniss ist eine bei jedem Programmdurchlauf größer werdende Zahl.
Diese kann man mit einem dritten Wert vergleiche und z.B. etwas machen lassen solange der Wert der Variablen kleiner dem Grenzwert ist oder oder etwas machen lassen sobald der Grenzwert überschritten wird.
Etwas machen zu lassen wenn beider Werte genau gleich sind, geht nur mal zufällig gut, Da die Laufzeit des Programms ja je nach Verzweigung sich ändern kann und deshalb nicht sichergestellt ist das man in der Programmzeiler der millis Abfrage genau dann ankommt wenn exakt die entsprechende Zeit verstrichen ist.
Soll es also ganz Genau gleich sein, dann nimmt man Timer-Interrupts.

In dem untenstehenden Beispiel nutze ich millis auf einem nano um zwei Ultraschallsensoren gleichzeitig (50% zeitversetzt) zu betreiben und gleichzeitig noch drei Reflexlichtschranken auswerten zu können.
(Da die US Echos zetilich nicht vorhersehbar sind, werden dafür dann noch Interrupteingänge und ISRs genutzt)

const int us1_echo = 2;
const int us2_echo = 3;
const int us1_trig = 4;
const int us2_trig = 5;
const int lf_le = 8;
const int lf_ce = 9;
const int lf_ri = 10;
int lf_le_state = LOW;
int lf_ce_state = LOW;
int lf_ri_state = LOW;
unsigned long us1_echo_st;
unsigned long us2_echo_st;
unsigned long us1_echo_et;
unsigned long us2_echo_et;
unsigned long us1_srt;
unsigned long us2_srt;
unsigned long us1_dist;
unsigned long us2_dist;
unsigned long prev1micros = 0;
const long toggleinterval = 1000;
int togglestate = LOW;
int us1_flag = 0;
int us2_flag = 0;
char* string_[]={"Linefollow:", "US-Echo1:", "US-Echo2:", "Cycletime:"};
unsigned long prev2micros = 0;

void setup() {
  Serial.begin(9600);
  pinMode(us1_echo, INPUT);
  pinMode(us2_echo, INPUT);
  pinMode(us1_trig, OUTPUT);
  pinMode(us2_trig, OUTPUT);
  pinMode(lf_le, INPUT);
  pinMode(lf_ce, INPUT);
  pinMode(lf_ri, INPUT);
  attachInterrupt(0, US1_ISR, CHANGE);
  attachInterrupt(1, US2_ISR, CHANGE);
}

void loop() {
  lf_le_state = digitalRead(lf_le);
  lf_ce_state = digitalRead(lf_ce);
  lf_ri_state = digitalRead(lf_ri);
  unsigned long cur1micros = millis();
  if (cur1micros - prev1micros >= toggleinterval) { //alle 10ms umschalten
    prev1micros = cur1micros;
    if (togglestate == LOW){
      togglestate = HIGH;
      digitalWrite(us1_trig, HIGH);
      digitalWrite(us2_trig, LOW);
      us1_echo_st = 0;
      us1_flag = 0;
    }else{
      togglestate = LOW;
      digitalWrite(us1_trig, LOW);
      digitalWrite(us2_trig, HIGH);
      us2_echo_st = 0;
      us2_flag = 0;    
    }
  }
   us1_dist = (us1_srt / 58); // Umrechnung des Sensorwerts, ungefähr in  cm (für 343m/s bei trockner Luft und 20° wäre 58,3 der genaue Wert)
  us2_dist = (us2_srt / 58);
  Serial.print(string_[1]);
  Serial.println(us1_dist);
  Serial.print(string_[2]);
  Serial.println(us2_dist);
  Serial.print(string_[0]);
  Serial.print(lf_le_state);
  Serial.print(lf_ce_state);
  Serial.println(lf_ri_state);
  unsigned long cur2micros = micros();
  Serial.print(string_[3]);
  Serial.println(cur2micros - prev2micros);
  prev2micros = cur2micros;
}

void US1_ISR(){
  if (us1_echo_st == 0) {
    us1_echo_st = micros();
  } else {
    us1_echo_et = micros();
    ++us1_flag;
  }
  if (us1_flag == 1) {
    us1_srt = (us1_echo_et - us1_echo_st);
  }
}

void US2_ISR(){
  if (us2_echo_st == 0) {
    us2_echo_st = micros();
  } else {
    us2_echo_et = micros();
    ++us2_flag;
  }
  if (us2_flag == 1) {
    us2_srt = (us2_echo_et - us2_echo_st);
  }
}

Für Dich von Interesse dürfte davon vermutlich das untenstehende sein:

unsigned long prev1micros = 0;
const long toggleinterval = 1000;
int togglestate = LOW;

void setup() {
}

void loop() {
<<<<< hier passiert was das nichts mit der Zeit zu tun hat
  unsigned long cur1micros = millis();
  if (cur1micros - prev1micros >= toggleinterval) { //alle 10ms umschalten
    prev1micros = cur1micros;
    if (togglestate == LOW){
      togglestate = HIGH;
<<<<< hier passiert was das Abhängig von der Zeit ist
    }else{
      togglestate = LOW;
<<<<< hier passiert was das Abhängig von der Zeit ist
    }
  }
<<<<< hier passiert was das nichts mit der Zeit zu tun hat
}

hier schalte ich alle 1000ms (oder mehr) zwichen zwei Zuständen um.

Was noch zu berücksichtigen ist, ist das millis natürlich irgendwann überläuft und dann einmal der aktuelle Wert kleiner sein kann als der in der Variablen gespeicherte.
Diesen Fehlerfall sollte man noch abfangen, denn sonst funktioniert das Programm sollange bis millis das erste mal den Maximalwert erreicht und danach nicht mehr, da millis ja nie mehr um den Grenzwert größer werden kann als der gespeicherte Wert.
Also:

if (cur1micros > prev1micros) prev1micros = 0;

müsste noch zum Code dazu.