Arduino und ein LED Band ansteuern?

Ah jetzt geht es hier mit:

}
  if (_ABVAR_1_LDR > 300 && ( digitalRead(4)) ){
    {
      zielwert = 255;
    }
  } else {
    zielwert = 0;
  }
  dimmen(zielwert);
}

Hängt wohl zusammen das PIR 5 und 6 nicht angeschlossen sind,
wusste nicht das die dafür dran sein müssten.

Ah und Dein Beispiel funktioniert sehr schön, richtig klasse.
PIR5 und 6 sind da auch erst raus.

Danke Dir für die mühe!!! Versuche dann meine Sketches zusammen zusetzen.

Gruß

power-dodge:
Hängt wohl zusammen das PIR 5 und 6 nicht angeschlossen sind,
wusste nicht das die dafür dran sein müssten.

Du hattest möglicherweise diese Bemerkung überlesen:

agmue:
... wenn ich alle digitalen Eingänge auf LOW lege, ...

Das liegt an INPUT_PULLUP, also unbeschaltet HIGH.

agmue:
Danke Dir für die mühe!!!

Bitte gerne :slight_smile:

Moin,

mir ist folgendes aufgefallen bei Deinem Beispiel:

Wenn der PIR nicht auslöst leuchtet das Band auf 20.
Löst der PIR aus fadet er hoch auf 255.

Aber jetzt wenn ich in dem PIR bleibe und mich bewege,
fadet es trotzdem runter auf 20, erneutes auslösen über PIR ist
etwa in 1 oder 2 Sekunden erst möglich.

Egal wie lange die Zeit bei dem PIR eingestellt ist (am Poti)
nach der Zeit und Bewegung in dem PIR fadet er runter.

Normalerweise soll es runter faden wenn keine Bewegung registriert wird.

Ist es ein Soft oder Hardware Problem?

Edit:

Sieht wohl nach Hardware aus, mit dem Code das selbe.
1 oder 2 Sekunden dann erst löst er aus:

    /*
     * PIR sensor tester
     */
     
    int ledPin = 3;                // choose the pin for the LED
    int inputPin = 4;               // choose the input pin (for PIR sensor)
    int pirState = LOW;             // we start, assuming no motion detected
    int val = 0;                    // variable for reading the pin status
     
    void setup() {
      pinMode(ledPin, OUTPUT);      // declare LED as output
      pinMode(inputPin, INPUT);     // declare sensor as input
     
      Serial.begin(9600);
    }
     
    void loop(){
      val = digitalRead(inputPin);  // read input value
      if (val == HIGH) {            // check if the input is HIGH
        digitalWrite(ledPin, HIGH);  // turn LED ON
        if (pirState == LOW) {
          // we have just turned on
          Serial.println("Motion detected!");
          // We only want to print on the output change, not state
          pirState = HIGH;
        }
      } else {
        digitalWrite(ledPin, LOW); // turn LED OFF
        if (pirState == HIGH){
          // we have just turned of
          Serial.println("Motion ended!");
          // We only want to print on the output change, not state
          pirState = LOW;
        }
      }
    }

Gruß

power-dodge:
Normalerweise soll es runter faden wenn keine Bewegung registriert wird.

Du beschreibst ein retriggerbares Monoflop, das Dein PIR wohl nicht hat.

power-dodge:
Sieht wohl nach Hardware aus,

Gut analysiert, dann muß es halt in die weiche Ware:

const byte pinLED = 3, pinPIR1 = 4, pinPIR2 = 5, pinPIR3 = 6, pinLDR = A0;
const uint16_t helligkeitsschwelle = 300, hysterese = 50;
uint16_t aktLDR, altLDR;
const uint32_t intervallMessen = 1000, intervallDimmen = 5, minEinZeit = 5000;
uint32_t aktMillis, altMillisMessen, einMillis;
bool aktPIR, altPIR;
const byte zielwertMin = 20;
byte zielwert;

void setup()
{
  pinMode( pinPIR3, INPUT_PULLUP);
  pinMode( pinPIR2, INPUT_PULLUP);
  pinMode( pinPIR1, INPUT_PULLUP);
  pinMode( pinLED, OUTPUT);
  Serial.begin(9600);
  Serial.println("Anfang");
}

void loop() {
  aktMillis = millis();
  altPIR = aktPIR;
  aktPIR = digitalRead(pinPIR1) ||  digitalRead(pinPIR2) || digitalRead(pinPIR3);
  if (aktMillis - altMillisMessen >= intervallMessen) {
    altMillisMessen = aktMillis;
    aktLDR = analogRead(pinLDR) ;
    Serial.print("LDR ");
    Serial.print(aktLDR);
    Serial.println();
  }
  if (aktLDR > helligkeitsschwelle) {
    if ( altPIR != aktPIR ) {  // positive Signalflanke
      einMillis = aktMillis;
    }
    if (aktPIR) {
      zielwert = 255;
    } else {
      zielwert = zielwertMin;
    }
  }
  if (aktLDR < helligkeitsschwelle - hysterese) {
    zielwert = 0;
  }
  if (aktMillis - einMillis < minEinZeit) {
    zielwert = 255;
  }
  dimmen(zielwert);
}

void dimmen(byte ziel) {
  static uint32_t altMillisDimmen;
  static byte fade = 0;
  if (aktMillis - altMillisDimmen >= intervallDimmen) {
    altMillisDimmen = aktMillis;
    if (fade < ziel) {
      fade++;
      Serial.print("fade ");
      Serial.println(fade);
    }
    if (fade > ziel) {
      fade--;
      Serial.print("fade ");
      Serial.println(fade);
    }
    analogWrite(pinLED, fade);
  }
}

Nach Reset wird zunächst auf 255 gedimmt, bitte nicht wundern. Wenn Dich das stört, Abhilfe durch:

uint32_t aktMillis, altMillisMessen, einMillis = -minEinZeit;

Ich hoffe, das harmoniert nun mit Deinen PIRs :slight_smile:

Hallo,

konnte gerade es testen. Das funktioniert wirklich prächtig.
Du bist echt klasse und auch so Hilfsbereit.
Ich mit meinem Kenntnisstand, hätte es nie so gut hinbekommen.

Einen herzlichen Dankeschön Dir.

Versuche später die Scethes zu verheiraten, da kommt bestimmt
was an blöden Fragen von mir.

Danke noch mal :slight_smile:

Die LDR- und RTC-Logik, noch ohne RTC, habe ich verändert:

const byte pinLED = 3, pinPIR1 = 4, pinPIR2 = 5, pinPIR3 = 6, pinLDR = A0, pinZeit = 7;
const uint16_t helligkeitsschwelle = 300, hysterese = 50;
uint16_t aktLDR;
const uint32_t intervallMessen = 1000, intervallDimmen = 5, minEinZeit = 5000;
uint32_t aktMillis, altMillisMessen, einMillis = -minEinZeit;
bool aktPIR, altPIR, zeitspanne;
const byte zielwertMin1 = 20, zielwertMin2 = 150, zielwertMax = 155;
enum {AUS, MIN, MAX};
byte dimmStatus = AUS;

void setup()
{
  pinMode( pinPIR3, INPUT_PULLUP);
  pinMode( pinPIR2, INPUT_PULLUP);
  pinMode( pinPIR1, INPUT_PULLUP);
  pinMode( pinZeit, INPUT_PULLUP);  // nur zum Testen ohne RTC
  pinMode( pinLED, OUTPUT);
  Serial.begin(9600);
  Serial.println("Anfang");
}

void loop() {
  aktMillis = millis();
  altPIR = aktPIR;
  aktPIR = digitalRead(pinPIR1) ||  digitalRead(pinPIR2) || digitalRead(pinPIR3);
  if (aktMillis - altMillisMessen >= intervallMessen) {
    altMillisMessen = aktMillis;
    zeitspanne = zeit();
    aktLDR = analogRead(pinLDR) ;
    Serial.print("LDR ");
    Serial.print(aktLDR);
    Serial.print("\tZeitspanne ");
    Serial.print(zeitspanne);
    Serial.println();
  }
  if (aktLDR > helligkeitsschwelle) {
    if ( altPIR != aktPIR ) {  // positive Signalflanke
      einMillis = aktMillis;
    }
    if (aktPIR) {
      dimmStatus = MAX;
    } else {
      dimmStatus = MIN;
    }
  }
  if (aktLDR < helligkeitsschwelle - hysterese) {
    dimmStatus = AUS;
  }
  if (aktMillis - einMillis < minEinZeit) {
    dimmStatus = MAX;
  }
  dimmen(dimmStatus, aktLDR, zeitspanne);
}

bool zeit() {  // nur zum Testen ohne RTC
  return digitalRead(pinZeit);
}

/*
 * hell -> LED aus, PIR ohne Funktion
 * dunkel - innerhalb Zeitspanne -> LED = Helligkeit von Wert des LDR, mit PIR LED=155
 * dunkel - außerhalb Zeitspanne -> LED 0, mit PIR 155
 */
void dimmen(byte status, uint16_t helligkeit, bool zspanne) {
  static uint32_t altMillisDimmen;
  static byte fade = 0;
  byte ziel = 0;

  if (aktMillis - altMillisDimmen >= intervallDimmen) {
    altMillisDimmen = aktMillis;
    switch (status) {
      case AUS:
        ziel = 0;
        break;
      case MIN:
        if (zspanne) {
          ziel = map(helligkeit, helligkeitsschwelle, 1023, zielwertMin2, zielwertMin1);
        } else {
          ziel = 0;
        }
        break;
      case MAX:
        ziel = zielwertMax;
        break;
    }
    if (fade < ziel) {
      fade++;
      Serial.print("fade ");
      Serial.println(fade);
    }
    if (fade > ziel) {
      fade--;
      Serial.print("fade ");
      Serial.println(fade);
    }
    analogWrite(pinLED, fade);
  }
}

Hallo,

oh vielen Dank für den Scetch. Denn kann ich erst morgen testet.
Der sieht ja gut aus, so würde ich es nie schaffen. Da muss man echt viel im Kopf haben gleichzeitig. Ich staune immer über Deine Fähigkeiten, echt Respekt dafür.

Gruß

Hallo,

hab eben ausprobiert funktioniert wie es soll.
(Denke ich)

Da die mit der Zeitsteuerung Helligkeit und LDR nicht zu testen ist.
(Oder?)
Ah irgendwie doch auf Pin 7 Sitzt ein PIR und der löst es aus und die Helligkeit
lässt sich über LDR ändern.
Ist echt nice.

Danke für ein weiteres Update

Gruß

power-dodge:
Ah irgendwie doch auf Pin 7 Sitzt ein PIR und der löst es aus und die Helligkeit
lässt sich über LDR ändern.

Kein PIR, nur ein Schalter, um die Funktionalität ohne RTC zu testen.

Ja da saß ja der 4te PIR bereits, der ist für den 2 kreis um Pin 9 anzusteuern.
Da soll es nur an und aus in fade gehen.

Der löst aber auch die Zeitspanne aus :wink:

Bin gerade am herum kopieren um den 2 Kreis dazu zu bekommen,
gerade klappt es noch nicht.

Anstelle von Pin 7 kannst Du auch A3 nehmen, irgendeinen freien halt.

Das konnte ich ja an der Stelle auf dem Pin 7 mit dem PIR testen.

Klappt nicht so wie ich mir das dachte:

