Arduino Mosfet pir voor Ledstrip

/*
 * PIR sensor tester
 */
 
#include <EEPROM.h> 
 
int ledPin = 12;                // choose the pin for the LED
int PIRpin = 2;               // choose the input pin (for PIR sensor)
int LDRpin = 2;
int pirState = LOW;             // we start, assuming no motion detected
int val = 0;                    // variable for reading the pin status
int pval = 0;                   // variable for reading the pin status
byte maxbrightness = 15;        // max brightness
byte brightness = 0;            // brightness
int ontime = 15;                // in seconds
int rampdelay = 250;
boolean ledstate = false;       // LEDs are on or off
boolean dark = true;
int maxdark = 100;
unsigned long offtime;


#define DEBUG 0
#define NVALUES 1

static byte settings[NVALUES];   // 0 = red, 1 = green, 2 = blue, 3 = white
static byte slots[256];          // time slots, toggles whenever a bit is set

// which setting affects which I/O pin:
//  bits 0..3 = AIO1 .. AIO4
//  bits 4..7 = DIO1 .. DIO4

//static const byte masks[NVALUES] = {0x20, 0x02, 0x10, 0x01 };
//                                     7654 3210
//                              0x20 = 0010 0000 = DIO2
//                              0x02 = 0000 0010 = AIO2
//                              0x10 = 0001 0000 = DIO1
//                              0x01 = 0000 0001 = AIO1

// 0x10 = bit 4 = DIO1 = Arduino digital 4
static const byte masks[NVALUES] = {0x10};

static void setupIO() {
  for (byte i = 0; i < NVALUES; ++i) {
    PORTD &= ~ (masks[i] & 0xF0);   // turn DIO pin off
    DDRD |= masks[i] & 0xF0;        // make pin an output
  }    
}

static void prepareSlots() {
  #if DEBUG
  Serial.print("settings ");
  for (byte i = 0; i < NVALUES; ++i) {
    Serial.print(' ');
    Serial.print(settings[i], DEC);
  }
  Serial.println();
  #endif    

  // set a few bits, i.e. at the time when we need to toggle the output pin
  memset(slots, 0, sizeof slots);
  // note: a 0 setting toggles the same bit twice, so it won't ever turn on
  for (byte i = 0; i < NVALUES; ++i) {
    byte level = settings[i];   // get the requested PWM level
    byte mask = masks[i];       // map setting to corresponding I/O pin
    slots[0] ^= mask;           // toggle on at the start of the loop
    slots[level] ^= mask;       // toggle off at the proper time
  }
  // Special case: run LED at full brightness for level 255 - this is done
  // by turning the LED on at the start of each scan and never toggling it.
  // This is done in loop() below, but we must prevent toggling in this case.
  slots[0] ^= slots[255];
}

static void loadSettings() {
  for (byte i = 0; i < NVALUES; ++i)
    settings[i] = EEPROM.read(i);
  prepareSlots();
}

static void saveSettings() {
  for (byte i = 0; i < NVALUES; ++i)
    EEPROM.write(i, settings[i]);
  prepareSlots();
}


 
void setup() {

  setupIO();
  settings[0] = 0;
  saveSettings();
  loadSettings();

  pinMode(ledPin, OUTPUT);      // declare LED as output
  pinMode(PIRpin, INPUT);     // declare sensor as input
 
  Serial.begin(9600);
  Serial.println("[BEDLIGHTPIR]");
}
 
int loopdelay = 0;
//int dark=0;

void loop(){

//  Serial.print(millis());
//  Serial.print(" ");
//  Serial.println(brightness,DEC);
//  delay(100);

  
  val = digitalRead(PIRpin);  // read input value

  if (loopdelay % rampdelay == 0)  
  {
    dark = (analogRead(LDRpin) < maxdark);
  }
//  Serial.print(millis());
//  Serial.print(" ");
//  Serial.println(dark?"dark":"light");
//  delay(100);
  

  if (val != pval) 
  {
    
    if (val == HIGH) 
    {
      // motion, so move time for the leds to go
      // off again forward
      offtime = millis() + (ontime * 1000);    
      digitalWrite(ledPin, HIGH);  // turn LED ON     
      if (!ledstate)
      {
        // leds were off, switch them on now
        brightness = 0;        
        ledstate = true;
        loopdelay = 0;
      }
    }
    else 
    {
      // no more motion.
      digitalWrite(ledPin, LOW); // turn LED OFF
    }
    pval=val;
  }
  if(dark)
  {
    if((ledstate) && (millis() > offtime))
    {
      ledstate = false;
      loopdelay = 0;
    }
  
    if ((ledstate) && (brightness < maxbrightness) && (loopdelay % rampdelay == 0))
    {   
      brightness++;
      settings[0] = brightness;
      prepareSlots();    
    }
    
    //if (((!ledstate) && (brightness > 0) || !dark) && (loopdelay % rampdelay == 0))
    if ((!ledstate) && (brightness > 0) && (loopdelay % rampdelay == 0))
    {
      brightness--;
      settings[0] = brightness;
      prepareSlots();    
    }
  }
  else
  {
    if ((brightness > 0) && (loopdelay % rampdelay == 0))
    {
      brightness--;
      settings[0] = brightness;
      prepareSlots();    
    }   
  }
  
  loopdelay++;
  
  // handle the special case: full-on never toggles the LED
  // FIXME: this needs to be refined if not all pins are allocated to LED PWM
  
//PORTC = (PORTC & 0xF0) | (slots[255] & 0x0F);
  PORTD = (PORTC & 0x0F) | (slots[255] & 0xF0);

  // here, the LED state is known: all LEDs with levels < 255 are off
  for (byte i = 0; i < 255; ++i) {
//  PINC = slots[i] & 0x0F; // toggle AIO pins for time slot i
    PIND = slots[i] & 0xF0; // toggle DIO pins for time slot i
    //delayMicroseconds(10);
  }
  
}

// Uses a PIR sensor to detect movement, buzzes a buzzer
// more info here: http://blog.makezine.com/projects/pir-sensor-arduino-alarm/
// email me, John Park, at jp@jpixl.net
// based upon:
// PIR sensor tester by Limor Fried of Adafruit
// tone code by michael@thegrebs.com

 
int ledPin = 12;                // choose the pin for the LED
int inputPin = 2;               // 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
      delay(100);      // delay is ophouden

    
    if (pirState == LOW) {
      // we have just turned on
//      Serial.println("Motion detected!");
      // We only want to print on the output change, not state
      pirState = LOW;
    }
  } else {
//      digitalWrite(ledPin, LOW); // turn LED OFF
           delay(100);    
      if (pirState == HIGH){
      // we have just turned of
      Serial.println("Motion ended!");
      // We only want to print on the output change, not state
      pirState = HIGH;
    }
  }
}

// Uses a PIR sensor to detect movement, buzzes a buzzer
// more info here: http://blog.makezine.com/projects/pir-sensor-arduino-alarm/
// email me, John Park, at jp@jpixl.net
// based upon:
// PIR sensor tester by Limor Fried of Adafruit
// tone code by michael@thegrebs.com

 
int ledPin = 12;                // choose the pin for the LED
int inputPin = 2;               // choose the input pin (for PIR sensor)
int pirState = LOW;             // we start, assuming no motion detected
int val = 1;                    // 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 == LOW) {            // Zorgt dat hij de goed "richting"op gaat High is de pir anders om
  digitalWrite(ledPin, HIGH);  // turn LED ON
//      delay(10);      
    
    if (pirState == LOW) {      // 
     Serial.println("Motion detected!");      // 
      pirState = LOW;
//      delay(10000);
    }
  } else {     digitalWrite(ledPin, LOW); // 
             
      if (pirState == HIGH){      // we have just turned of
      Serial.println("Motion ended!");      // 
      pirState = HIGH;
//     delay(1000000);  // tijd dat lamp aan is
    }
  }
}

// Uses a PIR sensor to detect movement, buzzes a buzzer
// more info here: http://blog.makezine.com/projects/pir-sensor-arduino-alarm/
// email me, John Park, at jp@jpixl.net
// based upon:
// PIR sensor tester by Limor Fried of Adafruit
// tone code by michael@thegrebs.com


