Das Arduino-Quiz

Arduino IDE installieren

https://smarthomeyourself.de/anleitung-zum-selber-bauen/arduino-ide-installieren/

Treppen-Lauflicht mit Bewegungserkennung (Arduino)

Die elektronische Welt mit Arduino entdecken

Erik Bartmann

http://sites.schaltungen.at/arduino-uno-r3/arduino-entdecken

http://www.erik-bartmann.de/arduino-projekt-kapitel-7.html

http://archive.is/lwk4u

2 Schieberegister 74HC595 Anschließen - Arduino Forum

https://forum.arduino.cc/index.php?topic=93390.0

2 Schieberegister 74HC595 .

int dataPin = 11;    // Pin connected to DS of 74HC595
int clockPin = 12;  //Pin connected to SH_CP of 74HC595

int latchPin = 8;    //Pin connected to ST_CP of 74HC595


void setup() {
                              //set pins to output because they are addressed in the main loop
   pinMode(dataPin, OUTPUT); 
   pinMode(clockPin, OUTPUT);
   pinMode(latchPin, OUTPUT);
}

void loop() {
  //count up routine
  for (int j = 0; j < 256; j++) {
    //ground latchPin and hold low for as long as you are transmitting

    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, j);  
    //return the latch pin high to signal chip that it
    //no longer needs to listen for information
    digitalWrite(latchPin, HIGH);
    delay(1000);
  }
} 

Serial to Parallel Shifting-Out with a 74HC595  (1A)

74HC595 pin Belegung

Example 1: One Shift Register

Der erste Schritt ist, Ihr Arduino mit einem Schieberegister zu erweitern.

The Circuit

1. Turning it on

Folgende Verbindungen herstellen:

• GND (pin 8) to ground,
• Vcc (pin 16) to 5V
• OE (pin 13) to ground
• MR (pin 10) to 5V

Diese Einstellung macht alle Ausgabe-Pins aktiv und adressierbar die ganze Zeit.

Der einzige Fehler dieses Aufbaus ist, dass Sie am Ende mit den Lichtern auf den letzten Zustand oder etwas Willkür jedes Mal, wenn Sie zuerst die Schaltung der Schaltung, bevor das Programm beginnt zu laufen.

Sie können dies durch die Kontrolle der MR und OE Pins aus Ihrem Arduino Board zu bekommen, aber dieser Weg wird funktionieren und lassen Sie mit offeneren Pins.

2. Connect to Arduino

• DS (pin 14) to Ardunio DigitalPin 11 (blue wire)
• SH_CP (pin 11) to to Ardunio DigitalPin 12 (yellow wire)
• ST_CP (pin 12) to Ardunio DigitalPin 8 (green wire)

Von nun an werden diese als dataPin, the clockPin bzw. latchPin bezeichnet. Beachten Sie den 0,1 "f Kondensator auf dem LatchPin, wenn Sie etwas Flimmern haben, wenn der Latch Pin Impulse können Sie einen Kondensator verwenden, um es sogar aus.

3. Add 8 LEDs.

Circuit Diagram

The Code

Code Sample 1.1 Hello World
Code Sample 1.2 One by One
Code Sample 1.3 Using an array

Example 2

In diesem Beispiel fügen Sie ein zweites Schieberegister hinzu, das die Anzahl der Ausgangspins verdoppelt, die Sie haben, während immer noch die gleiche Anzahl von Pins aus dem Arduino verwendet wird

The Circuit

1. Add a second shift register.

2. Connect the 2 registers.

3. Add a second set of LEDs.

In this case I added green ones so when reading the code it is clear which byte is going to which set of LEDs
In diesem Fall habe ich grüne hinzugefügt, also beim Lesen des Codes ist klar, welches Byte zu welchem Satz von LEDs geht

Circuit Diagram

The Code

Code Sample 2.2 2 Byte One By One
Comparing this code to the similar code from Example 1 you see that a little bit more has had to change.
The blinkAll() function has been changed to the blinkAll_2Bytes() function to reflect the fact that now there are 16 LEDs to control.
Also, in version 1 the pulsings of the latchPin were situated inside the subfunctions lightShiftPinA and lightShiftPinB().
Here they need to be moved back into the main loop to accommodate needing to run each subfunction twice in a row, once for the green LEDs and once for the red ones.

Code Sample 2.3 - Dual Defined Arrays
Like sample
2.2, sample 2.3 also takes advantage of the new blinkAll_2bytes() function.
2.3's big difference from sample 1.3 is only that instead of just a single variable called "data" and a single array called "dataArray" you have to have a dataRED, a dataGREEN, dataArrayRED, dataArrayGREEN defined up front. This means that line