const byte pinLED = 3, pinLED2 = 9, pinPIR1 = 4, pinPIR2 = 5, pinPIR3 = 6, pinPIR4 =7, pinLDR = A0, pinZeit = 8;
const uint16_t helligkeitsschwelle = 300, hysterese = 50;
uint16_t aktLDR;
const uint32_t intervallMessen = 1000, intervallDimmen = 5, minEinZeit = 5000;
uint32_t aktMillis, altMillisMessen, einMillis = -minEinZeit;
bool aktPIR, altPIR, zeitspanne;
const byte zielwertMin1 = 20, zielwertMin2 = 150, zielwertMax = 155;
enum {AUS, MIN, MAX};
byte dimmStatus = AUS;

void setup()
{
  pinMode( pinPIR3, INPUT_PULLUP);
  pinMode( pinPIR2, INPUT_PULLUP);
  pinMode( pinPIR1, INPUT_PULLUP);
  pinMode( pinZeit, INPUT_PULLUP);  // nur zum Testen ohne RTC
  pinMode( pinLED, OUTPUT);
  Serial.begin(9600);
  Serial.println("Anfang");
}

void loop() {
  aktMillis = millis();
  altPIR = aktPIR;
  aktPIR = digitalRead(pinPIR1) ||  digitalRead(pinPIR2) || digitalRead(pinPIR3);
  if (aktMillis - altMillisMessen >= intervallMessen) {
    altMillisMessen = aktMillis;
    zeitspanne = zeit();
    aktLDR = analogRead(pinLDR) ;
    Serial.print("LDR ");
    Serial.print(aktLDR);
    Serial.print("\tZeitspanne ");
    Serial.print(zeitspanne);
    Serial.println();
  }
  if (aktLDR > helligkeitsschwelle) {
    if ( altPIR != aktPIR ) {  // positive Signalflanke
      einMillis = aktMillis;
    }
    if (aktPIR) {
      dimmStatus = MAX;
    } else {
      dimmStatus = MIN;
    }
  }
  if (aktLDR < helligkeitsschwelle - hysterese) {
    dimmStatus = AUS;
  }
  if (aktMillis - einMillis < minEinZeit) {
    dimmStatus = MAX;
  }
  dimmen(dimmStatus, aktLDR, zeitspanne);
}

bool zeit() {  // nur zum Testen ohne RTC
  return digitalRead(pinZeit);
}

void loop() {
  aktMillis = millis();
  altPIR = aktPIR;
  aktPIR = digitalRead(pinPIR7);
  if (aktMillis - altMillisMessen >= intervallMessen) {
    altMillisMessen = aktMillis;
    zeitspanne = zeit();
    aktLDR = analogRead(pinLDR) ;
    Serial.print("LDR ");
    Serial.print(aktLDR);
    Serial.print("\tZeitspanne ");
    Serial.print(zeitspanne);
    Serial.println();
  }
  if (aktLDR > helligkeitsschwelle) {
    if ( altPIR != aktPIR ) {  // positive Signalflanke
      einMillis = aktMillis;
    }
    if (aktPIR) {
      dimmStatus = MAX;
    } else {
      dimmStatus = MIN;
    }
  }
  if (aktLDR < helligkeitsschwelle - hysterese) {
    dimmStatus = AUS;
  }
  if (aktMillis - einMillis < minEinZeit) {
    dimmStatus = MAX;
  }
  dimmen(dimmStatus, aktLDR, zeitspanne);
}
/*
 * hell -> LED aus, PIR ohne Funktion
 * dunkel - innerhalb Zeitspanne -> LED = Helligkeit von Wert des LDR, mit PIR LED=155
 * dunkel - außerhalb Zeitspanne -> LED 0, mit PIR 155
 */
void dimmen(byte status, uint16_t helligkeit, bool zspanne) {
  static uint32_t altMillisDimmen;
  static byte fade = 0;
  byte ziel = 0;

  if (aktMillis - altMillisDimmen >= intervallDimmen) {
    altMillisDimmen = aktMillis;
    switch (status) {
      case AUS:
        ziel = 0;
        break;
      case MIN:
        if (zspanne) {
          ziel = map(helligkeit, helligkeitsschwelle, 1023, zielwertMin2, zielwertMin1);
        } else {
          ziel = 0;
        }
        break;
      case MAX:
        ziel = zielwertMax;
        break;
    }
    if (fade < ziel) {
      fade++;
      Serial.print("fade ");
      Serial.println(fade);
    }
    if (fade > ziel) {
      fade--;
      Serial.print("fade ");
      Serial.println(fade);
    }
    analogWrite(pinLED, fade);
  }
}

power-dodge:
Klappt nicht so wie ich mir das dachte:

Zweimal loop() geht auch nicht.

Danke, dort meckert ja er auch beim testen.

Muss dann die Tage noch mal ausprobieren.

Wird denn das ganze schwer in Jurs seine Zeitschaltuhr einzubinden?
Oder war von Dir es irgendwie anders gedacht.

Bin Dir echt super Dankbar für die Hilfe bis jetzt.
Eingentlich ist es nur 'noch' die Scatches zusammen zu bauen.
Aber das faden hast wirklich klasse hin bekommen, echt unglaublich.
Eine Libraries von Dir mit dem Scetch wäre denke ich sehr hilfreich für andere User.
Oder solche Anfänger wie mir.

Gruß

Update mit RTC:

#include <avr/pgmspace.h>
#include <Wire.h>  // include Wire library for I2C devices
#include "jursRTCtimeEasy.h" // include RTC time library

sTime localTime; // holds current time in local time (with regard to DST/summertime)
swTime_t switchTimes[] = { // define ON times
  {500, 530},
  {830, 900},
  {1200, 1230},
  {1530, 1600},
  {2053, 2055},
  {2230, 2300},
};
#define NUMSWITCHTIMES sizeof(switchTimes)/sizeof(switchTimes[0])

const byte pinLED = 3, pinPIR1 = 4, pinPIR2 = 5, pinPIR3 = 6, pinLDR = A0;
const uint16_t helligkeitsschwelle = 300, hysterese = 50;
uint16_t aktLDR;
const uint32_t intervallMessen = 1000, intervallDimmen = 5, minEinZeit = 5000;
uint32_t aktMillis, altMillisMessen, einMillis = -minEinZeit;
bool aktPIR, altPIR, zeitspanne;
const byte zielwertMin1 = 20, zielwertMin2 = 150, zielwertMax = 155;
enum {AUS, MIN, MAX};
byte dimmStatus = AUS;

void setup()
{
  pinMode( pinPIR3, INPUT_PULLUP);
  pinMode( pinPIR2, INPUT_PULLUP);
  pinMode( pinPIR1, INPUT_PULLUP);
  pinMode( pinLED, OUTPUT);
  Serial.begin(9600);
  Serial.println("Anfang");
  if (RTCinit()) Serial.println(F("RTC OK"));
  else Serial.println(F("RTC/I2C ERROR"));
}

void loop() {
  aktMillis = millis();
  altPIR = aktPIR;
  aktPIR = digitalRead(pinPIR1) ||  digitalRead(pinPIR2) || digitalRead(pinPIR3);
  if (aktMillis - altMillisMessen >= intervallMessen) {
    altMillisMessen = aktMillis;
    zeitspanne = zeit();
    aktLDR = analogRead(pinLDR) ;
    Serial.print("LDR ");
    Serial.print(aktLDR);
    Serial.print("  \tZeitspanne ");
    Serial.print(zeitspanne);
    Serial.print("\t");
    Serial.print(localTime.bDay);
    Serial.print(".");
    Serial.print(localTime.bMonth);
    Serial.print(".");
    Serial.print(localTime.iYear);
    Serial.print("  ");
    Serial.print(localTime.bHour);
    Serial.print(":");
    Serial.print(localTime.bMinute);
    Serial.print(":");
    Serial.print(localTime.bSecond);
    Serial.println();
  }
  if (aktLDR > helligkeitsschwelle) {
    if ( altPIR != aktPIR ) {  // positive Signalflanke
      einMillis = aktMillis;
    }
    if (aktPIR) {
      dimmStatus = MAX;
    } else {
      dimmStatus = MIN;
    }
  }
  if (aktLDR < helligkeitsschwelle - hysterese) {
    dimmStatus = AUS;
  }
  if (aktMillis - einMillis < minEinZeit) {
    dimmStatus = MAX;
  }
  dimmen(dimmStatus, aktLDR, zeitspanne);
}

bool zeit() {  // nur zum Testen ohne RTC
  RTCreadLocalTime(localTime); // read localTime so that 'time' is a local time
  return isOnTime(localTime, switchTimes, NUMSWITCHTIMES);
}

/*
 * hell -> LED aus, PIR ohne Funktion
 * dunkel - innerhalb Zeitspanne -> LED = Helligkeit von Wert des LDR, mit PIR LED=155
 * dunkel - außerhalb Zeitspanne -> LED 0, mit PIR 155
 */
void dimmen(byte status, uint16_t helligkeit, bool zspanne) {
  static uint32_t altMillisDimmen;
  static byte fade = 0;
  byte ziel = 0;

  if (aktMillis - altMillisDimmen >= intervallDimmen) {
    altMillisDimmen = aktMillis;
    switch (status) {
      case AUS:
        ziel = 0;
        break;
      case MIN:
        if (zspanne) {
          ziel = map(helligkeit, helligkeitsschwelle, 1023, zielwertMin2, zielwertMin1);
        } else {
          ziel = 0;
        }
        break;
      case MAX:
        ziel = zielwertMax;
        break;
    }
    if (fade < ziel) {
      fade++;
      Serial.print("fade ");
      Serial.println(fade);
    }
    if (fade > ziel) {
      fade--;
      Serial.print("fade ");
      Serial.println(fade);
    }
    analogWrite(pinLED, fade);
  }
}

power-dodge:
Wird denn das ganze schwer in Jurs seine Zeitschaltuhr einzubinden?

Aus meiner Perspektive nicht, da er es ordentlich aufgebaut hat und ich es konzeptionell vorbereitet hatte.

Die Datei jursRTCtimeEasy.h mußte ich leicht verändern, um Warnungen zu vermeiden, daher im Anhang.

Bin gespannt, ob Deine Hardware genauso arbeitet wie mein Steckbrett :slight_smile:

jursRTCtimeEasy.h (8.75 KB)

Hallo,

hey das ist ja genial. Funktioniert wie es soll.
Vielen vielen Dank dafür!

Muss dann noch schauen das der zusätzliche Kreis rein kommt.
Pin 7 PIR,und Pin 9 = LED. An aus mit fade, evtl. aber auch nicht auf volle Helligkeit.

:slight_smile: :slight_smile: :slight_smile: :slight_smile: so froh bin ich Grad.

Saß schon paar Wochen dran (ab und zu). Angefangen mit DCF77, dann mit Ethernet
und zu letzt mit RTC.
Aber es hackte meist am fade, wenn man deinen Code anschaut... Hätte ich es nie so hin bekommen.

Danke Danke Dir!!!

Hallo,

ne kurze Frage.
Funktioniert bei Jurs seiner Zeitschaltuhr die Sommer - Winterzeitumstellung?

Wenn ja, muss man was aktivieren etc.?

Gruß

power-dodge:
Wenn ja, muss man was aktivieren etc.?

Wenn ich die Funktionalität richtig verstanden habe, läuft die RTC immer auf Winterzeit. Im Sommer wird eine Stunde dazugezählt. Schaue mal bei summertimeEurope() und RTCreadLocalTime().

Ah danke,

wenn er es selber dazu rechnet. Reicht das volkommen aus. Würde völlig ausreichen.
Schaue mir die Bereiche bei gelegenheit an.

Gruß