int ledPin = 12;                // choose the pin for the LED
int inputPin = 2;               // choose the input pin (for PIR sensor)
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

}

void loop(){  //start de eeuwige loop
	val = digitalRead(inputPin);  //lees de actuele toestand van de PIR
	if (val == HIGH)  
	{            
		//de PIR is "hoog" (beweging gezien), dus inschakelen LED OF
		//de PIR is nog steeds hoog, hoe dan ook ledpin hoog maken of houden.
		digitalWrite(ledPin, HIGH);  // turn LED ON
		delay(100);      //wacht geduldig een tijdje terwijl de ledjes branden.
		//(let op: 100 zou ook msec kunnen zijn, in dat geval flink ophogen)

		//terug naar het begin van de loop (else word dus niet gedaan)
	}
	else 
	{
		//de PIR is weer laag. Leds kunnen uit. 
		digitalWrite(ledPin, HIGH);  // turn LED ON
	}
}

/* 
 * //////////////////////////////////////////////////
 * //making sense of the Parallax PIR sensor's output
 * //////////////////////////////////////////////////
 *
 * Switches a LED according to the state of the sensors output pin.
 * Determines the beginning and end of continuous motion sequences.
 *
// * @author: Kristian Gohlke / krigoo (_) gmail (_) com / http://krx.at
 * date:   3. September 2006 
 *
 * kr1 (cleft) 2006 
 * released under a creative commons "Attribution-NonCommercial-ShareAlike 2.0" license
 * http://creativecommons.org/licenses/by-nc-sa/2.0/de/
 *
 *
 * The Parallax PIR Sensor is an easy to use digital infrared motion sensor module. 
 * (http://www.parallax.com/detail.asp?product_id=555-28027)
 *
// * The sensor's output pin goes to HIGH if motion is present.
 * However, even if motion is present it goes to LOW from time to time, 
 * which might give the impression no motion is present. 
 * This program deals with this issue by ignoring LOW-phases shorter than a given time, 
 * assuming continuous motion is present during these phases.
 *  
 */

/////////////////////////////
//VARS
//the time we give the sensor to calibrate (10-60 secs according to the datasheet)
int calibrationTime = 20;        

//the time when the sensor outputs a low impulse
long unsigned int lowIn;         

//the amount of milliseconds the sensor has to be low 
//before we assume all motion has stopped
long unsigned int pause = 1000;  

boolean lockLow = true;
boolean takeLowTime;  

int pirPin = 2;    //the digital pin connected to the PIR sensor's output
int ledPin = 13;


/////////////////////////////
//SETUP
void setup(){
  Serial.begin(9600);
  pinMode(pirPin, INPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(pirPin, LOW);  // veranderd in HIGH niet

  //give the sensor some time to calibrate
  Serial.print("calibrating sensor ");
    for(int i = 0; i < calibrationTime; i++){
      Serial.print(".");
      delay(1000);
      }
    Serial.println(" done");
    Serial.println("SENSOR ACTIVE");
    delay(500);
  }

////////////////////////////
//LOOP
void loop(){

     if(digitalRead(pirPin) == HIGH){ // veranderd in LOW niets
       digitalWrite(ledPin, HIGH);   //the led visualizes the sensors output pin state // veranderd in LOW niets
       if(lockLow){  
         //makes sure we wait for a transition to LOW before any further output is made:
         lockLow = false;            
         Serial.println("---");
         Serial.print("motion detected at ");
         Serial.print(millis()/1000);
         Serial.println(" sec"); 
         delay(50);
         }         
         takeLowTime = true;
       }

     if(digitalRead(pirPin) == LOW){   // Veranderd in HIGH    niets
       digitalWrite(ledPin, LOW);  //the led visualizes the sensors output pin state

       if(takeLowTime){
        lowIn = millis();          //save the time of the transition from high to LOW
        takeLowTime = false;       //make sure this is only done at the start of a LOW phase
        }
       //if the sensor is low for more than the given pause, 
       //we assume that no more motion is going to happen
       if(!lockLow && millis() - lowIn > pause){  
           //makes sure this block of code is only executed again after 
           //a new motion sequence has been detected
           lockLow = true;                        
           Serial.print("motion ended at ");      //output
           Serial.print((millis() - pause)/1000);
           Serial.println(" sec");
           delay(50);
           }
       }
  }

// Twee pirren onder het bed...
// Pir A en Pir B 
//Pir B werkt niet...
 
int ledPin = 12;                // choose the pin for the LED
int inputPin = 2;               // choose the input pin (for PIR sensor)
int inputPinB = 3;               // PIRB
int pirState = LOW;             // we start, assuming no motion detected
int pirStateB = LOW;             // PIR B
int val = 1;                    // variable for reading the pin status
int valB = 1;                    // PIR B
void setup() {
  pinMode(ledPin, OUTPUT);      // declare LED as output
  pinMode(inputPin, INPUT);     // declare sensor as input
  pinMode(inputPinB, INPUT);     // PIr B
  Serial.begin(9600);
}
//////////////// PIR A
void loop(){
  val = digitalRead(inputPin);  // read input value
   if (val == LOW) {            // Zorgt dat hij de goed "richting"op gaat High is de pir anders om
   digitalWrite(ledPin, HIGH);  // turn LED ON
     delay(100);        // uitlezen van ?
 ////////////////   
    if (pirState == HIGH) {      // 
     Serial.println("Motion detected!");      // 
      pirState = LOW;
      delay(100); // weet niet maar zal iets met uitlezen zijn.
 ///////////////////////////
      }
  } else {     digitalWrite(ledPin, LOW); // 
             
    if (pirState == LOW){      // we have just turned of
    Serial.println("Motion ended!");      // 
    pirState = HIGH;
     delay(10000);  // Tijd lamp aan is
    }
  }
} 
/////////////////////

//}
////////////////PIR B
void loopB(){
  valB = digitalRead(inputPinB);  // read input value
   if (valB == LOW) {            // Zorgt dat hij de goed "richting"op gaat High is de pir anders om
   digitalWrite(ledPin, HIGH);  // turn LED ON
     delay(100);        // uitlezen van ?
 ////////////////   
    if (pirStateB == HIGH) {      // 
     Serial.println("Motion detected!");      // 
      pirStateB = LOW;
      delay(100); // weet niet maar zal iets met uitlezen zijn.
 ///////////////////////////
      }
  } else {     digitalWrite(ledPin, LOW); // 
             
    if (pirStateB == LOW){      // we have just turned of
    Serial.println("Motion ended!");      // 
    pirStateB = HIGH;
     delay(10000);  // Tijd lamp aan is
    }
  }
} 

if (valA == HIGH || valB == HIGH){  // heeft een van beide iets gezien?

if (valA == LOW|| valB == LOW){  // heeft een van beide iets gezien?

// Twee pirren onder het bed...
// Pir A en Pir B 
// het licht gaat aan als een van beide iets heeft gezien
 
int ledPin = 12;                 // MOSFET hangt aan deze pin
int inputPinA = 2;               // PIR A hangt aan deze pin
int inputPinB = 3;               // PIR B hangt aan deze pin
boolean valA = false;            // PIR A wordt hierin ingelezen
boolean valB = false;            // PIR B wordt hierin ingelezen

long secondsDelay = 10;           // vul hier in hoeveel seconden je licht aan moet blijven

void setup() {
  pinMode(ledPin, OUTPUT);       // LED is een uitgang
  pinMode(inputPinA, INPUT);     // Pir A is een ingang
  pinMode(inputPinB, INPUT);     // Pir B is een ingang
  Serial.begin(9600);
}

//de loop hieronder wordt eindeloos doorgelopen
void loop(){
  valA = digitalRead(inputPinA);       // lees pir A
  valB = digitalRead(inputPinB);       // lees pir B
   if (valA == HIGH || valB == HIGH){  // heeft een van beide iets gezien?
     digitalWrite(ledPin, HIGH);       // LED aan
     delay(secondsDelay * 1000);       // licht aan laten voor "secondsDelay" seconden
  } 
  else {     
     digitalWrite(ledPin, LOW);        // licht uit!
     delay(250);                       // wacht een kwart seconde tot de volgende keer uitlezen
  }
}