//**************************************************************////  Name    : shiftOutCode, Dual Binary Counters                 ////  Author  : Carlyn Maw, Tom Igoe                               ////  Date    : 25 Oct, 2006                                       ////  Version : 1.0                                                ////  Notes   : Code for using a 74HC595 Shift Register            ////          : to count from 0 to 255                             ////**************************************************************////Pin connected to ST_CP of 74HC595int latchPin = 8;//Pin connected to SH_CP of 74HC595int clockPin = 12;////Pin connected to DS of 74HC595int dataPin = 11;void setup() {  //Start Serial for debuging purposes       Serial.begin(9600);  //set pins to output because they are addressed in the main loop  pinMode(latchPin, OUTPUT);}void loop() {  //count up routine  for (int j = 0; j < 256; j++) {    //ground latchPin and hold low for as long as you are transmitting    digitalWrite(latchPin, 0);    //count up on GREEN LEDs    shiftOut(dataPin, clockPin, j);     //count down on RED LEDs    shiftOut(dataPin, clockPin, 255-j);    //return the latch pin high to signal chip that it     //no longer needs to listen for information    digitalWrite(latchPin, 1);    delay(1000);  }}void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {  // This shifts 8 bits out MSB first,   //on the rising edge of the clock,  //clock idles low..//internal function setup  int i=0;  int pinState;  pinMode(myClockPin, OUTPUT);  pinMode(myDataPin, OUTPUT);. //clear everything out just in case to. //prepare shift register for bit shifting  digitalWrite(myDataPin, 0);  digitalWrite(myClockPin, 0);  //for each bit in the byte myDataOut�  //NOTICE THAT WE ARE COUNTING DOWN in our for loop  //This means that %00000001 or "1" will go through such  //that it will be pin Q0 that lights.   for (i=7; i>=0; i--)  {    digitalWrite(myClockPin, 0);    //if the value passed to myDataOut and a bitmask result     // true then... so if we are at i=6 and our value is    // %11010100 it would the code compares it to %01000000     // and proceeds to set pinState to 1.    if ( myDataOut & (1<<i) ) {      pinState= 1;    }    else {          pinState= 0;    }    //Sets the pin to HIGH or LOW depending on pinState    digitalWrite(myDataPin, pinState);    //register shifts bits on upstroke of clock pin      digitalWrite(myClockPin, 1);    //zero the data pin after shift to prevent bleed through    digitalWrite(myDataPin, 0);  }  //stop shifting  digitalWrite(myClockPin, 0);}

//**************************************************************////  Name    : shiftOutCode, Dual One By One                           ////  Author  : Carlyn Maw, Tom Igoe                               ////  Date    : 25 Oct, 2006                                       ////  Version : 1.0                                                ////  Notes   : Code for using a 74HC595 Shift Register            ////          : to count from 0 to 255                             ////**************************************************************////Pin connected to ST_CP of 74HC595int latchPin = 8;//Pin connected to SH_CP of 74HC595int clockPin = 12;////Pin connected to DS of 74HC595int dataPin = 11;//holder for infromation you're going to pass to shifting functionbyte data = 0; void setup() {  //set pins to output because they are addressed in the main loop  pinMode(latchPin, OUTPUT);}void loop() {  //function that blinks all the LEDs  //gets passed the number of blinks and the pause time  blinkAll_2Bytes(1,500);   // light each pin one by one using a function A  for (int j = 0; j < 8; j++) {    //ground latchPin and hold low for as long as you are transmitting    digitalWrite(latchPin, 0);    //red LEDs    lightShiftPinA(7-j);    //green LEDs    lightShiftPinA(j);    //return the latch pin high to signal chip that it     //no longer needs to listen for information    digitalWrite(latchPin, 1);    delay(1000);  }  // light each pin one by one using a function A  for (int j = 0; j < 8; j++) {    //ground latchPin and hold low for as long as you are transmitting    digitalWrite(latchPin, 0);    //red LEDs    lightShiftPinB(j);    //green LEDs    lightShiftPinB(7-j);    //return the latch pin high to signal chip that it     //no longer needs to listen for information    digitalWrite(latchPin, 1);    delay(1000);  } }//This function uses bitwise math to move the pins upvoid lightShiftPinA(int p) {  //defines a local variable  int pin;  //this is line uses a bitwise operator  //shifting a bit left using << is the same  //as multiplying the decimal number by two.   pin = 1<< p;  //move 'em out  shiftOut(dataPin, clockPin, pin);   }//This function uses that fact that each bit in a byte//is 2 times greater than the one before it to//shift the bits highervoid lightShiftPinB(int p) {  //defines a local variable  int pin;  //start with the pin = 1 so that if 0 is passed to this  //function pin 0 will light.   pin = 1;  for (int x = 0; x < p; x++) {    pin = pin * 2;   }  //move 'em out  shiftOut(dataPin, clockPin, pin);   }// the heart of the programvoid shiftOut(int myDataPin, int myClockPin, byte myDataOut) {  // This shifts 8 bits out MSB first,   //on the rising edge of the clock,  //clock idles low  //internal function setup  int i=0;  int pinState;  pinMode(myClockPin, OUTPUT);  pinMode(myDataPin, OUTPUT);  //clear everything out just in case to  //prepare shift register for bit shifting  digitalWrite(myDataPin, 0);  digitalWrite(myClockPin, 0);  //for each bit in the byte myDataOut�  //NOTICE THAT WE ARE COUNTING DOWN in our for loop  //This means that %00000001 or "1" will go through such  //that it will be pin Q0 that lights.   for (i=7; i>=0; i--)  {    digitalWrite(myClockPin, 0);    //if the value passed to myDataOut and a bitmask result     // true then... so if we are at i=6 and our value is    // %11010100 it would the code compares it to %01000000     // and proceeds to set pinState to 1.    if ( myDataOut & (1<<i) ) {      pinState= 1;    }    else {        pinState= 0;    }    //Sets the pin to HIGH or LOW depending on pinState    digitalWrite(myDataPin, pinState);    //register shifts bits on upstroke of clock pin      digitalWrite(myClockPin, 1);    //zero the data pin after shift to prevent bleed through    digitalWrite(myDataPin, 0);  }  //stop shifting  digitalWrite(myClockPin, 0);}//blinks both registers based on the number of times you want to //blink "n" and the pause between them "d"//starts with a moment of darkness to make sure the first blink//has its full visual effect.void blinkAll_2Bytes(int n, int d) {  digitalWrite(latchPin, 0);  shiftOut(dataPin, clockPin, 0);  shiftOut(dataPin, clockPin, 0);  digitalWrite(latchPin, 1);  delay(200);  for (int x = 0; x < n; x++) {    digitalWrite(latchPin, 0);    shiftOut(dataPin, clockPin, 255);    shiftOut(dataPin, clockPin, 255);    digitalWrite(latchPin, 1);    delay(d);    digitalWrite(latchPin, 0);    shiftOut(dataPin, clockPin, 0);    shiftOut(dataPin, clockPin, 0);    digitalWrite(latchPin, 1);    delay(d);  }}

data = dataArray[j];

becomes

dataRED = dataArrayRED[j];
dataGREEN = dataArrayGREEN[j];

and

shiftOut(dataPin, clockPin, data);

becomes

shiftOut(dataPin, clockPin, dataGREEN);
shiftOut(dataPin, clockPin, dataRED);

Tom Igoe  2006-11

//**************************************************************////  Name    : shiftOutCode, Predefined Dual Array Style         ////  Author  : Carlyn Maw, Tom Igoe                              ////  Date    : 25 Oct, 2006                                      ////  Version : 1.0                                               ////  Notes   : Code for using a 74HC595 Shift Register           ////          : to count from 0 to 255                            ////****************************************************************//Pin connected to ST_CP of 74HC595int latchPin = 8;//Pin connected to SH_CP of 74HC595int clockPin = 12;////Pin connected to DS of 74HC595int dataPin = 11;//holders for infromation you're going to pass to shifting functionbyte dataRED;byte dataGREEN;byte dataArrayRED[10];byte dataArrayGREEN[10];void setup() {  //set pins to output because they are addressed in the main loop  pinMode(latchPin, OUTPUT);  Serial.begin(9600);  //Arduino doesn't seem to have a way to write binary straight into the code   //so these values are in HEX.  Decimal would have been fine, too.   dataArrayRED[0] = 0xFF; //11111111  dataArrayRED[1] = 0xFE; //11111110  dataArrayRED[2] = 0xFC; //11111100  dataArrayRED[3] = 0xF8; //11111000  dataArrayRED[4] = 0xF0; //11110000  dataArrayRED[5] = 0xE0; //11100000  dataArrayRED[6] = 0xC0; //11000000  dataArrayRED[7] = 0x80; //10000000  dataArrayRED[8] = 0x00; //00000000  dataArrayRED[9] = 0xE0; //11100000  //Arduino doesn't seem to have a way to write binary straight into the code   //so these values are in HEX.  Decimal would have been fine, too.   dataArrayGREEN[0] = 0xFF; //11111111  dataArrayGREEN[1] = 0x7F; //01111111  dataArrayGREEN[2] = 0x3F; //00111111  dataArrayGREEN[3] = 0x1F; //00011111  dataArrayGREEN[4] = 0x0F; //00001111  dataArrayGREEN[5] = 0x07; //00000111  dataArrayGREEN[6] = 0x03; //00000011  dataArrayGREEN[7] = 0x01; //00000001  dataArrayGREEN[8] = 0x00; //00000000  dataArrayGREEN[9] = 0x07; //00000111  //function that blinks all the LEDs  //gets passed the number of blinks and the pause time  blinkAll_2Bytes(2,500); }void loop() {  for (int j = 0; j < 10; j++) {    //load the light sequence you want from array    dataRED = dataArrayRED[j];    dataGREEN = dataArrayGREEN[j];    //ground latchPin and hold low for as long as you are transmitting    digitalWrite(latchPin, 0);    //move 'em out    shiftOut(dataPin, clockPin, dataGREEN);       shiftOut(dataPin, clockPin, dataRED);    //return the latch pin high to signal chip that it     //no longer needs to listen for information    digitalWrite(latchPin, 1);    delay(300);  }}// the heart of the programvoid shiftOut(int myDataPin, int myClockPin, byte myDataOut) {  // This shifts 8 bits out MSB first,   //on the rising edge of the clock,  //clock idles low  //internal function setup  int i=0;  int pinState;  pinMode(myClockPin, OUTPUT);  pinMode(myDataPin, OUTPUT);  //clear everything out just in case to  //prepare shift register for bit shifting  digitalWrite(myDataPin, 0);  digitalWrite(myClockPin, 0);  //for each bit in the byte myDataOut�  //NOTICE THAT WE ARE COUNTING DOWN in our for loop  //This means that %00000001 or "1" will go through such  //that it will be pin Q0 that lights.   for (i=7; i>=0; i--)  {    digitalWrite(myClockPin, 0);    //if the value passed to myDataOut and a bitmask result     // true then... so if we are at i=6 and our value is    // %11010100 it would the code compares it to %01000000     // and proceeds to set pinState to 1.    if ( myDataOut & (1<<i) ) {      pinState= 1;    }    else {            pinState= 0;    }    //Sets the pin to HIGH or LOW depending on pinState    digitalWrite(myDataPin, pinState);    //register shifts bits on upstroke of clock pin      digitalWrite(myClockPin, 1);    //zero the data pin after shift to prevent bleed through    digitalWrite(myDataPin, 0);  }  //stop shifting  digitalWrite(myClockPin, 0);}//blinks the whole register based on the number of times you want to //blink "n" and the pause between them "d"//starts with a moment of darkness to make sure the first blink//has its full visual effect.void blinkAll_2Bytes(int n, int d) {  digitalWrite(latchPin, 0);  shiftOut(dataPin, clockPin, 0);  shiftOut(dataPin, clockPin, 0);  digitalWrite(latchPin, 1);  delay(200);  for (int x = 0; x < n; x++) {    digitalWrite(latchPin, 0);    shiftOut(dataPin, clockPin, 255);    shiftOut(dataPin, clockPin, 255);    digitalWrite(latchPin, 1);    delay(d);    digitalWrite(latchPin, 0);    shiftOut(dataPin, clockPin, 0);    shiftOut(dataPin, clockPin, 0);    digitalWrite(latchPin, 1);    delay(d);  }}

Arduino LED Lauflicht – Knight Rider K.I.T.T.

Arduino Uno mit Dämmerungssensor und Lauflicht

// Das Array mit den belegten Pins. Die Nullen vorne und hinten sind ein Trick,// damit sich das Lauflicht, dass sich über mehrere LEDs erstreckt, komplett// aus dem Bild laufen kann. int pinArray[] = {0,0,0,6,7,8,9,10,11,12,13,0,0,0}; // Die Anzahl der Elemente im Array. Die Elemente sind dann über die//Indizes [0] bis [13] zu erreichen.int pinCount = 14; // Der aktive Eintrag des Array, pinArray[2] ist das 3(!) Element. Das wird// zum Start gesetzt, die beiden hinterherlaufenden Lichter kriegen dann die // Einträge [1] und [0], also sind zum Start alle // anzusprechenden Pins = 0int activePin = 2; // Die Laufrichtung, in der für den nächsten Schritt zum activePin addiert // wird. dx ist +1 (aufwärts im Array) oder -1 (abwärts im Array)int dx = 1; // Der vom Potentiometer gelieferte Wertint poti = 0; // Mindestverzögerung zwischen zwei Schritten des Lauflichts. // Mit z.B. mintime=20 kann man die maximale Geschwindigkeit begrenzen.int mintime = 0; // setup() wird einmal bei Programmstart ausgeführtvoid setup() {  // Serielle Übertragung starten  Serial.begin(9600);  // Durch das Array gehen, alle Pins auf OUTPUT setzen außer es kommt 0.  for (int i=0; i< pinCount; i++) {    if (pinArray[i] != 0) {      pinMode(pinArray[i], OUTPUT);    }  }} // loop() wird während des Programmablaufs endlos immer wieder aufgerufenvoid loop() {   // Zuerst schalten wir alle Pins of Array auf LOW, als Hilfsfunktion  // verwenden wir digitalWriteNot0(), damit die Array-Einträge mit   // Wert 0 ignoriert werden.  for (int i=0; i<pinCount; i++) {    digitalWriteNot0(pinArray[i], LOW);  }   // Sind wir am Ende des Arrays angekommen? Wenn ja, dann einen Schritt   // zurückgehen (zum vorletzten 0-Element) und mit dx = -1 die Laufrichtung#  // ändern.  if (activePin == (pinCount-1)) {    activePin = (pinCount - 2);    dx = -1;  }   // Sind wir am Anfang des Arrays angekommen? Wenn ja, dann einen Schritt   // weitergehen (zum 2. 0-Element) und mit dx = 1 die Laufrichtung aufwärts setzen.  if (activePin == 0) {    activePin = 1;    dx = 1;  }   // Zum aktiven Pin die Laufrichtung hinzuzählen. An den Rändern des Array mit  // den 3 Nullen sind wir damit mindestens 2 Elemente vom Rand entfernt, haben   // also Platz um 2 weitere LEDs leuchten zu lassen  activePin += dx;   // Potentiometer von Pin 0 einlesen (Wert zwischen 0 und 1023)  poti = analogRead(0);   // Wenn der Wert < 1023 ist, dann...  if (poti < 1023) {    // Die LED auf activePin einschalten    digitalWriteNot0(pinArray[activePin], HIGH);    // und die LED in entgegengesetzter Laufrichtung davor    digitalWriteNot0(pinArray[activePin-dx], HIGH);    // und eine weitere LED in entgegengesetzter Laufrichtung davor    digitalWriteNot0(pinArray[activePin-2*dx], HIGH);    // Das funktoniert, weil wir durch die 3 Nullen an den Rändern des Arrays genug    // Platz haben, um im Array zu lesen, ohnen die Arraygrenzen zu sprengen. Wenn     // als Pin eine 0 drinsteht, wird dieses beim Schalten der LEDs einfach ignoriert.  }   // Debug-Ausgabe für den Seriellen Monitor. Einfach über "Tools" einschalten  Serial.print(poti);  Serial.print(" - ");  Serial.println(activePin);   // Den geviertelten Wert des Potentiometers verwenden wir für die Wartezeit   // zwischen den Schritten in Millisekunden mintime kann als Mindestwert gesetzt   // werden, damit wird die maximale Geschwindigkeit des Lauflichts begrenzt.  delay(mintime+analogRead(0)/4); } // digitalWriteNot0() ist eine Hilfsfunktion, die nur dann digitalWrite() ausführt,// wenn das übergebene Pin nicht 0 ist. Damit werden die Füllelemente des pinArray// bei der Ausgabe einfach ignoriert.void digitalWriteNot0(int pin, boolean state) {  if (pin > 0) {    digitalWrite(pin, state);  }}

