INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Frage zu Delay-Alternative
14.01.2021, 23:24
Beitrag #1
Frage zu Delay-Alternative
Hallo,
ich bin ein Gelegenheitsprogrammierer mit eher wenig Ahnung. Könnte mir jemand sagen wie ich hier Delay ersetzen kann?

If
Bedingung erfüllt
then
Schalte Lampe ein
Delay 1500
Schalte Lampe aus
Delay 2800
End If

Im voraus vielen Dank
Hans
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
14.01.2021, 23:34
Beitrag #2
RE: Frage zu Delay-Alternative
Moin Hans,
frag mal Google nach Blinkwithoutdelay. Oder in der IDE unter Beispiele-->02.Digital-->BlinkWithoutDelay.
Gruß Jan
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
14.01.2021, 23:41
Beitrag #3
RE: Frage zu Delay-Alternative
Hallo Jan,
das habe ich gefunden und nicht kapiert außerdem ist da die Zeit von an und aus gleich. Bei mir sind die
Zeiten ja unterschiedlich.
MfG
Hans
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
14.01.2021, 23:54 (Dieser Beitrag wurde zuletzt bearbeitet: 14.01.2021 23:55 von nbk83.)
Beitrag #4
RE: Frage zu Delay-Alternative
Hast Du das hier gesehen?
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.01.2021, 08:31
Beitrag #5
RE: Frage zu Delay-Alternative
Und wenn einem das Lernen schwer fällt, dann gibt es noch reichlich Libraries, die man verwenden könnte. Z.B. die "simpletimer.h" oder die "interval.h".
Mit denen kannst du auch die delays umgehen.
Dennoch solltest du es mit den millis (BlinkWithoutDelay) selbst aufbauen und daraus lernen.
Das macht dir später vieles leichter.

Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.01.2021, 10:35 (Dieser Beitrag wurde zuletzt bearbeitet: 15.01.2021 11:17 von Franz54.)
Beitrag #6
RE: Frage zu Delay-Alternative
Ich habe hier ein Programm, das ich gerne als Grundlage für ein neues Programm nehme, wenn ich was mit Tastenabfrage, Relais Steuerung, Displayausgabe, u.s.w. machen möchte. Da schmeisse ich dann raus was ich nicht brauche, und baue bischen was dazu was ich zusätzlich benötige. Das Programm in sich funktioniert eigenständig, denn ich wollte damit eben auch was zum üben, ausprobieren, für User haben, die sich damit noch nicht gespielt haben. Aber eigentlich ist es Sinnfrei Smile

Da siehst du alle Teile von Taster1 und 2, Deklarationen, und Tastenabfrage. Die Tastenabfrage wird immer, wenn sie einmal gemacht wurde, für 200ms übersprungen. Es wird als erstes abgefragt, ob die 200ms vorbei sind, wenn diese abgelaufen sind, wird der Taster abgefragt, wurde der Taster gedrückt, wird der Status des Tasters neu gesetzt und die 200ms neu gestartet. Es passiert noch mehr in dem Programm, aber zum verstehen von Millis denke ich ist das ganz brauchbar. Ich habe darin extra alles sehr genau kommentiert was in den Zeilen passiert. Das sollte man dann auch sehr leicht verstehen und anpassen können.

Achtung, du musst weg vom delay Denken. In den Programmen mit den millis wird NICHTS GESTOPPT, sondern es wird der Teil, der für die Zeit nicht ausgeführt werden soll, UBERSPRUNGEN. Alle Programmteile im Loop werden alle paar Millisekunden durchlaufen und die Zeit in den Blöcken neu abgefragt. Wenn du im Programm suchst, wo Stopp ist, kannst du nichts finden und nichts verstehen, weil NICHTS gestoppt wird.

Franz

Code:
[code]
// Deklarationen

// Timer DS3231 einrichten
#include "Wire.h"
#define DS3231_ADDRESSE 0x68
// LCD Display I2C 4 Zeilen je 20 Zeichen einrichten
#include <LiquidCrystal_I2C.h> // LCD Display
// Displayadresse ist 0x27 oder 0x3F
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

