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
Contents
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:
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.
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)
Als we dit schema doorzetten naar de volgende tree krijg je de volgende tabel
dataArrayUp[1] = 0x03; //00000011
Dit schuift even door en op tree 4 zie je dat de eerste tree uit is gegaan
dataArrayUp[3] = 0x0E; //00001110
Door deze gegevens ontstaat er een soort waarheidstabel waaraan je kunt zien hoe het hele verhaal loopt.
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.
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″]