Arduino – Treppenlicht

/* * Treppenlicht mit 2x SRF02 *                  1x LDR *                  45 LEDs in fünf Gruppen *///***LIBRARIES***#include "Wire.h"#include "SRF02.h"//***AUFRUFE***SRF02 Sensor[2] ={  SRF02(0x70, SRF02_CENTIMETERS),  SRF02(0x71, SRF02_CENTIMETERS)};//***VARIABLEN***//unsigned long nextPrint = 0;unsigned long laufzeit = 0;int WaitTime = 750;          // Pause zwischen den Einschalt-Zyklenint AusgabeTime = 0;          // Pause zwischen den seriellen Ausgabenint Wert1 = 0;int Wert2 = 0;int auf = 0;int LDRWert = 0;int MinLicht = 600;           // Mindestwert Lichtstärke für Einschalten (default: 275)int SchwelleUnten = 40;       // Schwellwert für Sensor unten (default: 35)int SchwelleOben = 80;        // Schwellwert für Sensor oben (default: 80)int Brenndauer = 25;          // Brenndauer für Time-Out-Abschaltung in Sekunden (default: 20)//***PINS***int PowerLED = 13;int Kanal_1 = 3;int Kanal_2 = 5;int Kanal_3 = 6;int Kanal_4 = 9;int Kanal_5 = 10;int ResetPIN = 4;int LDRPin = 0;void setup(){  pinMode(PowerLED, OUTPUT);  pinMode(ResetPIN, OUTPUT);  digitalWrite(PowerLED, HIGH);   digitalWrite(ResetPIN, LOW);  Serial.begin(9600);  Wire.begin();  SRF02::setInterval(200);}void loop(){  SRF02::update();  Wert1=Sensor[0].read();  Wert2=Sensor[1].read();  LDRWert = analogRead(LDRPin);//++++++++++++++++++++++++++++EINSCHALTEN Funktion AUF++++++++++++++++++++++++++++  if ( (Wert1 <= SchwelleUnten) && (Wert1 > 0) && (auf == 0) && (LDRWert < MinLicht) )   // Sensor unten hat ausgelöst "AUFWÄRTS einschalten"  {    digitalWrite(PowerLED, LOW);      laufzeit = millis ();                // 1    for (int i=0; i<=255; i+=5)    {      analogWrite(Kanal_1, i);      delay(5);    }       auf = 1 ;  }    if ( (millis() > (laufzeit + WaitTime)) && (auf == 1) )  {    for (int i=0; i<=255; i+=5)          // 2    {      analogWrite(Kanal_2, i);      delay(5);    }    auf = 2;  }    if ( (millis() > (laufzeit + WaitTime * 2 )) && (auf == 2) )  {    for (int i=0; i<=255; i+=5)          // 3    {      analogWrite(Kanal_3, i);      delay(5);    }    auf = 3;  }    if ( (millis() > (laufzeit + WaitTime * 3 )) && (auf == 3) )  {    for (int i=0; i<=255; i+=5)          // 4    {      analogWrite(Kanal_4, i);      delay(5);    }    auf = 4;  }    if ( (millis() > (laufzeit + WaitTime * 4 )) && (auf == 4) )  {    for (int i=0; i<=255; i+=5)          // 5    {      analogWrite(Kanal_5, i);      delay(5);    }    auf = 5;  }//++++++++++++++++++++++++++++EINSCHALTEN Funktion AUF++++++++++++++++++++++++++++//++++++++++++++++++++++++++++EINSCHALTEN Funktion AB+++++++++++++++++++++++++++++  if ( (Wert2 <= SchwelleOben) && (Wert2 > 0) && (auf == 0) && (LDRWert < MinLicht) )   // Sensor oben hat ausgelöst "ABWÄRTS einschalten"  {    digitalWrite(PowerLED, LOW);      laufzeit = millis ();                // 1    for (int i=0; i<=255; i+=5)    {      analogWrite(Kanal_5, i);      delay(5);    }       auf = 11 ;  }    if ( (millis() > (laufzeit + WaitTime)) && (auf == 11) )  {    for (int i=0; i<=255; i+=5)          // 2    {      analogWrite(Kanal_4, i);      delay(5);    }    auf = 12;  }    if ( (millis() > (laufzeit + WaitTime * 2 )) && (auf == 12) )  {    for (int i=0; i<=255; i+=5)          // 3    {      analogWrite(Kanal_3, i);      delay(5);    }    auf = 13;  }    if ( (millis() > (laufzeit + WaitTime * 3 )) && (auf == 13) )  {    for (int i=0; i<=255; i+=5)          // 4    {      analogWrite(Kanal_2, i);      delay(5);    }    auf = 14;  }    if ( (millis() > (laufzeit + WaitTime * 4 )) && (auf == 14) )  {    for (int i=0; i<=255; i+=5)          // 5    {      analogWrite(Kanal_1, i);      delay(5);    }    auf = 15;  }//++++++++++++++++++++++++++++EINSCHALTEN Funktion AUF++++++++++++++++++++++++++++//++++++++++++++++++++++++++++DATENAUSGABE++++++++++++++   if ( AusgabeTime >= 5000 ) {    Serial.print("Sensorwert unten: ");    Serial.println(Sensor[0].read());    Serial.print("Sensorwert oben: ");    Serial.println(Sensor[1].read());    Serial.print("Helligkeit: ");    Serial.println(LDRWert);        Serial.print("Programmposition: ");    Serial.println(auf);    Serial.println("-----------------------------------");    AusgabeTime = 0;   }//++++++++++++++++++++++++++++DATENAUSGABE++++++++++++++ //++++++++++++++++++++++++++++AUSSCHALTEN durch Timeout, Funktion AUF++++++++++++++  if ( (millis() > (laufzeit + WaitTime * Brenndauer)) && (auf == 5) )  {    for (int i=255; i>=0; i-=5)              {      analogWrite(Kanal_1, i);      analogWrite(Kanal_2, i);      analogWrite(Kanal_3, i);      analogWrite(Kanal_4, i);            analogWrite(Kanal_5, i);      delay(20);    }    //auf = 0;    digitalWrite(PowerLED, HIGH);    digitalWrite(ResetPIN, HIGH);  }//++++++++++++++++++++++++++++AUSSCHALTEN durch Timeout, Funktion AUF++++++++++++++//++++++++++++++++++++++++++++AUSSCHALTEN durch Timeout, Funktion AB++++++++++++++  if ( (millis() > (laufzeit + WaitTime * Brenndauer)) && (auf == 15) )  {    for (int i=255; i>=0; i-=5)              {      analogWrite(Kanal_1, i);      analogWrite(Kanal_2, i);      analogWrite(Kanal_3, i);      analogWrite(Kanal_4, i);            analogWrite(Kanal_5, i);      delay(20);    }    //auf = 0;    digitalWrite(PowerLED, HIGH);    digitalWrite(ResetPIN, HIGH);  }//++++++++++++++++++++++++++++AUSSCHALTEN durch Timeout, Funktion AB++++++++++++++  //++++++++++++++++++++++++++++AUSSCHALTEN durch Sensor, Funktion AUF++++++++++++++  if ( (auf == 5) && (Wert2>0) && (Wert2 < SchwelleOben) )          // Treppenlicht ist an und zweiter Sensor hat angeschlagen also "ausschalten"  {    for (int i=255; i>=0; i-=5)              {      analogWrite(Kanal_1, i);      analogWrite(Kanal_2, i);      analogWrite(Kanal_3, i);      analogWrite(Kanal_4, i);            analogWrite(Kanal_5, i);      delay(20);    }    //auf = 0;    digitalWrite(PowerLED, HIGH);    digitalWrite(ResetPIN, HIGH);  }//++++++++++++++++++++++++++++AUSSCHALTEN durch Sensor, Funktion AUF++++++++++++++//++++++++++++++++++++++++++++AUSSCHALTEN durch Sensor, Funktion AB++++++++++++++  if ( (auf == 15) && (Wert1>0) && (Wert1 < SchwelleUnten) )          // Treppenlicht ist an und zweiter Sensor hat angeschlagen also "ausschalten"  {    for (int i=255; i>=0; i-=5)              {      analogWrite(Kanal_1, i);      analogWrite(Kanal_2, i);      analogWrite(Kanal_3, i);      analogWrite(Kanal_4, i);            analogWrite(Kanal_5, i);      delay(20);    }    //auf = 0;    digitalWrite(PowerLED, HIGH);    digitalWrite(ResetPIN, HIGH);  }//++++++++++++++++++++++++++++AUSSCHALTEN durch Sensor, Funktion AB++++++++++++++AusgabeTime = AusgabeTime + 1;}

Treppenbeleuchtung mit Arduino Uno

Treppenbeleuchtung LED NeoPixel Motion Sensor

1. 1 X Arduino Uno (e-Bay)
2. 2 X PIR-Bewegungs-Sensoren (e-Bay)
3. 10M WS2812B LED Light Strip (Länge hängt wie Sie wollen, es rücke. Jede Treppe ist anders!) (e-Bay)
4. 5V 60A Switching Power supply (e-Bay)
5. 100ft 18AWG Datenkabel (grün) (e-Bay)
6. 100ft 18AWG Stromkabel (rot, schwarz) (e-Bay)
7. Verlängerungskabel oder ein standard-Netzkabel für einen Computer (alte Teile)
8. Lötkolben + Löt Draht, etc. (vorher gekauft)
9. Schrumpffolie (e-Bay)
10. Klebeband (big Box speichern)
11. Klaren Silikon (big Box speichern)

PIR Motion Sensor

1. /*
2. * PIR sensor tester
3. */
4. int ledPin = 13; // choose the pin for the LED
5. int inputPin = 2; // choose the input pin (for PIR sensor)
6. int pirState = LOW; // we start, assuming no motion detected
7. int val = 0; // variable for reading the pin status
8. void setup() {
9. pinMode(ledPin, OUTPUT); // declare LED as output
10. pinMode(inputPin, INPUT); // declare sensor as input
11. Serial.begin(9600);
12. }
13. void loop(){
14. val = digitalRead(inputPin); // read input value
15. if (val == HIGH) { // check if the input is HIGH
16. digitalWrite(ledPin, HIGH); // turn LED ON
17. if (pirState == LOW) {
18. // we have just turned on
19. Serial.println("Motion detected!");
20. // We only want to print on the output change, not state
21. pirState = HIGH;
22. }
23. } else {
24. digitalWrite(ledPin, LOW); // turn LED OFF
25. if (pirState == HIGH){
26. // we have just turned of
27. Serial.println("Motion ended!");
28. // We only want to print on the output change, not state
29. pirState = LOW;
30. }
31. }
32. }

********************************************************I*

Treppenbeleuchtung mit ARDUINO

Treppenbeleuchtung mit LEDs
Ein Controller für viele Leuchtdioden

Elektor 05-06/2017 (PDF)

********************************************************I*

Stromstoßschalter/ Treppenlicht-Zeitschalter

Eltako Treppenlicht-Schalter

Eltako Treppenlichtzeitschalter,

https://www.eltako.com/no_cache/at/das-system-im-gebaeude/15-treppenlicht-zeitschalter-und-nachlaufschalter.html?locationData=38%3Att_content%3A99

300_b_eltako-x_Eltako Treppenlicht-Zeitschalter und Nachlaufschalter - Gesamtkatalog_1a.pdf

https://www.eltako.com/fileadmin/downloads/de/Prospekte/Prospekt_Treppenlichtzeitschalter_internet_low.pdf

https://www.elv.at/stromstossschalter-treppenlichtschalter-elektroinstallation.html

********************************************************I*

PIR Motion Sensor Tutorial

• Größe: Rechteckige
• Preis: $10,00 bei Adafruit shop
• Ausgabe: Digitalen Puls hoch (3V) Auslösung (Bewegung erkannt) Digital niedriger als im Leerlauf (keine Bewegung erkannt).
  
• Pulslängen werden durch Widerstände und Kondensatoren auf der Platine bestimmt und unterscheiden sich von Sensor zu Sensor.
• Empfindlichkeitsbereich: bis zu 20 Fuß (6 m) 110 x 70 Grad Erfassungsbereich
• Stromversorgung: 3,3V - 5V Eingangsspannung,
• BIS0001 Datenblatt (der Decoder-Chip verwendet)
• RE200B Datenblatt (wahrscheinlich die PIR Sensorelement verwendet)
• NL11NH Datenblatt (entsprechende Objektiv verwendet)
• Parallaxe Datenblatt auf ihre Version des Sensors

Weitere Links!

• Eine tolle Seite auf PIR-Sensoren von GLOLAB
• NYU Sensor Bericht

Schritt 1: Wie funktioniert es?

Schritt 2: Linsen

Schritt 3: Schließen Sie an Ihren PIR

Schritt 4: Testen der PIR

Schritt 5: Retriggerung

Schritt 6: Längenänderung Puls Zeit und timeout

TX ist 24576 = * R10 * C6 = ~1.2 Sekunden
R10 = 4,7 K und C6 = 10nF

Ebenso

TI = 24 * R9 * C7 = ~1.2 Sekunden
R9 = 470 K und C7 = 0.1uF

Schritt 7: Projektbeispiele

Schritt 8: Lesung PIR-Sensoren

/ * PIR Sensor Tester * /

Int-LedPin = 13; Wählen Sie die Pin für die LED
Int InputPin = 2; Wählen Sie die Eingangs-Pin (für PIR-Sensor)
Int PirState = LOW; Wir beginnen, vorausgesetzt, keine Bewegung erkannt
Int Val = 0; Variable für das Lesen der Status-Pins

void setup() {}
PinMode (OUTPUT-LedPin,); LED als Ausgabe zu erklären
PinMode (InputPin, Eingabe); Sensor als Eingabe deklarieren

Serial.Begin(9600);
}

void loop() {}
Val = digitalRead(inputPin); Eingabewert zu lesen
Wenn (Val == HIGH) {/ / prüfen, ob die Eingabe hoch ist
DigitalWrite (LedPin, HIGH); LED ein-
Wenn (PirState == LOW) {}
Wir haben gerade eingeschaltet
Serial.println ("Bewegung erkannt!");
Wir wollen nur auf der Ausgabe ändern, nicht staatliche drucken
PirState = hoch;
}
} else {}
DigitalWrite (LedPin, LOW); LED ausschalten
Wenn (PirState == HIGH) {}
Wir haben gerade von
Serial.println ("Motion beendet!");
Wir wollen nur auf der Ausgabe ändern, nicht staatliche drucken
PirState = niedrig;
}
}
}

http://www.genstr.com/pir-motion-sensor-tutorial.html

********************************************************I*

const int buttonPin = 12;const int ledPin = 2; void setup() { pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT);} void loop() { if (digitalRead(buttonPin) == HIGH) { digitalWrite(ledPin, HIGH); } else { digitalWrite(ledPin, LOW); }}

#include "OneButton.h" const int buttonPin = 12;const int ledPin = 2; OneButton button(buttonPin, false); int ledState = LOW; void setup() { pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT);  button.attachClick(clickedIt); button.attachDoubleClick(doubleClickedIt); } void loop() { button.tick();  delay(10);}  void clickedIt() { ledState = !ledState; digitalWrite(ledPin, ledState);} void doubleClickedIt() { for (int i=0; i<5; i++) { digitalWrite(ledPin, HIGH); delay(60); digitalWrite(ledPin, LOW); delay(60); }  digitalWrite(ledPin, ledState);}

[code]
#include 
int ledPin=13;
int buttonPin1=A1;
OneButton button1=OneButton(buttonPin1,true);

void setup() {
  pinMode(ledPin,OUTPUT);
  pinMode(buttonPin1,INPUT);
  button1.attachPress(halten);
  button1.setPressTicks(3000);
}

void loop() {
 button1.tick();
  delay(10);
}
void halten()
 {
   static int ledState=LOW;
   ledState=!ledState;
   digitalWrite(ledPin,ledState);
   }

[/code]