// Baudrate fuer Serial Schnittstelle
const int baudSerial = 9600;
//-----------------------Taster01----------------------------------------
// const byte ist im Programm Constant und byte ist fuer Werte 0-255
const byte Taster01 = 15;           // Pin 15 wird Constant als Taster01 bezeichnet
byte Tasterstatus01 = 0;            // Zum Abfragen des Tatsenpins
byte Tastenmerker01 = 0;            // Zum Merken des aktuellen Tatsenstatus
unsigned long Sekundenablauf01 = 0; // Tastenabfrage von Taster02 300ms aussetzen
const unsigned long Pausezeit01 = 200;
//-----------------------Taster02---------------------------------------
const byte Taster02 = 16;           // Pin16 wird Constant als Taster02 bezeichnet
byte Tasterstatus02 = 0;
byte Tastenmerker02 = 0;
unsigned long Sekundenablauf02 = 0; // Tastenabfrage von Taster02 300ms aussetzen
const unsigned long Pausezeit02 = 200;
//-----------------------Analoger Eingang A0------------------------------
const byte ANALOG_PIN = A0; // Hier wird der Name fuer den Steuereingang festgelegt
int a0 = 0;      // Der Speicher fuer den Analogwert
int a0alt = 0;   // Der Speicher fuer den alten Analogwert

//-----------------------PWM Pins festlegen am Mega-----------------------
/* Timer und zugehörige Pinns:
   timer 0 (controls pin 13, 4);
   timer 1 (controls pin 12, 11);
   timer 2 (controls pin 10, 9);
   timer 3 (controls pin 5, 3, 2);
   timer 4 (controls pin 8, 7, 6);
   Wenn ich den Pin10 als PWM_PIN3 deklariere, dann bekomme ich Probleme bei der Tonausgabe
   auf Pin 17. Also wenn ich Pin 10 anstelle von Pin 9 als PWM Ausgang benutze, dann wird
   die Tonfrequenz von Pin17 liniar mit dem eingestellten PWM Signal verändert. Wenn ich
   wie jetzt im Programm für Pin10 den Pin9 verwende ist da kein Problem mehr. Der Pin10
   ist nicht beschalten.
*/
int PWM_PIN2 = 13;  // PWM Ausgabepin 13 festlegen auf 490Hz, Timer0
int PWM_PIN1 = 11;  // PWM Ausgabepin 11 festlegen auf 31300Hz, Timer1
int PWM_PIN3 = 9;  // PWM Ausgabepin 9 festlegen auf 980Hz, Timer2
//-----------------------AusgangPIN31-------------------------------------
const byte Ausgang01 = 6;          // Pin 6 ist für das Relais01
byte Ausgangsstatus01 = 0;
unsigned long Sekundenablauf03 = 0; // Ausgang Schaltzeit auf 3000ms 3 Sekunden einrichten
const unsigned long Pausezeit03 = 3000;
//-----------------------AusgangPIN32-------------------------------------
const byte Ausgang02 = 7;          // Pin 7 ist für das Relais02
byte Ausgangsstatus02 = 0;
unsigned long Sekundenablauf04 = 0; // Ausgang Schaltzeit auf 1000ms 1 Sekunde einrichten
const unsigned long Pausezeit04 = 1000;
//-------------------------Tonausgabe PIN 17-----------------------------
const byte tonPin = 17;
const int frequenz = 1000;
unsigned long tonZeit = 100;
//-------------------------Programmdurchlauf in Millis messen------------
unsigned long Startzeit = 0;
unsigned long Stoppzeit = 0;
//-------------------------Kontrolle ob eine Minute abgelaufen-----------
unsigned long minutenablauf = 0;
unsigned long eineminute = 60000;
//================================================================================​=============================
void setup() {

  //I2C für DS3231 aktivieren
  Wire.begin();
  // Wenn die I2C Leitung länger ist, kann man den Tackt für den I2C Bus langsammer machen!!
  Wire.setClock(32000);

  // Serial Schnittstelle starten
  Serial.begin(baudSerial);

  // Wenn die Zeit gestellt werden muß
  // aktuelle Zeit        sek min std wt tag monat jahr
  // einstellenDS3231zeit(00, 22, 22, 2, 16,  06,  20);

  // ----------PWM Tackt für Pin 11&12 auf 31300Hz ändern---------------
  TCCR1B = TCCR1B & 0b11111000 | 0x01;

  //-----------LCD Display Start----------------------------------------
  lcd.begin(20, 4);
  lcd.backlight();
  lcd.clear();
  //-----------Display Maske erstellen----------------------------------
  zeigeZeit(); // Zeit ausgeben    // Zeile 1
  lcd.setCursor (0, 3);            // Zeile 4
  lcd.print (F("PWM Wert "));
  lcd.setCursor (0, 1);            // Zeile 2
  lcd.print (F("Taste 01  0"));
  lcd.setCursor (15, 1);
  lcd.print (F("02  0"));
  lcd.setCursor (0, 2);            // Zeile 3
  lcd.print (F("Ausg. 01  0"));
  lcd.setCursor (15, 2);
  lcd.print (F("02  0"));
  //-----------Taster einrichten----------------------------------------
  pinMode(Taster01, INPUT_PULLUP); // Pin 15 fuer Taster01 wird intern auf plus gelegt. Mit GND ueber Taste aktivieren
  pinMode(Taster02, INPUT_PULLUP); // Pin 16 fuer Taster02
  //-----------Ausgang einrichten---------------------------------------
  pinMode(Ausgang01, OUTPUT);      // Pin 6 (Ausgang01) ist als Ausgang aktiviert
  pinMode(Ausgang02, OUTPUT);      // Pin 7 (Ausgang02) ist als Ausgang aktiviert
  //-----------Input und Output Pin für PWM bestimmen-------------------
  pinMode(ANALOG_PIN, INPUT);      // Eingang für Poti A0
  pinMode(PWM_PIN1, OUTPUT);       // Pin 11
  pinMode(PWM_PIN2, OUTPUT);       // Pin 13
  pinMode(PWM_PIN3, OUTPUT);       // Pin 9
  //--------------Ton Ausgabepin einrichten----------------------------
  pinMode(tonPin, OUTPUT);         // Pin 17
  //--------------Startzeit für Zeitausgabe----------------------------
  minutenablauf = millis();
}
//================================================================================​=============================
void loop() {
  Startzeit = micros();
  //-----------Zeit ausgeben von DS3231-----------------------------------
  if (millis() - minutenablauf >= eineminute) { // Eine Minute abgelaufen?
    zeigeZeit(); // Zeit ausgeben
  }
  //----------Analogen Eingang auslesen-----------------------------------
  a0 = analogRead (ANALOG_PIN);
  a0 = map(a0, 0, 1023, 25, 254);
  if ((a0 > a0alt+2)||(a0 < a0alt-2)) {
    //------Potiwert auf PWM Ausgang ausgeben-----------------------------
    analogWrite (PWM_PIN1, a0);                       // Analogwert Ausgabe an PWM Pin.11
    analogWrite (PWM_PIN2, a0);                       // Analogwert Ausgabe an PWM Pin.13
    analogWrite (PWM_PIN3, a0);                       // Analogwert Ausgabe an PWM Pin.9
    lcd.setCursor (11, 3);                            // Zeile 4
    lcd.print (F("    "));
    lcd.setCursor (11, 3);
    lcd.print (a0);
    a0alt = a0;
  }
  //-----------Taster01 abfragen--------------------------------------------
  if (millis() - Sekundenablauf01 >= Pausezeit01) { // 200msec abgelaufen?
    Tasterstatus01 = digitalRead(Taster01);         // Pin von Taster01 abfragen
    if (Tasterstatus01 == LOW) {                    // Ist Taster01 gedrueckt?
      Tastenmerker01 = !Tastenmerker01;             // Merken dass Taster01 gedrueckt wurde
      lcd.setCursor (10, 1);                        // Ins Display Zeile 2 links schreiben
      lcd.print (Tastenmerker01);
      Sekundenablauf01 = millis();                  // Die 200ms neu starten
      tone(tonPin, frequenz, tonZeit);              // Bestätigungston für Tastendruck ausgeben
    }
  }
  //-----------Taster02 abfragen--------------------------------------------
  if (millis() - Sekundenablauf02 >= Pausezeit02) { // 200msec abgelaufen?
    Tasterstatus02 = digitalRead(Taster02);         // Pin von Taster02 abfragen
    if (Tasterstatus02 == LOW) {                    // Ist Taster02 gedrueckt?
      Tastenmerker02 = !Tastenmerker02;             // Merken dass Taster02 gedrueckt wurde
      lcd.setCursor (19, 1);                        // Ins Display Zeile 2 rechts schreiben
      lcd.print (Tastenmerker02);
      Sekundenablauf02 = millis();                  // Die 200ms neu starten
      tone(tonPin, frequenz, tonZeit);              // Bestätigungston für Tastendruck ausgeben
    }
  }

  //-------------Ausgang01 schalten-------------------------------------------
  // Alle 3 Sekunden 2100 Microsekunden
  if (millis() - Sekundenablauf03 >= Pausezeit03) { // 3000msec abgelaufen?
    Ausgangsstatus01 = ! Ausgangsstatus01;          // Status wechseln
    digitalWrite (Ausgang01, Ausgangsstatus01);     // Ausgang01 Relais umschalten
    lcd.setCursor (10, 2);                          // Zeile 3
    lcd.print (Ausgangsstatus01);
    Sekundenablauf03 = millis();
  }

  //-------------Ausgang02 schalten-------------------------------------------
  // Jede Sekunde 2100 Microsekunden
  if (millis() - Sekundenablauf04 >= Pausezeit04) { // 1000msec abgelaufen?
    Ausgangsstatus02 = ! Ausgangsstatus02;          // Status wechseln
    digitalWrite (Ausgang02, Ausgangsstatus02);     // Ausgang02 Relais umschalten
    lcd.setCursor (19, 2);                          // Zeile 3
    lcd.print (Ausgangsstatus02);
    Sekundenablauf04 = millis();
  }
  // Zeitmessung für einen Programm Durchlauf und Ausgabe des Wertes
  // Mit Serial.print() sieht man die Laufzeiten des Programmes in MicroSekunden
    Stoppzeit = micros();
    //Serial.print("Laufzeit= ");
    //Serial.println(Stoppzeit - Startzeit);
}
//=======================Loop Ende============================================================================​==
//---------------Erweiterung für die DS3132---------------------------------------------------------------------
void einstellenDS3231zeit(byte sekunde, byte minute, byte stunde, byte wochentag, byte tag, byte monat, byte jahr)
{
  // Datum und Uhrzeit einstellen
  Wire.beginTransmission(DS3231_ADDRESSE);
  Wire.write(0);
  Wire.write(decToBcd(sekunde)); // Sekunden einstellen
  Wire.write(decToBcd(minute)); // Minuten einstellen
  Wire.write(decToBcd(stunde));
  Wire.write(decToBcd(wochentag)); // 1=Sonntag ... 7=Samstag
  Wire.write(decToBcd(tag));
  Wire.write(decToBcd(monat));
  Wire.write(decToBcd(jahr)); // 0...99
  Wire.endTransmission();
}
//--------------------------Die Zeit auslesen------------------------------------------------------------------
// jede Minute etwa 5000 Microsekunden
void leseDS3231zeit(byte *sekunde, byte *minute, byte *stunde, byte *wochentag, byte *tag, byte *monat, byte *jahr)
{
  Wire.beginTransmission(DS3231_ADDRESSE);
  Wire.write(0); // DS3231 Register zu 00h
  Wire.endTransmission();
  Wire.requestFrom(DS3231_ADDRESSE, 7); // 7 Byte Daten vom DS3231 holen
  *sekunde = bcdToDec(Wire.read() & 0x7f);
  *minute = bcdToDec(Wire.read());
  *stunde = bcdToDec(Wire.read() & 0x3f);
  *wochentag = bcdToDec(Wire.read());
  *tag = bcdToDec(Wire.read());
  *monat = bcdToDec(Wire.read());
  *jahr = bcdToDec(Wire.read());
}
//---------------------------Die Zeit anzeigen----------------------------------------------------------------
// jede Minute etwa 15000 Microsekunden
void zeigeZeit() {
  byte sekunde, minute, stunde, wochentag, tag, monat, jahr, minuteAlt;
  leseDS3231zeit(&sekunde, &minute, &stunde, &wochentag, &tag, &monat, &jahr);   // Daten vom DS3231 holen
  if ((minute > minuteAlt) || (minute == 0)) {
    switch (wochentag) {
      case 1:
        lcd.setCursor(0, 0);
        lcd.print(F("Mo "));
        break;
      case 2:
        lcd.setCursor(0, 0);
        lcd.print(F("Di "));
        break;
      case 3:
        lcd.setCursor(0, 0);
        lcd.print(F("Mi "));
        break;
      case 4:
        lcd.setCursor(0, 0);
        lcd.print(F("Do "));
        break;
      case 5:
        lcd.setCursor(0, 0);
        lcd.print(F("Fr "));
        break;
      case 6:
        lcd.setCursor(0, 0);
        lcd.print(F("Sa "));
        break;
      case 7:
        lcd.setCursor(0, 0);
        lcd.print(F("So "));
        break;
      default:
        break;
    }
    if (tag < 10) {
      lcd.print(F("0"));
    }
    lcd.print(tag); // ausgeben T.M.J H:M:S
    lcd.print(F("."));
    if (monat < 10) {
      lcd.print(F("0"));
    }
    lcd.print(monat);
    lcd.print(F("."));
    lcd.print(jahr);
    lcd.print(F(" um "));
    if (stunde < 10) {
      lcd.print(F("0"));
    }
    lcd.print(stunde, DEC); // byte in Dezimal zur Ausgabe
    lcd.print(F(":"));
    if (minute < 10) {
      lcd.print("0");
    }
    lcd.print(minute, DEC);
    minuteAlt = minute;
    // Bestimmen wann wieder eine Minute um
    minutenablauf = millis();
    eineminute = (60 - sekunde) * 1000UL;
  }
}
byte decToBcd(byte val) {
  // Dezimal Zahl zu binary coded decimal (BCD) umwandeln
  return ((val / 10 * 16) + (val % 10));
}
byte bcdToDec(byte val) {
  // BCD (binary coded decimal) in Dezimal Zahl umwandeln
  return ((val / 16 * 10) + (val % 16));
}
[/code]

https://www.youtube.com/watch?v=Fnzn85oWM_Q
Hier was zum Thema Deutsche Politik Angry
Und hier zum Thema richtige Politik Big Grin
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.01.2021, 10:41
Beitrag #7
RE: Frage zu Delay-Alternative
(15.01.2021 10:35)Franz54 schrieb:  Ich habe hier ein Programm,
Wo ist hier?

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.01.2021, 10:58 (Dieser Beitrag wurde zuletzt bearbeitet: 15.01.2021 11:08 von Franz54.)
Beitrag #8
RE: Frage zu Delay-Alternative
Ohhh, danke für die Erinnerung, ich hab´s geändert. Big Grin

In dem Programm stehen so Bemerkungen wie
// jede Minute etwa 5000 microsekunden
Das heißt nur, dass der Programmteil in der Minute einmal durchlaufen wird, und für den Durchlauf etwa 5000 Microsekunden in Anspruch nimmt.

https://www.youtube.com/watch?v=Fnzn85oWM_Q
Hier was zum Thema Deutsche Politik Angry
Und hier zum Thema richtige Politik Big Grin
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
Question Alternative Serial.readString() xrzr91 5 429 12.03.2021 15:08
Letzter Beitrag: Tommy56
  Anfänger Frage zu code Beispiel peter_schmieg 4 480 03.03.2021 12:24
Letzter Beitrag: Tommy56
  4 mal Blink ohne Delay Blende8 2 389 02.03.2021 18:36
Letzter Beitrag: Blende8
  von delay auf millis umgestellt, klappt nur nicht. Servo Geschwindigkeit einstellen. gutschy 8 668 21.02.2021 15:22
Letzter Beitrag: gutschy
  grundelegende Frage: int vs const int mhoeting 4 389 27.01.2021 14:37
Letzter Beitrag: mhoeting
  Füllstand mit RGB visualisieren [FRAGE] Dukopfo 3 448 27.12.2020 13:53
Letzter Beitrag: Tommy56
  Weiches Auf- und Abblenden mit delay vs millis() do1xxy 24 1.415 23.12.2020 14:45
Letzter Beitrag: Franz54
  Servos ohne delay juergen001 23 2.287 30.10.2020 16:49
Letzter Beitrag: MicroBahner
  Frage zur <Adafruit_PWMServoDriver.h> Christian_Moba-Arduino 7 737 16.10.2020 12:32
Letzter Beitrag: Tommy56
  Generelle Frage zum Schlafen legen DO3GE 3 596 02.10.2020 10:56
Letzter Beitrag: Tommy56

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste