Lopende trapverlichting op 5V

De afgelopen weken ben ik druk bezig geweest met de trapverlichting.

Het is een onbewerkt filmpje hieronder, maar om even een idee te geven….

De trapverlichting had ik al redelijk snel werkend met de arduino, zodat ik een stap verder kon gaan. Ik heb er lang over gepuzzeld om alles op de arduino te laten lopen. Dat houdt het volgende in:

• De trapverlichting naar de eerste verdieping
• De overloop verlichting
• De trap verlichting naar zolder met daaraan gekoppeld de zolder verlichting.
De punten waar ik tegen aan liep waren de volgende:
1. Voor elke trap heb ik twee sensoren nodig
2. Voor de overloop heb ik twee sensoren nodig

Voor elke trap heb ik twee sensoren nodig

Dit omdat onder aan de trap moet worden bepaald of er iemand aan komt zodat de verlichting van onder na boven loopt
Boven aan de trap moet ook een sensor komen die detecteert of er iemand de trap af gaat. Deze sensor moet een seintje geven zodat de leds van boven naar beneden gaan branden.
Dus ik heb twee sensoren nodig.

Voor de overloop heb ik twee sensoren nodig

Dit omdat de overloop in een L-vorm is gebouwd en ik vanuit alle hoeken moet kunnen detecteren of er iemand de overloop op gaat en zo de verlichting aan moet worden geschakeld.
Op de overloop komen 3 leds die parallel zijn geschakeld aan elkaar. Hierdoor gaan ze gelijk branden en mocht er één kapot gaan, doen de andere twee het nog wel.

De aansturing

Voor de aansturing van de leds maak ik gebruik van de 74HC595 (schuif register). Deze wordt weer aangestuurd door middel van de Arduino, maar dat vind ik niet echt een goed idee. Dit omdat ik dan 3 Arduino’s zou moeten kopen als ik 3 verschillende plaatsen moet verlichten.
Als eerste heb ik nu de trap naar boven in elkaar gezet.

De stappen

Het idee ontwikkelen

Het idee is ontstaat doordat ik voor een deel mijn huis op 12Volt wil omzetten. Dit houdt in dat er een nieuw net naast de 220V komt te liggen in mijn huis voor de lampen en voedingen.
Ik ben aan het zoeken gegaan naar trapverlichting en kwam het volgende tegen:

trapverlichting
trapverlichting

Dit leek mij wel wat dus ik ben aan het ontwikkelen gegaan. Als snel was ik er achter dat de lampjes door middel van een schuifregister werden aan en uit gezet.
De Arduino stuurt het schuif register aan en deze de lampjes.
Dit systeem was snel in elkaar gezet op een breadboard in combinatie met de Arduino.

20141223_153752
Nu moest hier een sketch voor worden geschreven waarin de arduino werd aangestuurd. Hiervoor moest ik gebruik maken van de Arduino IDE.
Gelukkig werkt dit in C, waar ik toch redelijk ervaring in heb opgedaan. Dus dat was voor mij niet zo’n probleem en ‘google is your friend’. Dus aan het zoeken geslagen en na een poosje kwam ik een stukje software tegen waarmee ik het schuifregister kon aansturen

/*
  74HC595 met PIR-Sensoren en 1W LEDS

 Hardware:
 * 74HC595 shift register
 * LEDs attached to each of the outputs of the shift register
 * PIR_1 Sensor attached to pin 9
 * PIR_1 Sensor attached to pin 7

 */
//Pin connected to ST_CP of 74HC595
int latchPin =0;
//Pin connected to SH_CP of 74HC595
int clockPin = 4;
////Pin connected to DS of 74HC595
int dataPin = 3;
////Init ReadValue_1 and ReadValue_2 for digital(9) and digital (7)
int ReadValue_1; //PIR_1
int ReadValue_2; //PIR_2

//holders for infromation you're going to pass to shifting function
byte data;
byte dataArrayUp[11];
byte dataArrayDown[11];

void setup() {
  //set pins to output because they are addressed in the main loop
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin,OUTPUT);
  pinMode(dataPin,OUTPUT);  
  //pinMode(3,INPUT);
  //pinMode(4,INPUT);
 
  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.
 
  /* 00000001
  Deze string is als volgt opgebouwd:
  lNiet_Aangesloten | l14,l13 | l12,l11 | l10,l9 | l8,l7 | l6,l5 | l4,l3 | l2,l1
 
  */
 
  dataArrayUp[0] = 0x01;  //00000001
  dataArrayUp[1] = 0x03;  //00000011
  dataArrayUp[2] = 0x07;  //00000111
  dataArrayUp[3] = 0x0E;  //00001110
  dataArrayUp[4] = 0x1C;  //00011100
  dataArrayUp[5] = 0x38;  //00111000
  dataArrayUp[6] = 0x70;  //01110000
  dataArrayUp[7] = 0x60;  //01100000
  dataArrayUp[8] = 0x40;  //01000000
  dataArrayUp[10] = 0x00; //00000000
 

  dataArrayDown[0] = 0x00;  //00000000
  dataArrayDown[1] = 0x40;  //01000000
  dataArrayDown[2] = 0x60;  //01100000
  dataArrayDown[3] = 0x70;  //01110000
  dataArrayDown[4] = 0x38;  //00111000
  dataArrayDown[5] = 0x1C;  //00011100
  dataArrayDown[6] = 0x0E;  //00001110
  dataArrayDown[7] = 0x07;  //00000111
  dataArrayDown[8] = 0x03;  //00000011
  dataArrayDown[9] = 0x01;  //00000001
  dataArrayDown[10] = 0x00; //00000000
 
}

void loop() {

if (digitalRead(2)==HIGH) //van beneden naar boven
{
//##BEGIN - code voor schuiven naar result
  for (int j = 0; j < 11; j++) {
    //load the light sequence you want from array
    data = dataArrayUp[j];
     //ground latchPin and hold low for as long as you are transmitting
    digitalWrite(latchPin, 0);
    //move 'em out
    shiftOut(dataPin, clockPin, data);
    //return the latch pin high to signal chip that it
    //no longer needs to listen for information
    digitalWrite(latchPin, 1);
    delay(1000);
  }
  //Serial.println();
}
else{
      if (digitalRead(1)==HIGH) //van beneden naar boven
      {
      //##BEGIN - code voor schuiven naar result
        for (int j = 0; j < 11; j++) {
          //load the light sequence you want from array
          data = dataArrayDown[j];
           //ground latchPin and hold low for as long as you are transmitting
          digitalWrite(latchPin, 0);
          //move 'em out
          shiftOut(dataPin, clockPin, data);
          //return the latch pin high to signal chip that it
          //no longer needs to listen for information
          digitalWrite(latchPin, 1);
          delay(1000);
        }
        //Serial.println();
      }
    }

}

// the heart of the program
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);
}

Alles gereed maken

Uiteraard zitten er fouten in de software en in de hardware als deze voor het eerst is opgebouwd.
Een van de fouten was het aansturen van de verlichting op de overloop. Deze verlichting is niet nodig om te schakelen met de trap, omdat er sensoren op de overloop komen vanuit twee hoeken.
Ik heb gebruik gemaakt van een serie van ‘1’-en en ‘0’-en die ik in het schuifregister plaats, zodat het net lijkt of de lampjes mee gaan met degene die over de trap loopt.

dataArrayUp[0] = 0x01; //00000001
dataArrayUp[1] = 0x03; //00000011
dataArrayUp[2] = 0x07; //00000111
dataArrayUp[3] = 0x0E; //00001110
dataArrayUp[4] = 0x1C; //00011100
dataArrayUp[5] = 0x38; //00111000
dataArrayUp[6] = 0x70; //01110000
dataArrayUp[7] = 0x60; //01100000
dataArrayUp[8] = 0x40; //01000000
dataArrayUp[10] = 0x00; //00000000

dataArrayDown[0] = 0x00; //00000000
dataArrayDown[1] = 0x40; //01000000
dataArrayDown[2] = 0x60; //01100000
dataArrayDown[3] = 0x70; //01110000
dataArrayDown[4] = 0x38; //00111000
dataArrayDown[5] = 0x1C; //00011100
dataArrayDown[6] = 0x0E; //00001110
dataArrayDown[7] = 0x07; //00000111
dataArrayDown[8] = 0x03; //00000011
dataArrayDown[9] = 0x01; //00000001
dataArrayDown[10] = 0x00; //00000000

elke 0 zorgt er voor dat de led niet aan is. De 1 zorgt er voor dat de led brand.

In stand 1 van dataArrayUp (dit is om de trap op te lopen) gaat de led onderaan branden en de rest is uit.
dataArrayUp[0] = 0x01; //00000001
Je zou het kunnen zien dat ik gebruik maak van 7 led (het zijn er 14, maar er zijn er twee parallel geschakeld)

1
Als we dit schema doorzetten naar de volgende tree krijg je de volgende tabel

dataArrayUp[1] = 0x03; //00000011

2

Dit schuift even door en op tree 4 zie je dat de eerste tree uit is gegaan
dataArrayUp[3] = 0x0E; //00001110

3

Door deze gegevens ontstaat er een soort waarheidstabel waaraan je kunt zien hoe het hele verhaal loopt.

4
Zo snel als sensor 1 actief wordt (deze zit beneden aan de trap), wordt er omhoog gelopen. Dus moeten de led op de volgende manier gaan branden. Dit wordt ook wel een waarheidstabel genoemd.

5
Omdat de Arduino geen gebruik maakt van 1-tjes en 0-etjes, moet die worden omgerekend naar het hexadecimale talstelsel.
Dit loopt als volgt:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f (hexadecimaal)
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (decimaal)

Nadat dit allemaal is bepaald kon het programma worden ingevuld.

Einde van deel 1 van de lopende trapverlichting

 


 

[wysija_form id=”1″]

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *