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
Lauflicht mit Interrupt
04.12.2019, 22:39
Beitrag #9
RE: Lauflicht mit Interrupt
@Gorathan
Deinen Code finde ich sehr interessant, nun würde ich Ihn gerne besser verstehen. könntest du mir dabei vielleicht helfen ?

Code:
nowMillis = millis();
  speed = analogRead(POTI_PIN);
  switchState = digitalRead(SWITCH_PIN);
  if (switchState != oldState && nowMillis - switchMillis > 30) {
    switchMillis = nowMillis;
if (!switchState) direction = -direction;
    oldState = switchState;
Hier definiertst du die Zeit
dann liesst du den Poti aus und danach wird der Schalter ausgewertet soweit klar was bedeuten die switchMillis > 30
Die Anweisung direction ist mir leider auch nicht klar was damit bewirkt wird.

Code:
if (nowMillis - stepMillis > speed) {
    stepMillis = nowMillis;
    digitalWrite(LED_PINS[index], LOW);
    index += direction;
    if (index == LED_COUNT) index = 0;
    if (index < 0) index = LED_COUNT - 1;
    digitalWrite(LED_PINS[index], HIGH);

In dem Teil legst du die Geschwindkeit feste dann werden die LED``s geschrieben auf LOW soweit klar, dann komm ich leider nicht weiter.

Meine Idee wäre es eventuell mit einem 2. Taster noch einen weiteren Effekt ein zu bauen nämlich, das die LED`s nach einander an gehen D2-D7 und erst abschalten wenn alle an sind.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.12.2019, 08:03
Beitrag #10
RE: Lauflicht mit Interrupt
Ich habe Dir mal ein Beispiel mit 10 verschiedenen Programmen erstellt und ausführlich kommentiert:
Code:
const uint8_t LED_PINS[] = {2, 3, 4, 5, 6, 7, 8, 9}; // an D2...D9 sind die LEDs angeschlossen (max. 8 LEDs)
const uint8_t LED_COUNT = sizeof(LED_PINS); // die Anzahl der LEDs ermitteln
const uint8_t POTI_PIN = A4; // am Pin A4 liegt der Mittelanschluss des Potis (10kOhm), aussen +5V und GND
const uint8_t DIR_PIN = 12; // am Pin D12 ist ein Taster nach GND angeschlossen (fuer die Laufrichtung)
const uint8_t PROG_PIN = A5; // am Pin A5 ist ein Taster nach GND angeschlossen (fuer die Programmauswahl)

// die maximale Anzahl der Schritte pro Programm
const byte MAX_COUNT = 30;

// Ein 2D-Array fuer die LED-Programme im Binaerformat (1 Byte pro Schritt)
// Beispiel: "B10000000" entspricht der linken LED, "B00000001" entspricht der rechten LED
// PROGRAM[x][0] = Anzahl der Schritte/Bytes fuer das Programm
const uint8_t PROGRAM[][MAX_COUNT + 1] = {
  { // Programm 0
    9,
    B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001, B00000000
  },
  { // Programm 1
    11,
    B10000000, B11000000, B11100000, B01110000, B00111000, B00011100, B00001110, B00000111, B00000011, B00000001,
    B00000000
  },
  { // Programm 2
    23,
    B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001, B00000011, B00000111,
    B00001111, B00011111, B00111111, B01111111, B11111111, B11111110, B11111100, B11111000, B11110000, B11100000,
    B11000000, B10000000, B00000000
  },
  { // Programm 3
    20,
    B10000000, B11000000, B11100000, B01110000, B00111000, B00011100, B00001110, B00000111, B00000011, B00000001,
    B00000001, B00000011, B00000111, B00001110, B00011100, B00111000, B01110000, B11100000, B11000000, B10000000
  },
  { // Programm 4
    15,
    B10000000, B01000000, B10100000, B01010000, B10101000, B01010100, B10101010, B01010101, B00101010, B00010101,
    B00001010, B00000101, B00000010, B00000001, B00000000
  },
  { // Programm 5
    16,
    B10000000, B11000000, B11100000, B11110000, B11111000, B11111100, B11111110, B11111111, B01111111, B00111111,
    B00011111, B00001111, B00000111, B00000011, B00000001, B00000000
  },
  { // Programm 6
    15,
    B10000000, B11000000, B11100000, B11110000, B01110000, B00110000, B00010000, B00001000, B00001100, B00001110,
    B00001111, B00000111, B00000011, B00000001, B00000000
  },
  { // Programm 7
    8,
    B10000001, B11000011, B11100111, B11111111, B11100111, B11000011, B10000001, B00000000
  },
  { // Programm 8
    2,
    B10101010, B01010101
  },
  { // Programm 9
    8,
    B10001000, B11001100, B01100110, B00110011, B00010001, B00110011, B01100110, B11001100
  }
};
const uint8_t PROG_COUNT = 10; // die Anzahl der Programme festlegen

uint8_t progNr = 0; // zum merken der ausgewaehlten Programmnummer
uint8_t index = 1; // index dient zum durchzaehlen der Programmschritte
int8_t direction = 1; // direction wird fuer die Laufrichtung verwendet (1 = vorwaerts, -1 = rueckwaerts)
uint16_t speed = 0; // speed wird vom Poti ausgelesen (0...1023) und entspricht dann den Millisekunden zwischen den Schritten
uint32_t nowMillis, stepMillis, dirMillis, progMillis;
bool dirState = HIGH, dirOldState = HIGH;
bool progState = HIGH, progOldState = HIGH;

void setLEDs(const uint8_t bits) {
  for (uint8_t i = 0; i < LED_COUNT; i++) {
    digitalWrite(LED_PINS[i], (bits << i) & 0x80);
  }
}

void setup() {
  Serial.begin(115200);
  for (uint8_t i = 0; i < LED_COUNT; i++) {
    pinMode(LED_PINS[i], OUTPUT);
  }
  pinMode(POTI_PIN, INPUT);
  pinMode(DIR_PIN, INPUT_PULLUP);
  pinMode(PROG_PIN, INPUT_PULLUP);
  Serial.print(F("Programm: "));
  Serial.println(progNr);
  Serial.print(F("Richtung: "));
  Serial.println(direction == 1 ? F("vorwaerts") : F("rueckwaerts"));
  setLEDs(PROGRAM[progNr][index]);
  stepMillis = millis();
}

void loop() {
  nowMillis = millis(); // die aktuellen Millisekunden holen
  
  // jeder Taster prellt beim betaetigen (Mehrfachausloesung). Hier werden dafuer 30ms beruecksichtigt.
  dirState = digitalRead(DIR_PIN); // den Zustand des Tasters auslesen (HIGH = nicht gedrueckt, wegen INPUT_PULLUP)
  if (dirState != dirOldState && nowMillis - dirMillis > 30) { // nur wenn sich der Zustand geaendert hat und die Prellzeit um ist
    dirMillis = nowMillis; // die Millisekunden seit dem Tastendruck in dirMillis merken
    if (!dirState) { // wenn Taste == LOW (gedrueckt)
      direction = -direction; // dann die Laufrichtung umdrehen (1 oder -1)
      Serial.print(F("Richtung: "));
      Serial.println(direction == 1 ? F("vorwaerts") : F("rueckwaerts"));
    }
    dirOldState = dirState; // den letzten Tastenzustand in dirOldState merken
  }
  progState = digitalRead(PROG_PIN); // den Zustand des Tasters auslesen (HIGH = nicht gedrueckt, wegen INPUT_PULLUP)
  if (progState != progOldState && nowMillis - progMillis > 30) { // nur wenn sich der Zustand geaendert hat und die Prellzeit um ist
    progMillis = nowMillis; // die Millisekunden seit dem Tastendruck in progMillis merken
    if (!progState) { // wenn Taste == LOW (gedrueckt)
      progNr++; // dann die Programmnummer um eins erhoehen
      if (progNr > PROG_COUNT - 1) progNr = 0; // wenn die Programmnummer groesser als die Anzahl der Programme ist, bei Null weitermachen
      Serial.print(F("Programm: "));
      Serial.println(progNr);
    }
    progOldState = progState; // den letzten Tastenzustand in progOldState merken
  }

  speed = analogRead(POTI_PIN); // den Wert vom Poti auslesen (10 Bit = 0...1023)
  if (nowMillis - stepMillis > speed) { // wenn die Zeit, seit dem letzten erhoehen des Index, groesser als der Wert vom Poti
    stepMillis = nowMillis; // die Millisekunden in stepMillis merken
    index += direction; // index um eins erhoehen bzw. erniedrigen (je nach Wert von direction)
    // im ersten Element des 2D-Arrays "PROGRAM[progNr][0]" steht die Anzahl der Schritte
    if (index > PROGRAM[progNr][0]) index = 1; // wenn index groesser als die Anzahl der Schritte, dann wieder bei Eins beginnen
    if (index < 1) index = PROGRAM[progNr][0]; // wenn index kleiner als Eins, dann wieder mit dem hoechsten Wert beginnen
    setLEDs(PROGRAM[progNr][index]); // die LEDs entsprechend der Bits fuer diesen Schritt ein-/ausschalten
  }
}


Angehängte Datei(en)
.zip  Lauflicht_328P.zip (Größe: 2,12 KB / Downloads: 15)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.12.2019, 19:40
Beitrag #11
RE: Lauflicht mit Interrupt
Wau, Super danke für deine Mühe und Hilfe. Das hast du toll gemacht jetzt verstehe ich einiges besser.
Was ich nicht ganz verstehe ist das man den Taster nochmals über die Millis entprellt dafür ist doch eigentlich schon der Pullup oder Hardware Widerstand (10KOhm) zuständig.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.12.2019, 19:46
Beitrag #12
RE: Lauflicht mit Interrupt
Nein. Der ist dafür da, bei offenem Taster einen definierten Zustand sicher zu stellen.

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
05.12.2019, 19:47
Beitrag #13
RE: Lauflicht mit Interrupt
(05.12.2019 19:40)senseman schrieb:  Wau, Super danke für deine Mühe und Hilfe. Das hast du toll gemacht jetzt verstehe ich einiges besser.
Was ich nicht ganz verstehe ist das man den Taster nochmals über die Millis entprellt dafür ist doch eigentlich schon der Pullup oder Hardware Widerstand (10KOhm) zuständig.

...die Widerstände ob intern oder extern haben mit dem Entprellen nichts zu tun...die sind nur dazu da definierte Eingangspegel zu ermöglichen. Zum entprellen benötigt es weitere Hardware oder eben Software.
lgbk

1+1 = 10 Angel ...und ich bin hier nicht der Suchmaschinen-Ersatz Dodgy...nur mal so als genereller Tipp..
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.12.2019, 21:48
Beitrag #14
RE: Lauflicht mit Interrupt
Ahh, jetzt verstanden, anstatt einen Kondensator zum entprellen am Taster zu nutzen nimmt man eine Zeit also 30Millis um den Taster zu entprellen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.12.2019, 22:07
Beitrag #15
RE: Lauflicht mit Interrupt
Genau. Wobei auch einfache Taster durchaus schon mit 10-15 ms ausgeprellt haben.

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
05.12.2019, 22:34 (Dieser Beitrag wurde zuletzt bearbeitet: 05.12.2019 22:35 von senseman.)
Beitrag #16
RE: Lauflicht mit Interrupt
Da wäre dann die Frage wie definieret man einen einfachen Taster ? Ich gehe mal von den Billig haimer aus ala. denen die z.b. auf den Shields verbaut sind (bsp.: https://www.reichelt.de/printtaster-12-v...stct=pol_2)
Weiter wäre von Interesse was macht es für einen Unterschied 10-15Millis oder 30Millis. wäre wohl Programm abhängig.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  for-schleife, delay, millis, interrupt Harry 8 566 31.03.2020 21:02
Letzter Beitrag: Harry
Question deepsleep 433Mhz Interrupt Marc2014 15 690 28.03.2020 13:30
Letzter Beitrag: hotsystems
Question Lauflicht Spezial Charlie 7 449 25.03.2020 00:23
Letzter Beitrag: senseman
  Lauflicht mit externem Takt Manny 21 1.581 02.03.2020 12:36
Letzter Beitrag: Harry
Question Lauflicht mit zufälligem Stop Platinum 5 448 20.02.2020 20:07
Letzter Beitrag: Tommy56
  Loop-Teil mit Interrupt für bestimmte Zeit stoppen Alter Fritz 11 1.145 23.12.2019 23:10
Letzter Beitrag: hotsystems
  AT90CAN Interrupt wird nicht ausgelöst slsb02 5 705 19.11.2019 15:04
Letzter Beitrag: slsb02
  Interrupt vs. LCD Nasenbär 10 1.437 22.08.2019 16:30
Letzter Beitrag: @Thomas
  RGB LED Lauflicht per Taster unterbrechen AC_DC_new 28 4.907 05.08.2018 19:16
Letzter Beitrag: AC_DC_new
  Lauflicht mit Kontrolle Golffahrer 13 2.956 13.05.2018 19:59
Letzter Beitrag: Tommy56

Gehe zu:


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